Struct Limits 

pub struct Limits {
    pub event_topics: u32,
    pub globals: u32,
    pub locals: u32,
    pub parameters: u32,
    pub memory_pages: u32,
    pub table_size: u32,
    pub br_table_size: u32,
    pub subject_len: u32,
    pub payload_len: u32,
    pub runtime_memory: u32,
}

Describes the upper limits on various metrics.

Fields

event_topics: u32

The maximum number of topics supported by an event.

globals: u32

Maximum number of globals a module is allowed to declare.

Globals are not limited through the linear memory limit memory_pages.

locals: u32

Maximum number of locals a function can have.

As wasm engine initializes each of the local, we need to limit their number to confine execution costs.

parameters: u32

Maximum numbers of parameters a function can have.

Those need to be limited to prevent a potentially exploitable interaction with the stack height instrumentation: The costs of executing the stack height instrumentation for an indirectly called function scales linearly with the amount of parameters of this function. Because the stack height instrumentation itself is is not weight metered its costs must be static (via this limit) and included in the costs of the instructions that cause them (call, call_indirect).

memory_pages: u32

Maximum number of memory pages allowed for a contract.

table_size: u32

Maximum number of elements allowed in a table.

Currently, the only type of element that is allowed in a table is funcref.

br_table_size: u32

Maximum number of elements that can appear as immediate value to the br_table instruction.

subject_len: u32

The maximum length of a subject in bytes used for PRNG generation.

payload_len: u32

The maximum size of a storage value and event payload in bytes.

runtime_memory: u32

The maximum node runtime memory. This is for integrity checks only and does not affect the real setting.

Implementations

impl Limits

pub fn max_memory_size(&self) -> u32

The maximum memory size in bytes that a contract can occupy.

Trait Implementations

impl Clone for Limits

fn clone(&self) -> Limits

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Limits

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

Formats the value using the given formatter.

impl Decode for Limits

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl Default for Limits

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Limits

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for Limits

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl PartialEq for Limits

fn eq(&self, other: &Limits) -> 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 Limits

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TypeInfo for Limits

type Identity = Limits

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl EncodeLike for Limits

impl Eq for Limits

impl StructuralPartialEq for Limits