Struct ExecutionEngine 

pub struct ExecutionEngine {
    pub process: Process<TestnetV0>,
}

Execution engine wrapping a snarkVM Process.

Fields

process: Process<TestnetV0>

Implementations

impl ExecutionEngine

pub fn new() -> Result<Self>

Initialize a new process using Process::load() (credits loaded by default).

pub fn new_with_v0_fee_keys() -> Result<Self>

Initialize with explicit V0 fee keys injected.

pub fn inject_v0_fee_keys(&mut self) -> Result<()>

Inject V0 fee proving/verifying keys for testnet fee_public support.

pub fn add_program(&self, program: &Program<TestnetV0>) -> Result<()>

Add a program to the engine.

pub fn authorize_and_execute_with_values( &self, private_key: &PrivateKey<TestnetV0>, program_id: &ProgramID<TestnetV0>, function_name: &str, values: Vec<Value<TestnetV0>>, rng: &mut TestRng, ) -> Result<(Response<TestnetV0>, Trace<TestnetV0>)>

Authorize and execute locally using pre-parsed snarkVM Value inputs. Use this variant when inputs include record ciphertexts that must be decrypted first.

pub fn authorize_and_execute( &self, private_key: &PrivateKey<TestnetV0>, program_id: &ProgramID<TestnetV0>, function_name: &str, inputs: Vec<&str>, rng: &mut TestRng, ) -> Result<(Response<TestnetV0>, Trace<TestnetV0>)>

Authorize and execute locally. Returns response + trace.

Inputs are parsed as snarkVM Values — record ciphertexts (e.g. record1...) are handled correctly, unlike raw string inputs.

pub fn prove_and_package( &self, trace: Trace<TestnetV0>, private_key: &PrivateKey<TestnetV0>, program_id: &ProgramID<TestnetV0>, function_name: &str, base_fee: u64, priority_fee: u64, query: &impl QueryTrait<TestnetV0>, rng: &mut TestRng, ) -> Result<Transaction<TestnetV0>>

Prove execution + fee, verify, package into Transaction.

pub fn inner(&self) -> &Process<TestnetV0>

Reference to the inner Process.

pub fn deploy_program<R: Rng + CryptoRng>( &self, program: &Program<TestnetV0>, rng: &mut R, ) -> Result<Deployment<TestnetV0>>

Pure program deployment proof — generates a Deployment from source.

This only proves the program circuit. Fee and transaction packaging must be done separately via build_deployment_transaction.

pub fn build_deployment_transaction<R: Rng + CryptoRng>( &self, private_key: &PrivateKey<TestnetV0>, _program: &Program<TestnetV0>, deployment: &Deployment<TestnetV0>, base_fee: u64, priority_fee_in_microcredits: u64, _consensus_version: ConsensusVersion, query: &impl QueryTrait<TestnetV0>, rng: &mut R, ) -> Result<Transaction<TestnetV0>>

Full deployment pipeline: prove program → authorize fee → prove fee → verify → package into Transaction.

This is the equivalent of JS SDK’s buildDeploymentTransaction.

base_fee is the minimum deployment cost (use ExecutionEngine::deployment_cost_minimum to compute it). priority_fee_in_microcredits is an additional fee on top. consensus_version determines which cost formula applies (TestnetV0 uses V14). query supplies the current state root (from AleoHttpClient::fetch_state_root).

pub fn deployment_cost_minimum( &self, deployment: &Deployment<TestnetV0>, _consensus_version: ConsensusVersion, ) -> Result<u64>

Compute the minimum deployment cost for a deployment at the given consensus version.

pub fn verify_execution_transaction( &self, execution: &Execution<TestnetV0>, ) -> Result<()>

Verify an execute transaction’s proof.

The program must already be registered in this engine via add_program().

pub fn verify_deployment_transaction( &self, deployment: &Deployment<TestnetV0>, rng: &mut TestRng, ) -> Result<()>

Verify a deploy transaction’s proof. Uses an empty engine (no user programs loaded) to avoid edition-zero collision.