Struct SharedMemory

pub struct SharedMemory {
    buffer: Vec<u8>,
    checkpoints: Vec<usize>,
    last_checkpoint: usize,
    memory_limit: u64,
}

A sequential memory shared between calls, which uses a Vec for internal representation. A SharedMemory instance should always be obtained using the new static method to ensure memory safety.

Fields

buffer: Vec<u8>

checkpoints: Vec<usize>

last_checkpoint: usize

memory_limit: u64

Available on crate feature memory_limit only.

Implementations

impl SharedMemory

pub fn new() -> SharedMemory

Creates a new memory instance that can be shared between calls.

The default initial capacity is 4KiB.

pub fn with_capacity(capacity: usize) -> SharedMemory

Creates a new memory instance that can be shared between calls with the given capacity.

pub fn new_with_memory_limit(memory_limit: u64) -> SharedMemory

Available on crate feature memory_limit only.

Creates a new memory instance that can be shared between calls, with memory_limit as upper bound for allocation size.

The default initial capacity is 4KiB.

pub fn limit_reached(&self, new_size: usize) -> bool

Available on crate feature memory_limit only.

Returns true if the new_size for the current context memory will make the shared buffer length exceed the memory_limit.

pub fn new_context(&mut self)

Prepares the shared memory for a new context.

pub fn free_context(&mut self)

Prepares the shared memory for returning to the previous context.

pub fn len(&self) -> usize

Returns the length of the current memory range.

pub fn is_empty(&self) -> bool

Returns true if the current memory range is empty.

pub fn current_expansion_cost(&self) -> u64

Returns the gas cost for the current memory expansion.

pub fn resize(&mut self, new_size: usize)

Resizes the memory in-place so that len is equal to new_len.

pub fn slice(&self, offset: usize, size: usize) -> &[u8]

Returns a byte slice of the memory region at the given offset.

Panics

Panics on out of bounds.

pub fn slice_range(&self, range: Range<usize>) -> &[u8]

Returns a byte slice of the memory region at the given offset.

Panics

Panics on out of bounds.

pub fn slice_mut(&mut self, offset: usize, size: usize) -> &mut [u8]

Returns a byte slice of the memory region at the given offset.

Panics

Panics on out of bounds.

pub fn get_byte(&self, offset: usize) -> u8

Returns the byte at the given offset.

Panics

Panics on out of bounds.

pub fn get_word(&self, offset: usize) -> FixedBytes<32>

Returns a 32-byte slice of the memory region at the given offset.

Panics

Panics on out of bounds.

pub fn get_u256(&self, offset: usize) -> Uint<256, 4>

Returns a U256 of the memory region at the given offset.

Panics

Panics on out of bounds.

pub fn set_byte(&mut self, offset: usize, byte: u8)

Sets the byte at the given index.

Panics

Panics on out of bounds.

pub fn set_word(&mut self, offset: usize, value: &FixedBytes<32>)

Sets the given 32-byte value to the memory region at the given offset.

Panics

Panics on out of bounds.

pub fn set_u256(&mut self, offset: usize, value: Uint<256, 4>)

Sets the given U256 value to the memory region at the given offset.

Panics

Panics on out of bounds.

pub fn set(&mut self, offset: usize, value: &[u8])

Set memory region at given offset.

Panics

Panics on out of bounds.

pub fn set_data( &mut self, memory_offset: usize, data_offset: usize, len: usize, data: &[u8], )

Set memory from data. Our memory offset+len is expected to be correct but we are doing bound checks on data/data_offeset/len and zeroing parts that is not copied.

Panics

Panics if memory is out of bounds.

pub fn copy(&mut self, dst: usize, src: usize, len: usize)

Copies elements from one part of the memory to another part of itself.

Panics

Panics on out of bounds.

pub fn context_memory(&self) -> &[u8]

Returns a reference to the memory of the current context, the active memory.

pub fn context_memory_mut(&mut self) -> &mut [u8]

Returns a mutable reference to the memory of the current context.

Trait Implementations

impl Clone for SharedMemory

fn clone(&self) -> SharedMemory

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SharedMemory

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

Formats the value using the given formatter.

impl Default for SharedMemory

fn default() -> SharedMemory

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SharedMemory

fn deserialize<__D>( __deserializer: __D, ) -> Result<SharedMemory, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for SharedMemory

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SharedMemory

fn eq(&self, other: &SharedMemory) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SharedMemory

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SharedMemory

impl StructuralPartialEq for SharedMemory

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 64 bytes