Struct WrappedKernelApi

pub struct WrappedKernelApi<'a, E: KernelTransactionExecutor + 'a, K: KernelApi<CallbackObject = InjectCostingError<E>>> { /* private fields */ }

Trait Implementations

impl<'a, E: KernelTransactionExecutor + 'a, K: KernelApi<CallbackObject = InjectCostingError<E>>> KernelApi for WrappedKernelApi<'a, E, K>

type CallbackObject = E

impl<'a, E: KernelTransactionExecutor + 'a, K: KernelApi<CallbackObject = InjectCostingError<E>>> KernelInternalApi for WrappedKernelApi<'a, E, K>

type System = E

fn kernel_get_system_state(&mut self) -> SystemState<'_, E>

Returns the system state.

fn kernel_get_current_stack_depth_uncosted(&self) -> usize

Returns the current stack depth.

fn kernel_get_current_stack_id_uncosted(&self) -> usize

Returns the current stack id.

fn kernel_get_node_visibility_uncosted( &self, node_id: &NodeId, ) -> NodeVisibility

Returns the visibility of a node.

fn kernel_read_substate_uncosted( &self, node_id: &NodeId, partition_num: PartitionNumber, substate_key: &SubstateKey, ) -> Option<&IndexedScryptoValue>

Returns the value of a substate.

fn kernel_get_system(&mut self) -> &mut Self::System

Returns the system.

impl<'a, E: KernelTransactionExecutor + 'a, K: KernelApi<CallbackObject = InjectCostingError<E>>> KernelInvokeApi<<E as KernelCallbackObject>::CallFrameData> for WrappedKernelApi<'a, E, K>

fn kernel_invoke( &mut self, invocation: Box<KernelInvocation<E::CallFrameData>>, ) -> Result<IndexedScryptoValue, RuntimeError>

impl<'a, E: KernelTransactionExecutor + 'a, K: KernelApi<CallbackObject = InjectCostingError<E>>> KernelNodeApi for WrappedKernelApi<'a, E, K>

fn kernel_pin_node(&mut self, node_id: NodeId) -> Result<(), RuntimeError>

Pin a node to it’s current device.

fn kernel_allocate_node_id( &mut self, entity_type: EntityType, ) -> Result<NodeId, RuntimeError>

Allocates a new node id useable for create_node

fn kernel_create_node( &mut self, node_id: NodeId, node_substates: NodeSubstates, ) -> Result<(), RuntimeError>

Creates a new RENode

fn kernel_create_node_from( &mut self, node_id: NodeId, partitions: BTreeMap<PartitionNumber, (NodeId, PartitionNumber)>, ) -> Result<(), RuntimeError>

fn kernel_drop_node( &mut self, node_id: &NodeId, ) -> Result<DroppedNode, RuntimeError>

Removes an RENode. Owned children will be possessed by the call frame.

impl<'a, E: KernelTransactionExecutor + 'a, K: KernelApi<CallbackObject = InjectCostingError<E>>> KernelStackApi for WrappedKernelApi<'a, E, K>

type CallFrameData = <E as KernelCallbackObject>::CallFrameData

fn kernel_get_stack_id(&mut self) -> Result<usize, RuntimeError>

Gets the stack id which is currently being used

fn kernel_switch_stack(&mut self, id: usize) -> Result<(), RuntimeError>

Achieves a context switch by switching the underlying callframe/stack

fn kernel_send_to_stack( &mut self, id: usize, value: &IndexedScryptoValue, ) -> Result<(), RuntimeError>

Moves the objects in a scrypto value from the current call frame to another stack

fn kernel_set_call_frame_data( &mut self, data: E::CallFrameData, ) -> Result<(), RuntimeError>

Sets the call frame data for the current call frame

fn kernel_get_owned_nodes(&mut self) -> Result<Vec<NodeId>, RuntimeError>

Returns the owned nodes of the current call frame

impl<'a, E: KernelTransactionExecutor + 'a, Y: KernelApi<CallbackObject = InjectCostingError<E>>> KernelSubstateApi<<E as KernelCallbackObject>::LockData> for WrappedKernelApi<'a, E, Y>

fn kernel_mark_substate_as_transient( &mut self, node_id: NodeId, partition_num: PartitionNumber, key: SubstateKey, ) -> Result<(), RuntimeError>

Marks a substate as transient, or a substate which was never and will never be persisted

fn kernel_open_substate_with_default<F: FnOnce() -> IndexedScryptoValue>( &mut self, node_id: &NodeId, partition_num: PartitionNumber, substate_key: &SubstateKey, flags: LockFlags, default: Option<F>, lock_data: E::LockData, ) -> Result<SubstateHandle, RuntimeError>

Locks a substate to make available for reading and/or writing

fn kernel_get_lock_data( &mut self, lock_handle: SubstateHandle, ) -> Result<E::LockData, RuntimeError>

Retrieves info related to a lock

fn kernel_close_substate( &mut self, lock_handle: SubstateHandle, ) -> Result<(), RuntimeError>

Drops the handle on some substate, if the handle is a force write, updates are flushed. No updates should occur if an error is returned.

fn kernel_read_substate( &mut self, lock_handle: SubstateHandle, ) -> Result<&IndexedScryptoValue, RuntimeError>

Reads the value of the substate locked by the given lock handle

fn kernel_write_substate( &mut self, lock_handle: SubstateHandle, value: IndexedScryptoValue, ) -> Result<(), RuntimeError>

Writes a value to the substate locked by the given lock handle

fn kernel_set_substate( &mut self, node_id: &NodeId, partition_num: PartitionNumber, substate_key: SubstateKey, value: IndexedScryptoValue, ) -> Result<(), RuntimeError>

Sets a value to a substate without checking for the original value.

fn kernel_remove_substate( &mut self, node_id: &NodeId, partition_num: PartitionNumber, substate_key: &SubstateKey, ) -> Result<Option<IndexedScryptoValue>, RuntimeError>

Removes a substate from a node and returns the original value.

fn kernel_scan_sorted_substates( &mut self, node_id: &NodeId, partition_num: PartitionNumber, count: u32, ) -> Result<Vec<(SortedKey, IndexedScryptoValue)>, RuntimeError>

Reads substates under a node in sorted lexicographical order

fn kernel_scan_keys<K: SubstateKeyContent>( &mut self, node_id: &NodeId, partition_num: PartitionNumber, count: u32, ) -> Result<Vec<SubstateKey>, RuntimeError>

fn kernel_drain_substates<K: SubstateKeyContent>( &mut self, node_id: &NodeId, partition_num: PartitionNumber, count: u32, ) -> Result<Vec<(SubstateKey, IndexedScryptoValue)>, RuntimeError>

fn kernel_open_substate( &mut self, node_id: &NodeId, partition_num: PartitionNumber, substate_key: &SubstateKey, flags: LockFlags, lock_data: L, ) -> Result<u32, RuntimeError>