Struct darkfi::runtime::vm_runtime::Runtime

pub struct Runtime {
    pub instance: Arc<Instance>,
    pub store: Store,
    pub ctx: FunctionEnv<Env>,
}

Define a wasm runtime.

Fields

instance: Arc<Instance>

A wasm instance

store: Store

A wasm store (global state)

ctx: FunctionEnv<Env>

Implementations

impl Runtime

pub fn new( wasm_bytes: &[u8], blockchain: BlockchainOverlayPtr, contract_id: ContractId, verifying_block_height: u32, block_target: u32, tx_hash: TransactionHash, call_idx: u8, ) -> Result<Self>

Create a new wasm runtime instance that contains the given wasm module.

fn call(&mut self, section: ContractSection, payload: &[u8]) -> Result<Vec<u8>>

Call a contract method defined by a ContractSection using a supplied payload. Returns a Vec<u8> corresponding to the result data of the call. For calls that do not return any data, an empty Vec<u8> is returned.

pub fn deploy(&mut self, payload: &[u8]) -> Result<()>

This function runs when a smart contract is initially deployed, or re-deployed.

The runtime will look for an __initialize symbol in the wasm code, and execute it if found. Optionally, it is possible to pass in a payload for any kind of special instructions the developer wants to manage in the initialize function.

This process is supposed to set up the overlay trees for storing the smart contract state, and it can create, delete, modify, read, and write to databases it’s allowed to. The permissions for this are handled by the ContractId in the overlay db API so we assume that the contract is only able to do write operations on its own overlay trees.

pub fn metadata(&mut self, payload: &[u8]) -> Result<Vec<u8>>

This function runs first in the entire scheme of executing a smart contract.

The runtime will look for a __metadata symbol in the wasm code and execute it. It is supposed to correctly extract public inputs for any ZK proofs included in the contract calls, and also extract the public keys used to verify the call/transaction signatures.

pub fn exec(&mut self, payload: &[u8]) -> Result<Vec<u8>>

This function runs when someone wants to execute a smart contract.

The runtime will look for an __entrypoint symbol in the wasm code, and execute it if found. A payload is also passed as an instruction that can be used inside the vm by the runtime.

pub fn apply(&mut self, update: &[u8]) -> Result<()>

This function runs after successful execution of exec and tries to apply the state change to the overlay databases.

The runtime will lok for an __update symbol in the wasm code, and execute it if found. The function does not take an arbitrary payload, but just takes a state update from env and passes it into the wasm runtime.

fn print_logs(&self)

Prints the wasm contract logs.

pub fn gas_used(&mut self) -> u64

Calculate the remaining gas using wasm’s concept of metering points.

fn gas_info(&mut self) -> String

fn set_memory_page_size(&mut self, pages: u32) -> Result<Pages>

Set the memory page size. Returns the previous memory size.

fn take_memory(&mut self) -> Memory

Take Memory by value. Needed to modify the Memory object Will panic if memory isn’t set.

fn copy_to_memory(&self, payload: &[u8]) -> Result<()>

Copy payload to the start of the memory

fn serialize_payload(cid: &ContractId, payload: &[u8]) -> Vec<u8>

Serialize contract payload to the format accepted by the runtime functions. We keep the same payload as a slice of bytes, and prepend it with a ContractId, and then a little-endian u64 to tell the payload’s length.