Method execute_function_offline

wasm/src/programs/manager/execute.rs:156–226

(
        private_key: &PrivateKey,
        program: &str,
        function: &str,
        inputs: Array,
        prove_execution: bool,
        cache: bool,
        imports: Option<Object>,
        p

    #[wasm_bindgen(js_name = executeFunctionOffline)]
    #[allow(clippy::too_many_arguments)]
    pub async fn execute_function_offline(
        private_key: &PrivateKey,
        program: &str,
        function: &str,
        inputs: Array,
        prove_execution: bool,
        cache: bool,
        imports: Option<Object>,
        proving_key: Option<ProvingKey>,
        verifying_key: Option<VerifyingKey>,
        url: Option<String>,
        query: Option<QueryOption>,
        edition: Option<u16>,
        program_imports: Option<ProgramImports>,
    ) -> Result<ExecutionResponse, String> {
        let node_url = url.as_deref().unwrap_or(DEFAULT_URL);
        let inputs = inputs.to_vec();
        let rng = &mut rand::rng();
        let edition = edition.unwrap_or(1);

        let mut resolved = ResolvedProcess::resolve(&program_imports, program, edition, imports)?;
        let program_native = resolved.program().clone();
        let process = resolved.process_mut();

        let (response, mut trace) = execute_program!(
            process,
            process_inputs!(inputs),
            program,
            function,
            private_key,
            proving_key,
            verifying_key,
            rng,
            edition
        );

        let mut execution_response = if prove_execution {
            log("Preparing inclusion proofs for execution");
            if let Some(ref query) = query {
                trace.prepare_async(query).await.map_err(|err| err.to_string())?;
            } else {
                let function_name = IdentifierNative::from_str(function).map_err(|err| err.to_string())?;
                let view_key =
                    ViewKeyNative::try_from(PrivateKeyNative::from(private_key)).map_err(|err| err.to_string())?;
                let query = SnapshotQuery::try_from_inputs(
                    node_url,
                    &program_native,
                    &function_name,
                    &view_key,
                    &inputs.to_vec(),
                )
                .await
                .map_err(|err| err.to_string())?;
                trace.prepare_async(&query).await.map_err(|err| err.to_string())?;
            };

            log("Proving execution");
            let locator = program_native.id().to_string().add("/").add(function);