Struct Memory 

pub struct Memory {
    pub buffer: Rc<RefCell<Vec<u8>>>,
    pub len: usize,
    /* private fields */
}

A cheaply clonable callframe-shared memory buffer.

When a new callframe is created a RC clone of this memory is made, with the current base offset at the length of the buffer at that time.

Fields

buffer: Rc<RefCell<Vec<u8>>>

len: usize

Implementations

impl Memory

pub fn new() -> Self

pub fn reset_for_reuse(&mut self)

Resets this memory so its buffer can be reused from a pool by the next transaction: drops all contents (length → 0, capacity retained) and rebases to 0.

Truncating the buffer to length 0 is REQUIRED for correctness, not just hygiene: Memory::resize only zero-fills bytes grown past buffer.len(), so handing a non-empty buffer to the next tx would expose stale data from the previous one (a consensus bug). Capacity is kept so the grown allocation is reused.

pub fn next_memory(&self) -> Memory

Gets the Memory for the next children callframe.

pub fn clean_from_base(&self)

Cleans the memory from base onwards, this must be used in callframes when handling returns.

On the callframe that is about to be dropped.

pub fn len(&self) -> usize

Returns the len of the current memory, from the current base.

pub fn is_empty(&self) -> bool

pub fn live_bytes(&self) -> Vec<u8>

Returns a copy of the live byte slice for this frame (from current_base to current_base + len). Used by the struct-log tracer for memory capture.

pub fn resize(&mut self, new_memory_size: usize) -> Result<(), VMError>

Resizes the from the current base to fit the memory specified at new_memory_size.

Note: new_memory_size is increased to the next 32 byte multiple.

pub fn load_range( &mut self, offset: usize, size: usize, ) -> Result<Bytes, VMError>

Load size bytes from the given offset. Returning a Bytes.

pub fn with_range<R>( &mut self, offset: usize, size: usize, f: impl FnOnce(&[u8]) -> R, ) -> Result<R, VMError>

Borrow size bytes from the given offset and pass them to f, without allocating a Bytes copy of the range.

load_range reads through self.buffer.borrow(), whose Ref guard cannot outlive this call — so a -> &[u8] accessor can’t be written. Callers that only need to read the range (e.g. hashing) take the borrow via this closure instead. Semantics match load_range exactly, including zero-padding reads past the current length (handled by resize).

pub fn load_range_const<const N: usize>( &mut self, offset: usize, ) -> Result<[u8; N], VMError>

Load N bytes from the given offset.

pub fn load_word(&mut self, offset: usize) -> Result<U256, VMError>

Load a word from at the given offset.

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

Stores the given data at the given offset.

pub fn store_data_zero_padded( &mut self, offset: usize, data: &[u8], total_size: usize, ) -> Result<(), VMError>

Stores data and zero-pads up to total_size at the given offset.

pub fn store_word(&mut self, offset: usize, word: U256) -> Result<(), VMError>

Stores a word at the given offset, resizing memory if needed.

pub fn copy_within( &mut self, from_offset: usize, to_offset: usize, size: usize, ) -> Result<(), VMError>

Copies memory within 2 offsets. Like a memmove.

Resizes if needed, because one can copy from “expanded memory”, which is initialized with zeroes.

pub fn store_zeros(&mut self, offset: usize, size: usize) -> Result<(), VMError>

Trait Implementations

impl Clone for Memory

fn clone(&self) -> Memory

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Memory

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Memory

fn default() -> Self

Returns the “default value” for a type.