Struct pallet_contracts::chain_extension::Environment[][src]

pub struct Environment<'a, 'b, E: Ext, S: State> { /* fields omitted */ }
Expand description

Grants the chain extension access to its parameters and execution environment.

It uses typestate programming to enforce the correct usage of the parameters passed to the chain extension.

Implementations

Functions that are available in every state of this type.

Charge the passed amount of weight from the overall limit.

It returns Ok when there the remaining weight budget is larger than the passed weight. It returns Err otherwise. In this case the chain extension should abort the execution and pass through the error.

The returned value can be used to with Self::adjust_weight. Other than that it has no purpose.

Note

Weight is synonymous with gas in substrate.

Adjust a previously charged amount down to its actual amount.

This is when a maximum a priori amount was charged and then should be partially refunded to match the actual amount.

Grants access to the execution environment of the current contract call.

Consult the functions on the returned type before re-implementing those functions.

Functions that are only available in the initial state of this type.

Those are the functions that determine how the arguments to the chain extensions should be consumed.

Use all arguments as integer values.

Use input arguments as integer and output arguments as pointer to a buffer.

Use input and output arguments as pointers to a buffer.

Functions to use the input arguments as integers.

The input_ptr argument.

The input_len argument.

Functions to use the output arguments as integers.

The output_ptr argument.

The output_len_ptr argument.

Functions to use the input arguments as pointer to a buffer.

Reads min(max_len, in_len) from contract memory.

This does not charge any weight. The caller must make sure that the an appropriate amount of weight is charged before reading from contract memory. The reason for that is that usually the costs for reading data and processing said data cannot be separated in a benchmark. Therefore a chain extension would charge the overall costs either using max_len (worst case approximation) or using in_len().

Reads `min(buffer.len(), in_len) from contract memory.

This takes a mutable pointer to a buffer fills it with data and shrinks it to the size of the actual data. Apart from supporting pre-allocated buffers it is equivalent to to read().

Reads and decodes a type with a size fixed at compile time from contract memory.

This function is secure and recommended for all input types of fixed size as long as the cost of reading the memory is included in the overall already charged weight of the chain extension. This should usually be the case when fixed input types are used.

Reads and decodes a type with a dynamic size from contract memory.

Make sure to include len in your weight calculations.

The length of the input as passed in as input_len.

A chain extension would use this value to calculate the dynamic part of its weight. For example a chain extension that calculates the hash of some passed in bytes would use in_len to charge the costs of hashing that amount of bytes. This also subsumes the act of copying those bytes as a benchmarks measures both.

Functions to use the output arguments as pointer to a buffer.

Write the supplied buffer to contract memory.

If the contract supplied buffer is smaller than the passed buffer an Err is returned. If allow_skip is set to true the contract is allowed to skip the copying of the buffer by supplying the guard value of u32::MAX as out_ptr. The weight_per_byte is only charged when the write actually happens and is not skipped or failed due to a too small output buffer.

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Convert from a value of T into an equivalent instance of Option<Self>. Read more

Consume self to return Some equivalent value of Option<T>. Read more

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait. Read more

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait. Read more

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s. Read more

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s. Read more

Performs the conversion.

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Performs the conversion.

Cast reference.

Cast reference.

Cast mutable reference.

Cast mutable reference.

Get a reference to the inner from the outer.

Get a mutable reference to the inner from the outer.

Should always be Self

Convert from a value of T into an equivalent instance of Self. Read more

Consume self to return an equivalent value of T. Read more

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more

Checks if self is actually part of its subset T (and can be converted to it).

Use with care! Same as self.to_subset but without any property checks. Always succeeds.

The inclusion map: converts self to the equivalent element of its superset.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

The counterpart to unchecked_from.

Consume self to return an equivalent value of T.

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more