VM

pub struct VM<N: Network, C: ConsensusStorage<N>> {
    /// The process for program execution
    process: Arc<RwLock<Process<N>>>,
    /// The puzzle for proof-of-work
    puzzle: Puzzle<N>,
    /// The consensus storage backend
    store: ConsensusStore<N, C>,
    /// Cache of partially-verified transactions
    partially_verified_transactions: Arc<RwLock<LruCache<TransactionCacheKey<N>, N::TransmissionChecksum>>>,
    /// Program restrictions (e.g., banned programs)
    restrictions: Restrictions<N>,
    /// Channel for sequential operations
    sequential_ops_tx: Arc<RwLock<Option<mpsc::Sender<SequentialOperationRequest<N>>>>>,
    /// Thread handle for sequential operations
    sequential_ops_thread: Arc<Mutex<Option<thread::JoinHandle<()>>>>,
}

pub fn from(store: ConsensusStore<N, C>) -> Result<Self>

use snarkvm_synthesizer::VM;
use snarkvm_ledger_store::{ConsensusStore, helpers::memory::ConsensusMemory};
use aleo_std::StorageMode;

type CurrentNetwork = snarkvm_console::network::MainnetV0;

let store = ConsensusStore::<CurrentNetwork, ConsensusMemory<_>>::open(
    StorageMode::Production
)?;
let vm = VM::from(store)?;

pub fn deploy<R: Rng + CryptoRng>(
    &self,
    private_key: &PrivateKey<N>,
    program: &Program<N>,
    fee_record: Option<Record<N, Plaintext<N>>>,
    priority_fee_in_microcredits: u64,
    query: Option<&dyn QueryTrait<N>>,
    rng: &mut R,
) -> Result<Transaction<N>, VmDeployError>

use snarkvm_console::program::Program;

let program_source = r"
program token.aleo;

record token:
    owner as address.private;
    amount as u64.private;

function mint:
    input r0 as address.private;
    input r1 as u64.private;
    cast r0 r1 into r2 as token.record;
    output r2 as token.record;
";

let program = Program::from_str(program_source)?;
let deployment = vm.deploy(
    &private_key,
    &program,
    Some(fee_record),
    10_000_000, // 10 credit priority fee
    None,
    &mut rng,
)?;

pub fn execute<R: Rng + CryptoRng>(
    &self,
    private_key: &PrivateKey<N>,
    (program_id, function_name): (impl TryInto<ProgramID<N>>, impl TryInto<Identifier<N>>),
    inputs: impl ExactSizeIterator<Item = impl TryInto<Value<N>>>,
    fee_record: Option<Record<N, Plaintext<N>>>,
    priority_fee_in_microcredits: u64,
    query: Option<&dyn QueryTrait<N>>,
    rng: &mut R,
) -> Result<Transaction<N>, VmExecError>

use snarkvm_console::program::Value;

let inputs = [
    Value::from_str("aleo1...")?,  // recipient address
    Value::from_str("1000u64")?,   // amount
];

let transaction = vm.execute(
    &private_key,
    ("credits.aleo", "transfer_public"),
    inputs.iter(),
    None,              // public fee
    0,                 // no priority fee
    None,
    &mut rng,
)?;

pub fn execute_with_response<R: Rng + CryptoRng>(
    &self,
    private_key: &PrivateKey<N>,
    (program_id, function_name): (impl TryInto<ProgramID<N>>, impl TryInto<Identifier<N>>),
    inputs: impl ExactSizeIterator<Item = impl TryInto<Value<N>>>,
    fee_record: Option<Record<N, Plaintext<N>>>,
    priority_fee_in_microcredits: u64,
    query: Option<&dyn QueryTrait<N>>,
    rng: &mut R,
) -> Result<(Transaction<N>, Response<N>), VmExecError>

pub fn authorize<R: Rng + CryptoRng>(
    &self,
    private_key: &PrivateKey<N>,
    program_id: impl TryInto<ProgramID<N>>,
    function_name: impl TryInto<Identifier<N>>,
    inputs: impl IntoIterator<IntoIter = impl ExactSizeIterator<Item = impl TryInto<Value<N>>>>,
    rng: &mut R,
) -> Result<Authorization<N>, VmAuthError>

pub fn execute_authorization<R: Rng + CryptoRng>(
    &self,
    execute_authorization: Authorization<N>,
    fee_authorization: Option<Authorization<N>>,
    query: Option<&dyn QueryTrait<N>>,
    rng: &mut R,
) -> Result<Transaction<N>>

pub fn authorize_fee_private<R: Rng + CryptoRng>(
    &self,
    private_key: &PrivateKey<N>,
    credits: Record<N, Plaintext<N>>,
    base_fee_in_microcredits: u64,
    priority_fee_in_microcredits: u64,
    deployment_or_execution_id: Field<N>,
    rng: &mut R,
) -> Result<Authorization<N>>

pub fn authorize_fee_public<R: Rng + CryptoRng>(
    &self,
    private_key: &PrivateKey<N>,
    base_fee_in_microcredits: u64,
    priority_fee_in_microcredits: u64,
    deployment_or_execution_id: Field<N>,
    rng: &mut R,
) -> Result<Authorization<N>>

pub fn add_next_block(&self, block: &Block<N>) -> Result<()>

pub fn finalize(
    &self,
    state: FinalizeGlobalState,
    ratifications: &[Ratify<N>],
    solutions: &Solutions<N>,
    transactions: impl Iterator<Item = &Transaction<N>>,
) -> Result<Vec<FinalizeOperation<N>>>

pub fn finalize_store(&self) -> &FinalizeStore<N, C::FinalizeStorage>

pub fn block_store(&self) -> &BlockStore<N, C::BlockStorage>

pub fn transaction_store(&self) -> &TransactionStore<N, C::TransactionStorage>

pub fn transition_store(&self) -> &TransitionStore<N, C::TransitionStorage>

pub fn genesis_beacon<R: Rng + CryptoRng>(
    &self,
    private_key: &PrivateKey<N>,
    rng: &mut R,
) -> Result<Block<N>>

pub fn genesis_quorum<R: Rng + CryptoRng>(
    &self,
    private_key: &PrivateKey<N>,
    committee: Committee<N>,
    public_balances: IndexMap<Address<N>, u64>,
    bonded_balances: IndexMap<Address<N>, (Address<N>, Address<N>, u64)>,
    rng: &mut R,
) -> Result<Block<N>>

pub fn contains_program(&self, program_id: &ProgramID<N>) -> bool

pub fn process(&self) -> Arc<RwLock<Process<N>>>

partially_verified_transactions: Arc<RwLock<LruCache<TransactionCacheKey<N>, N::TransmissionChecksum>>>

#[derive(Clone)]
pub struct VM<N: Network, C: ConsensusStorage<N>> { ... }