Method get_info

src/exp.rs:813–902

(&self, helper: &MyHelper, is_encode: bool)

}
impl Method {
    pub fn get_info(&self, helper: &MyHelper, is_encode: bool) -> Result<MethodInfo> {
        if is_encode && self.method == "__init_args" {
            if let Some(IDLValue::Blob(bytes)) = helper.env.0.get(&self.canister) {
                use ic_wasm::{metadata::get_metadata, utils::parse_wasm};
                let m = parse_wasm(bytes, false)?;
                let args = get_metadata(&m, "candid:args");
                let candid = get_metadata(&m, "candid:service");
                let canister_id = Principal::anonymous();
                match args {
                    None => {
                        eprintln!("Warning: no candid:args metadata in the Wasm module, use types inferred from textual value.");
                        return Ok(MethodInfo {
                            canister_id,
                            signature: None,
                            profiling: None,
                        });
                    }
                    Some(args) => {
                        let candid = candid
                            .as_ref()
                            .map(|x| std::str::from_utf8(x).unwrap())
                            .unwrap_or("service : {}");
                        let (env, ty) = candid_parser::utils::merge_init_args(
                            candid,
                            std::str::from_utf8(&args)?,
                        )?;
                        let init_args = find_init_args(&env, &ty).expect("invalid init arg types");
                        let signature = Some((
                            env,
                            Function {
                                args: init_args,
                                rets: Vec::new(),
                                modes: Vec::new(),
                            },
                        ));
                        return Ok(MethodInfo {
                            canister_id,
                            signature,
                            profiling: None,
                        });
                    }
                }
            }
        }
        let canister_id = str_to_principal(&self.canister, helper)?;
        let agent = &helper.agent;
        let mut map = helper.canister_map.borrow_mut();
        Ok(match map.get(agent, &canister_id) {
            Err(_) => MethodInfo {
                canister_id,
                signature: None,
                profiling: None,
            },
            Ok(info) => {
                let signature = if self.method == "__init_args" {
                    eprintln!(
                        "Warning: no init args in did file, use types inferred from textual value."
                    );