Struct Ext

pub struct Ext<LP: LazyPagesInterface> {
    pub context: ProcessorContext,
    pub current_counter: CounterType,
    /* private fields */
}

Structure providing externalities for running host functions.

Fields

context: ProcessorContext

Processor context.

current_counter: CounterType

Actual gas counter type within wasm module’s global.

Trait Implementations

impl<LP: LazyPagesInterface> BackendExternalities for Ext<LP>

fn gas_amount(&self) -> GasAmount

fn pre_process_memory_accesses( &mut self, reads: &[MemoryInterval], writes: &[MemoryInterval], gas_counter: &mut u64, ) -> Result<(), ProcessAccessError>

Pre-process memory access if needed.

impl<LP: LazyPagesInterface> CountersOwner for Ext<LP>

fn charge_gas_for_token(&mut self, token: CostToken) -> Result<(), ChargeError>

Charge for runtime api call.

fn charge_gas_if_enough(&mut self, amount: u64) -> Result<(), ChargeError>

Charge gas if enough, else just returns error.

fn gas_left(&self) -> GasLeft

Returns gas limit and gas allowance left.

fn current_counter_type(&self) -> CounterType

Currently set gas counter type.

fn decrease_current_counter_to(&mut self, amount: u64)

Decreases gas left by fetched single numeric of actual counter.

fn define_current_counter(&mut self) -> u64

Returns minimal amount of gas counters and set the type of current counter.

fn current_counter_value(&self) -> u64

Returns value of gas counter currently set.

impl<LP: LazyPagesInterface> Externalities for Ext<LP>

type UnrecoverableError = UnrecoverableExtError

An error issued in infallible syscall.

type FallibleError = FallibleExtError

An error issued in fallible syscall.

type AllocError = AllocExtError

An error issued during allocation.

fn alloc<Context>( &mut self, ctx: &mut Context, mem: &mut impl Memory<Context>, pages_num: u32, ) -> Result<WasmPage, Self::AllocError>

Allocate number of pages.

fn free(&mut self, page: WasmPage) -> Result<(), Self::AllocError>

Free specific page.

fn free_range( &mut self, start: WasmPage, end: WasmPage, ) -> Result<(), Self::AllocError>

Free specific memory range.

fn env_vars(&self, version: u32) -> Result<EnvVars, Self::UnrecoverableError>

Get environment variables currently set in the system and in the form corresponded to the requested version.

fn block_height(&self) -> Result<u32, Self::UnrecoverableError>

Get the current block height.

fn block_timestamp(&self) -> Result<u64, Self::UnrecoverableError>

Get the current block timestamp.

fn send_init(&mut self) -> Result<u32, Self::FallibleError>

Initialize a new incomplete message for another program and return its handle.

fn send_push( &mut self, handle: u32, buffer: &[u8], ) -> Result<(), Self::FallibleError>

Push an extra buffer into message payload by handle.

fn send_push_input( &mut self, handle: u32, offset: u32, len: u32, ) -> Result<(), Self::FallibleError>

Push the incoming message buffer into message payload by handle.

fn send_commit( &mut self, handle: u32, msg: HandlePacket, delay: u32, ) -> Result<MessageId, Self::FallibleError>

Complete message and send it to another program.

fn reservation_send_commit( &mut self, id: ReservationId, handle: u32, msg: HandlePacket, delay: u32, ) -> Result<MessageId, Self::FallibleError>

Complete message and send it to another program using gas from reservation.

fn reply_push(&mut self, buffer: &[u8]) -> Result<(), Self::FallibleError>

Push an extra buffer into reply message.

fn reply_commit( &mut self, msg: ReplyPacket, ) -> Result<MessageId, Self::FallibleError>

Complete reply message and send it to source program.

fn reservation_reply_commit( &mut self, id: ReservationId, msg: ReplyPacket, ) -> Result<MessageId, Self::FallibleError>

Complete reply message and send it to source program from reservation.

fn reply_to(&self) -> Result<MessageId, Self::FallibleError>

Get the message id of the initial message.

fn signal_from(&self) -> Result<MessageId, Self::FallibleError>

Get the message id which signal issues from.

fn reply_push_input( &mut self, offset: u32, len: u32, ) -> Result<(), Self::FallibleError>

Push the incoming message buffer into reply message.

fn source(&self) -> Result<ProgramId, Self::UnrecoverableError>

Get the source of the message currently being handled.

fn reply_code(&self) -> Result<ReplyCode, Self::FallibleError>

Get the reply code if the message being processed.

fn signal_code(&self) -> Result<SignalCode, Self::FallibleError>

Get the signal code if the message being processed.

fn message_id(&self) -> Result<MessageId, Self::UnrecoverableError>

Get the id of the message currently being handled.

fn program_id(&self) -> Result<ProgramId, Self::UnrecoverableError>

Get the id of program itself

fn debug(&self, data: &str) -> Result<(), Self::UnrecoverableError>

Send debug message.

fn lock_payload( &mut self, at: u32, len: u32, ) -> Result<PayloadSliceLock, Self::FallibleError>

Takes ownership over payload of the executing message and returns it in the wrapper PayloadSliceLock, which acts like lock.

fn unlock_payload( &mut self, payload_holder: &mut PayloadSliceLock, ) -> UnlockPayloadBound

Reclaims ownership from the payload lock over previously taken payload from the currently executing message..

fn size(&self) -> Result<usize, Self::UnrecoverableError>

Size of currently handled message payload.

fn reserve_gas( &mut self, amount: u64, duration: u32, ) -> Result<ReservationId, Self::FallibleError>

Reserve some gas for a few blocks.

fn unreserve_gas( &mut self, id: ReservationId, ) -> Result<u64, Self::FallibleError>

Unreserve gas using reservation ID.

fn system_reserve_gas(&mut self, amount: u64) -> Result<(), Self::FallibleError>

Do system reservation.

fn gas_available(&self) -> Result<u64, Self::UnrecoverableError>

Tell how much gas is left in running context.

fn value(&self) -> Result<u128, Self::UnrecoverableError>

Value associated with message.

fn value_available(&self) -> Result<u128, Self::UnrecoverableError>

Tell how much value is left in running context.

fn wait(&mut self) -> Result<(), Self::UnrecoverableError>

Interrupt the program and reschedule execution for maximum.

fn wait_for(&mut self, duration: u32) -> Result<(), Self::UnrecoverableError>

Interrupt the program and reschedule execution in duration.

fn wait_up_to( &mut self, duration: u32, ) -> Result<bool, Self::UnrecoverableError>

Interrupt the program and reschedule execution for maximum, but not more than duration.

fn wake( &mut self, waker_id: MessageId, delay: u32, ) -> Result<(), Self::FallibleError>

Wake the waiting message and move it to the processing queue.

fn create_program( &mut self, packet: InitPacket, delay: u32, ) -> Result<(MessageId, ProgramId), Self::FallibleError>

Send init message to create a new program.

fn reply_deposit( &mut self, message_id: MessageId, amount: u64, ) -> Result<(), Self::FallibleError>

Create deposit to handle reply on given message.

fn random(&self) -> Result<(&[u8], u32), Self::UnrecoverableError>

Returns a random seed for the current block with message id as a subject, along with the time in the past since when it was determinable by chain observers.

fn forbidden_funcs(&self) -> &BTreeSet<SyscallName>

Return the set of functions that are forbidden to be called.

fn msg_ctx(&self) -> &MessageContext

Return the current message context.

fn send( &mut self, msg: HandlePacket, delay: u32, ) -> Result<MessageId, Self::FallibleError>

Send message to another program.

fn reservation_send( &mut self, id: ReservationId, msg: HandlePacket, delay: u32, ) -> Result<MessageId, Self::FallibleError>

Send message to another program using gas from reservation.

fn reply(&mut self, msg: ReplyPacket) -> Result<MessageId, Self::FallibleError>

Produce reply to the current message.

fn reservation_reply( &mut self, id: ReservationId, msg: ReplyPacket, ) -> Result<MessageId, Self::FallibleError>

Produce reply to the current message from reservation.

impl<LP: LazyPagesInterface> ProcessorExternalities for Ext<LP>

Empty implementation for non-substrate (and non-lazy-pages) using

fn new(context: ProcessorContext) -> Self

Create new

fn into_ext_info<Context>( self, ctx: &mut Context, memory: &impl Memory<Context>, ) -> Result<ExtInfo, MemoryError>

Convert externalities into info.

fn lazy_pages_init_for_program<Context>( ctx: &mut Context, mem: &mut impl Memory<Context>, prog_id: ProgramId, memory_infix: MemoryInfix, stack_end: Option<WasmPage>, globals_config: GlobalsAccessConfig, lazy_pages_costs: LazyPagesCosts, )

Protect and save storage keys for pages which has no data

fn lazy_pages_post_execution_actions<Context>( ctx: &mut Context, mem: &mut impl Memory<Context>, )

Lazy pages program post execution actions

fn lazy_pages_status() -> Status

Returns lazy pages status