Rust Create Canister / Inter-Canister Calls

Steve · February 20, 2021, 4:22pm

Does anyone know how to use the Rust CDK call function?

dfinity/cdk-rs/blob/ee145313fa9feae4ae0ab7602d8fca39374c3fb8/src/ic-cdk/src/api/call.rs#L140


        let mut state = state.borrow_mut();
        state.result = Some(Err((
            RejectionCode::from(err_code),
            "Couldn't send message".to_string(),
        )));
    }
    CallFuture { state }
}
/// Perform an asynchronous call to another canister via ic0.
pub async fn call<T: ArgumentEncoder, R: for<'a> ArgumentDecoder<'a>>(
    id: Principal,
    method: &str,
    args: T,
) -> CallResult<R> {
    let args_raw = encode_args(args).expect("Failed to encode arguments.");
    let bytes = call_raw(id, method, args_raw, 0).await?;
    decode_args(&bytes).map_err(|err| trap(&format!("{:?}", err)))
}
pub async fn call_with_payment<T: ArgumentEncoder, R: for<'a> ArgumentDecoder<'a>>(

I’m trying to call the management canister to create a new canister from wasm. It looks like I just need to implement the ArgumentEncoder trait on my struct, but it feels a bit laborious to do that for all my types.

github.com

dfinity/candid/blob/ea2c72f57e4b1cde99fad3b61308c0e979a65e3a/rust/candid/src/ser.rs#L399


        let mut ty_encode = Vec::new();
        for t in self.args.iter() {
            self.encode(&mut ty_encode, t)?;
        }
        self.result.append(&mut ty_encode);
        Ok(())
    }
}
/// Allow encoding of any serializable value.
pub trait ArgumentEncoder {
    /// Encode a value of type [Self].
    fn encode(self, ser: &mut IDLBuilder) -> Result<()>;
}
/// Decode an empty tuple.
impl ArgumentEncoder for () {
    fn encode(self, _de: &mut IDLBuilder) -> Result<()> {
        Ok(())
    }
}

chenyan · February 20, 2021, 5:58pm

ArgumentEncoder is implemented for all tuple types (T1, T2, ...), where Ti: CandidType. If you have a custom struct, you only need to #[derive(CandidType, Deserialize)], then pass in args as a tuple, for example (your_struct, 42, "Text").

Steve · February 22, 2021, 3:59pm

Hey @chenyan - I’m having issues with ArgumentDecoder now. If its not too much hassle, could share an example of just calling a canister, and getting the result?

chenyan · February 22, 2021, 5:41pm

let (first_result, second_result) : (first_result_type, second_result_type) = 
  api::call::call(canister_id, "method", (first_arg, second_arg)).await?;

Both argument and return types are tuples. The type annotation on return type is required, as it cannot be inferred by Rust.

Steve · February 22, 2021, 6:32pm

Thanks, let me give that a shot! Just so I make sure I understand

(first_result_type, second_result_type) → (candid::Nat, candid::Principle)

chenyan · February 22, 2021, 7:15pm

That’s the return type of your method. If you are not sure, can you post the did file for that method?

Steve · February 22, 2021, 10:47pm

@chenyan - sorry for the confusion here is a full example

let canister : (candid::Principal) = ic_cdk::api::call(candid::Principal::management_canister(), "create_canister", ()).await?;

Yields the following error:

the trait `for<'a> ArgumentDecoder<'a>` is not implemented for `ic_types::Principal`

chenyan · February 22, 2021, 11:26pm

The return type is a tuple, even if it has only one value, so this will work:
let (canister,) : (candid::Principal,)

Steve · February 23, 2021, 12:00am

DOH! Yes its working now. Thank you!!