Method devnode_execute

wasm/src/programs/manager/execute.rs:384–483

(
        private_key: &PrivateKey,
        program: &str,
        function: &str,
        inputs: Array,
        priority_fee_credits: f64,
        fee_record: Option<RecordPlaintext>,
        url: O

    #[wasm_bindgen(js_name = buildDevnodeExecutionTransaction)]
    #[allow(clippy::too_many_arguments)]
    pub async fn devnode_execute(
        private_key: &PrivateKey,
        program: &str,
        function: &str,
        inputs: Array,
        priority_fee_credits: f64,
        fee_record: Option<RecordPlaintext>,
        url: Option<String>,
        imports: Option<Object>,
        edition: Option<u16>,
        program_imports: Option<ProgramImports>,
    ) -> Result<Transaction, String> {
        log("Loading the SnarkVM process");
        let node_url = url.as_deref().unwrap_or(LOCAL_URL);
        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();

        // Initialize the rng.
        let rng = &mut rand::rng();
        let program_id = program_native.id().to_string();
        let inputs = process_inputs!(inputs);

        // Add the program to the process (no-op if ensure_program already added it).
        if program_id != "credits.aleo" && !process.contains_program(program_native.id()) {
            log("Adding program to the process");
            process.lock().add_program_with_edition(&program_native, edition).map_err(|e| e.to_string())?;
        }

        // Generate the authorization.
        let authorization = process
            .authorize::<CurrentAleo, _>(&private_key, &program_id, function, inputs.iter(), rng)
            .map_err(|e| e.to_string())?;

        // Get the state root.
        let state_root = latest_stateroot(node_url).await.map_err(|e| e.to_string())?;

        // Get the consensus version.
        let latest_height = latest_block_height(node_url).await.map_err(|err| err.to_string())?;
        let consensus_version = CurrentNetwork::CONSENSUS_VERSION(latest_height).map_err(|err| err.to_string())?;

        // Execute without proving.
        let execution = ExecutionNative::from(authorization.transitions().values().cloned(), state_root, None)
            .map_err(|e| e.to_string())?;

        // Calculate the cost.
        let (cost, _) = execution_cost(&process, &execution, consensus_version).map_err(|e| e.to_string())?;

        // Generate the fee authorization.
        let id = authorization.to_execution_id().map_err(|e| e.to_string())?;

        // Convert the priority fee to microcredits.
        let priority_fee_microcredits = (priority_fee_credits * 1_000_000.0) as u64;

        let fee_authorization = match fee_record {
            Some(fee_record) => {