Struct SystemRuntime 

pub struct SystemRuntime { /* private fields */ }

A system runtime instance.

System runtimes are trusted programs executed through Wasmtime and reused across calls. This wrapper owns:

• a cached, compiled+instantiated Wasmtime runtime (CompiledRuntime),
• the per-call RuntimeContext (ctx) which is swapped into the cached store on execution,
• an optional resumable interruption state used when system runtimes request an interruption.
• a flag indicating whether Wasmtime fuel metering is enabled (consume_fuel).

The runtime is keyed by code_hash so that we can cache compiled artifacts and instances.

Implementations

impl SystemRuntime

pub fn reset_cached_runtimes()

Clears the per-thread cache of instantiated runtimes.

Useful in tests or when a process needs to drop cached instances (e.g. after an upgrade).

pub fn new( rwasm_module: RwasmModule, import_linker: Arc<ImportLinker>, code_hash: B256, ctx: RuntimeContext, consume_fuel: bool, ) -> Self

Creates a new SystemRuntime.

If a compiled runtime for code_hash is present in the thread-local cache, it will be reused. Otherwise, this function compiles/loads the module and instantiates it with imports wired via import_linker.

Fuel metering

The consume_fuel parameter determines whether Wasmtime fuel metering is enabled:

• true: Engine automatically meters fuel (for NITRO, OAUTH2, WASM_RUNTIME, WEBAUTHN)
• false: Contract self-meters via _charge_fuel syscall (for EVM_RUNTIME, etc.)

pub fn execute(&mut self) -> Result<(), TrapCode>

Executes the system runtime entrypoint and updates self.ctx.execution_result.

Execution uses the cached store/instance. Before calling into Wasmtime, we swap self.ctx into the store to ensure syscalls and state access refer to the correct context.

Fuel metering

If consume_fuel=true, the fuel limit is set in the store before execution. Wasmtime will automatically decrement fuel as instructions execute.

Error handling model

• If Wasmtime traps unexpectedly, we do not propagate the trap outward as fatal. Instead, we mark UnexpectedFatalExecutionFailure in execution_result and return Ok(()) so the outer executor can treat it as a partially controlled failure.
• Normal completion is signaled by output where the first 4 bytes are LE exit_code.
• Interruption is requested by returning ExitCode::InterruptionCalled in that header.

pub fn resume( &mut self, _exit_code: i32, _fuel_consumed: u64, ) -> Result<(), TrapCode>

Resumes execution after an interruption.

System runtimes do not support “native” resumable interruptions internally in the same way as contract runtimes. Therefore, resume currently re-enters execute() after clearing any stale output.

Note: exit_code and fuel_consumed are intentionally ignored here because fuel metering is handled by RuntimeContext, and exit codes are encoded in returned output.

pub fn memory_write( &mut self, offset: usize, data: &[u8], ) -> Result<(), TrapCode>

Writes bytes into the system runtime’s linear memory.

Bounds violations are mapped into TrapCode::MemoryOutOfBounds.

pub fn memory_read( &mut self, offset: usize, buffer: &mut [u8], ) -> Result<(), TrapCode>

Reads bytes from the system runtime’s linear memory.

Bounds violations are mapped into TrapCode::MemoryOutOfBounds.

pub fn remaining_fuel(&self) -> Option<u64>

Returns remaining fuel if fuel metering is enabled.

For engine-metered precompiles (consume_fuel=true), returns the actual remaining fuel from the Wasmtime store.

For self-metering runtimes (consume_fuel=false), returns None because fuel is tracked in RuntimeContext via _charge_fuel syscall, not in the Wasmtime store.

pub fn context_mut(&mut self) -> &mut RuntimeContext

Provides mutable access to the per-call runtime context.

pub fn context(&self) -> &RuntimeContext

Provides immutable access to the per-call runtime context.