Struct noble_contracts::Limits

pub struct Limits {
    pub event_topics: u32,
    pub stack_height: u32,
    pub globals: u32,
    pub parameters: u32,
    pub memory_pages: u32,
    pub table_size: u32,
    pub br_table_size: u32,
    pub subject_len: u32,
    pub code_size: u32,
}

Describes the upper limits on various metrics.

Fields

event_topics: u32

The maximum number of topics supported by an event.

stack_height: u32

Maximum allowed stack height in number of elements.

See https://wiki.tetcoin.org/WebAssembly-StackHeight to find out how the stack fabric cost is calculated. Each element can be of one of the wasm value types. This means the maximum size per element is 64bit.

globals: u32

Maximum number of globals a module is allowed to declare.

Globals are not limited through the stack_height as locals are. Neither does the linear memory limit memory_pages applies to them.

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.

code_size: u32

The maximum length of a contract code in bytes. This limit applies to the uninstrumented and pristine form of the code as supplied to put_code.

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 copy of the value.

pub 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.

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

Attempt to skip the encoded value from input.

pub 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 encode_to<__CodecOutputEdqy: Output + ?Sized>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
)

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

pub fn size_hint(&self) -> usize

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

pub fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

pub 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.

pub fn encoded_size(&self) -> usize

Calculates the encoded size.

impl EncodeLike<Limits> for Limits

impl Eq for Limits

impl PartialEq<Limits> for Limits

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

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 StructuralEq for Limits

impl StructuralPartialEq for Limits