move call/encode as value, instead of command (#7)

* move call/encode as value, instead of command

* fix

* readme

* decode

Co-authored-by: chenyan-dfinity <[email protected]>

Author: chenyan2002

README.md

@@ -8,25 +8,24 @@ ic-repl --replica [local|ic|url] --config <dhall config> [script file]
 
 ```
 <command> := 
- | import <id> = <text> ( : <text> )?   // bind canister URI to <id>, with optional did file
- | call <name> . <name> ( <val>,* )     // call a canister method with candid arguments
- | encode <name> . <name> ( <val>,* )   // encode candid arguments with respect to a canister method signature
- | export <text>                        // export command history to a file that can be run in ic-repl as a script
- | load <text>                          // load and run a script file
- | config <text>                        // set config for random value generator in dhall format
- | let <id> = <val>                     // bind <val> to a variable <id>
- | <val>                                // show the value of <val>
- | assert <val> <binop> <val>           // assertion
- | identity <id> <text>?                // switch to identity <id>, with optional Ed25519 pem file
-
-<val> := 
- | <candid val>          // any candid value
- | <var> <selector>*     // variable with optional selectors
- | file <text>           // load external file as a blob value
- | encode ( <val),* )    // encode candid arguments as a blob value, use the `encode` command if you can
+ | import <id> = <text> (as <text>)?     // bind canister URI to <id>, with optional did file
+ | export <text>                         // export command history to a file that can be run in ic-repl as a script
+ | load <text>                           // load and run a script file
+ | config <text>                         // set config for random value generator in dhall format
+ | let <id> = <exp>                      // bind <exp> to a variable <id>
+ | <exp>                                 // show the value of <exp>
+ | assert <exp> <binop> <exp>            // assertion
+ | identity <id> <text>?                 // switch to identity <id>, with optional Ed25519 pem file
+<exp> := 
+ | <candid val>                          // any candid value
+ | <var> <selector>*                     // variable with optional selectors
+ | file <text>                           // load external file as a blob value
+ | call <name> . <name> ( <exp>,* )      // call a canister method, and store the result as a single value
+ | encode (<name> . <name>)? ( <exp>,* ) // encode candid arguments as a blob value
+ | decode (as <name> . <name>)? <exp>    // decode blob as candid values
 <var> := 
  | <id>                  // variable name 
- | _                     // previous call result is bind to `_` 
+ | _                     // previous eval of exp is bind to `_` 
 <selector> :=
  | ?                     // select opt value
  | . <name>              // select field name from record or variant value
@@ -55,8 +54,7 @@ assert _ == result;
 install.sh
 ```
 #!/usr/bin/ic-repl
-call "aaaaa-aa".provisional_create_canister_with_cycles(record { settings: null; amount: null });
-let id = _;
+let id = call "aaaaa-aa".provisional_create_canister_with_cycles(record { settings: null; amount: null });
 call "aaaaa-aa".install_code(
   record {
     arg = encode ();
@@ -73,7 +71,7 @@ call canister.greet("test");
 wallet.sh
 ```
 #!/usr/bin/ic-repl
-import wallet = "rwlgt-iiaaa-aaaaa-aaaaa-cai" : "wallet.did";
+import wallet = "rwlgt-iiaaa-aaaaa-aaaaa-cai" as "wallet.did";
 identity default "~/.config/dfx/identity/default/identity.pem";
 call wallet.wallet_create_canister(
   record {
@@ -86,26 +84,25 @@ call wallet.wallet_create_canister(
     };
   },
 )
-let id = _.Ok;
-encode "aaaaa-aa".install_code(
+let id = _.Ok.canister_id;
+let msg = encode "aaaaa-aa".install_code(
   record {
     arg = encode ();
     wasm_module = file "your_wasm_file.wasm";
     mode = variant { install };
-    canister_id = id.canister_id;
+    canister_id = id;
   },
 );
-let msg = _;
-call wallet.wallet_call(
+let res = call wallet.wallet_call(
   record {
     args = msg;
     cycles = 0;
     method_name = "install_code";
     canister = principal "aaaaa-aa";
   },
 );
-let canister = id.canister_id;
-call canister.greet("test");
+decode as "aaaaa-aa".install_code res.Ok.return;
+call id.greet("test");
 ```
 
 ## Notes for Rust canisters
@@ -131,9 +128,8 @@ If you are writing your own `.did` file, you can also supply the did file via th
 * Acess to service init type
 * `IDLValue::Blob` for efficient blob serialization
 * Tokenization for partial parser (variable needs a preceding space for autocompletion)
-* Autocompletion within Candid value
+* Rename `Value` module to `Exp`
+* Autocompletion within Candid value; autocompletion for decode method
 * Robust support for `~=`, requires inferring principal types
-* Bind multiple return values to `_`
 * Loop detection for `load`
-* Import external identity
 * Assert upgrade correctness

src/command.rs

@@ -3,9 +3,7 @@ use super::helper::{did_to_canister_info, MyHelper};
 use super::token::{ParserError, Tokenizer};
 use super::value::Value;
 use anyhow::{anyhow, Context};
-use candid::{
-    parser::configs::Configs, parser::value::IDLValue, types::Function, IDLArgs, Principal, TypeEnv,
-};
+use candid::{parser::configs::Configs, parser::value::IDLValue, Principal, TypeEnv};
 use ic_agent::Agent;
 use pretty_assertions::{assert_eq, assert_ne};
 use std::path::{Path, PathBuf};
@@ -16,12 +14,6 @@ use terminal_size::{terminal_size, Width};
 pub struct Commands(pub Vec<Command>);
 #[derive(Debug, Clone)]
 pub enum Command {
-    Call {
-        canister: String,
-        method: String,
-        args: Vec<Value>,
-        encode_only: bool,
-    },
     Config(String),
     Show(Value),
     Let(String, Value),
@@ -41,54 +33,6 @@ pub enum BinOp {
 impl Command {
     pub fn run(self, helper: &mut MyHelper) -> anyhow::Result<()> {
         match self {
-            Command::Call {
-                canister,
-                method,
-                args,
-                encode_only,
-            } => {
-                let try_id = Principal::from_text(&canister);
-                let canister_id = match try_id {
-                    Ok(ref id) => id,
-                    Err(_) => match helper.env.0.get(&canister) {
-                        Some(IDLValue::Principal(id)) => id,
-                        _ => return Err(anyhow!("{} is not a canister id", canister)),
-                    },
-                };
-                let agent = &helper.agent;
-                let mut map = helper.canister_map.borrow_mut();
-                let info = map.get(&agent, &canister_id)?;
-                let func = info
-                    .methods
-                    .get(&method)
-                    .ok_or_else(|| anyhow!("no method {}", method))?;
-                let mut values = Vec::new();
-                for arg in args.into_iter() {
-                    values.push(arg.eval(&helper)?);
-                }
-                let args = IDLArgs { args: values };
-                if encode_only {
-                    let bytes = args.to_bytes_with_types(&info.env, &func.args)?;
-                    let res = IDLValue::Vec(bytes.into_iter().map(IDLValue::Nat8).collect());
-                    println!("{}", res);
-                    helper.env.0.insert("_".to_string(), res);
-                    return Ok(());
-                }
-                let time = Instant::now();
-                let res = call(&agent, &canister_id, &method, &args, &info.env, &func)?;
-                let duration = time.elapsed();
-                println!("{}", res);
-                let width = if let Some((Width(w), _)) = terminal_size() {
-                    w as usize
-                } else {
-                    80
-                };
-                println!("{:>width$}", format!("({:.2?})", duration), width = width);
-                // TODO multiple values
-                for arg in res.args.into_iter() {
-                    helper.env.0.insert("_".to_string(), arg);
-                }
-            }
             Command::Import(id, canister_id, did) => {
                 if let Some(did) = &did {
                     let path = resolve_path(&helper.base_path, did);
@@ -130,8 +74,17 @@ impl Command {
             }
             Command::Config(conf) => helper.config = Configs::from_dhall(&conf)?,
             Command::Show(val) => {
+                let time = Instant::now();
                 let v = val.eval(&helper)?;
+                let duration = time.elapsed();
                 println!("{}", v);
+                helper.env.0.insert("_".to_string(), v);
+                let width = if let Some((Width(w), _)) = terminal_size() {
+                    w as usize
+                } else {
+                    80
+                };
+                println!("{:>width$}", format!("({:.2?})", duration), width = width);
             }
             Command::Identity(id, opt_pem) => {
                 use ic_agent::Identity;
@@ -216,38 +169,6 @@ impl std::str::FromStr for Commands {
     }
 }
 
-#[tokio::main]
-async fn call(
-    agent: &Agent,
-    canister_id: &Principal,
-    method: &str,
-    args: &IDLArgs,
-    env: &TypeEnv,
-    func: &Function,
-) -> anyhow::Result<IDLArgs> {
-    let args = args.to_bytes_with_types(env, &func.args)?;
-    let bytes = if func.is_query() {
-        agent
-            .query(canister_id, method)
-            .with_arg(args)
-            .with_effective_canister_id(canister_id.clone())
-            .call()
-            .await?
-    } else {
-        let waiter = delay::Delay::builder()
-            .exponential_backoff(std::time::Duration::from_secs(1), 1.1)
-            .timeout(std::time::Duration::from_secs(60 * 5))
-            .build();
-        agent
-            .update(canister_id, method)
-            .with_arg(args)
-            .with_effective_canister_id(canister_id.clone())
-            .call_and_wait(waiter)
-            .await?
-    };
-    Ok(IDLArgs::from_bytes_with_types(&bytes, env, &func.rets)?)
-}
-
 pub fn resolve_path(base: &Path, file: &str) -> PathBuf {
     let file = PathBuf::from(shellexpand::tilde(file).into_owned());
     if file.is_absolute() {

src/grammar.lalrpop

@@ -1,4 +1,4 @@
-use super::value::{Field, Value, Selector};
+use super::value::{Field, Value, Selector, Method};
 use candid::parser::types::{IDLType, TypeField, PrimType, FuncType, FuncMode, Binding};
 use candid::parser::typing::{TypeEnv, check_unique};
 use super::token::{Token, error2, LexicalError, Span};
@@ -34,6 +34,8 @@ extern {
         "principal" => Token::Principal,
         "call" => Token::Call,
         "encode" => Token::Encode,
+        "decode" => Token::Decode,
+        "as" => Token::As,
         "config" => Token::Config,
         "assert" => Token::Assert,
         "let" => Token::Let,
@@ -63,19 +65,13 @@ pub Commands: Commands = SepBy<Command, ";"> => Commands(<>);
 
 // Command
 pub Command: Command = {
-    "call" <canister:Name> "." <method:Name> "(" <args: SepBy<Value, ",">> ")"? => {
-         Command::Call{canister, method, args, encode_only: false}
-    },
-    "encode" <canister:Name> "." <method:Name> "(" <args: SepBy<Value, ",">> ")"? => {
-         Command::Call{canister, method, args, encode_only: true}
-    },
     "config" <Text> => Command::Config(<>),
-    <Value> => Command::Show(<>),
+    Value => Command::Show(<>),
     "assert" <left:Value> <op:BinOp> <right:Value> => Command::Assert(op, left, right),
     "let" <id:"id"> "=" <val:Value> => Command::Let(id, val),
     "export" <Text> => Command::Export(<>),
     "load" <Text> => Command::Load(<>),
-    "import" <id:"id"> "=" <uri:Sp<Text>> <did:(":" <Text>)?> =>? {
+    "import" <id:"id"> "=" <uri:Sp<Text>> <did:("as" <Text>)?> =>? {
          let principal = Principal::from_text(&uri.0).map_err(|e| error2(e, uri.1))?;
          Ok(Command::Import(id, principal, did))
     },
@@ -84,10 +80,13 @@ pub Command: Command = {
 
 pub Value: Value = {
   Arg => <>,
-  <v:"id"> <path:(<Selector>)*> => Value::Path(v, path),
+  Variable => <>,
   "file" <Text> => Value::Blob(<>),
-  "encode" <Values> => Value::Args(<>),
+  "call" <method:Method> <args:Values> => Value::Method{method:Some(method), args, encode_only: false},
+  "encode" <method:Method?> <args:Values> => Value::Method{method, args, encode_only: true},
+  "decode" <method:("as" <Method>)?> <blob:Value> => Value::Decode{method, blob:Box::new(blob)},
 }
+Variable: Value = <v:"id"> <path:(<Selector>)*> => Value::Path(v, path);
 Selector: Selector = {
      "?" => Selector::Field("?".to_string()),
      "." <Name> => Selector::Field(<>),
@@ -96,6 +95,7 @@ Selector: Selector = {
        Ok(Selector::Index(idx))
      }
 }
+Method: Method = <canister:Name> "." <method:Name> => Method { canister, method };
 
 BinOp: BinOp = {
   "==" => BinOp::Equal,

src/token.rs

@@ -64,6 +64,10 @@ pub enum Token {
     Call,
     #[token("encode")]
     Encode,
+    #[token("decode")]
+    Decode,
+    #[token("as")]
+    As,
     #[token("config")]
     Config,
     #[token("let")]