Struct scrypto_test::prelude::Kernel

pub struct Kernel<'g, M, S>
where
    M: KernelCallbackObject,
    S: CommitableSubstateStore,
{ /* private fields */ }

Implementations

impl<'g, M, S> Kernel<'g, M, S>

where M: KernelCallbackObject, S: CommitableSubstateStore + BootStore,

pub fn new_no_refs( store: &'g mut S, id_allocator: &'g mut IdAllocator, callback: &'g mut M ) -> Kernel<'g, M, S>

pub fn new( store: &'g mut S, id_allocator: &'g mut IdAllocator, callback: &'g mut M, global_addresses: IndexSet<GlobalAddress>, internal_addresses: IndexSet<InternalAddress> ) -> Kernel<'g, M, S>

impl<'g, M, S> Kernel<'g, M, S>

where M: KernelCallbackObject, S: CommitableSubstateStore,

pub fn kernel_create_kernel_for_testing( substate_io: SubstateIO<'g, S>, id_allocator: &'g mut IdAllocator, current_frame: CallFrame<<M as KernelCallbackObject>::CallFrameData, <M as KernelCallbackObject>::LockData>, prev_frame_stack: Vec<CallFrame<<M as KernelCallbackObject>::CallFrameData, <M as KernelCallbackObject>::LockData>>, callback: &'g mut M ) -> Kernel<'g, M, S>

pub fn kernel_current_frame( &self ) -> &CallFrame<<M as KernelCallbackObject>::CallFrameData, <M as KernelCallbackObject>::LockData>

pub fn kernel_current_frame_mut( &mut self ) -> (&SubstateIO<'_, S>, &mut CallFrame<<M as KernelCallbackObject>::CallFrameData, <M as KernelCallbackObject>::LockData>)

pub fn kernel_prev_frame_stack( &self ) -> &Vec<CallFrame<<M as KernelCallbackObject>::CallFrameData, <M as KernelCallbackObject>::LockData>>

pub fn kernel_prev_frame_stack_mut( &mut self ) -> &mut Vec<CallFrame<<M as KernelCallbackObject>::CallFrameData, <M as KernelCallbackObject>::LockData>>

pub fn kernel_substate_io(&self) -> &SubstateIO<'g, S>

pub fn kernel_substate_io_mut(&mut self) -> &mut SubstateIO<'g, S>

pub fn kernel_id_allocator(&self) -> &IdAllocator

pub fn kernel_id_allocator_mut(&mut self) -> &mut &'g mut IdAllocator

pub fn kernel_callback(&self) -> &M

pub fn kernel_callback_mut(&mut self) -> &mut M

Trait Implementations

impl<'g, M, S> KernelInternalApi<M> for Kernel<'g, M, S>

where M: KernelCallbackObject, S: CommitableSubstateStore,

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

Returns the visibility of a node

fn kernel_get_current_depth(&self) -> usize

Gets the number of call frames that are currently in the call frame stack

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

fn kernel_read_bucket(&mut self, bucket_id: &NodeId) -> Option<BucketSnapshot>

fn kernel_read_proof(&mut self, proof_id: &NodeId) -> Option<ProofSnapshot>

fn kernel_get_system(&mut self) -> &mut M

Retrieves data associated with the kernel upstream layer (system)

impl<'g, M, S> KernelInvokeApi<<M as KernelCallbackObject>::CallFrameData> for Kernel<'g, M, S>

where M: KernelCallbackObject, S: CommitableSubstateStore,

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

impl<'g, M, S> KernelNodeApi for Kernel<'g, M, S>

where M: KernelCallbackObject, S: CommitableSubstateStore,

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: BTreeMap<PartitionNumber, BTreeMap<SubstateKey, IndexedScryptoValue>> ) -> 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<'g, M, S> KernelSubstateApi<<M as KernelCallbackObject>::LockData> for Kernel<'g, M, S>

where M: KernelCallbackObject, S: CommitableSubstateStore,

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>( &mut self, node_id: &NodeId, partition_num: PartitionNumber, substate_key: &SubstateKey, flags: LockFlags, default: Option<F>, data: <M as KernelCallbackObject>::LockData ) -> Result<u32, RuntimeError>

where F: FnOnce() -> IndexedScryptoValue,

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

fn kernel_get_lock_data( &mut self, lock_handle: u32 ) -> Result<<M as KernelCallbackObject>::LockData, RuntimeError>

Retrieves info related to a lock

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

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

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

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

fn kernel_close_substate( &mut self, lock_handle: u32 ) -> 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_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_keys<K>( &mut self, node_id: &NodeId, partition_num: PartitionNumber, limit: u32 ) -> Result<Vec<SubstateKey>, RuntimeError>

where K: SubstateKeyContent + 'static,

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

where K: SubstateKeyContent + 'static,

fn kernel_scan_sorted_substates( &mut self, node_id: &NodeId, partition_num: PartitionNumber, limit: u32 ) -> Result<Vec<(([u8; 2], Vec<u8>), IndexedScryptoValue)>, RuntimeError>

Reads substates under a node in sorted lexicographical order

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

impl<'g, M, S> KernelApi<M> for Kernel<'g, M, S>

where M: KernelCallbackObject, S: CommitableSubstateStore,