Struct System

pub struct System<V: SystemCallbackObject> {
    pub versioned_system_logic: SystemVersion,
    pub callback: V,
    pub blueprint_cache: NonIterMap<CanonicalBlueprintId, Rc<BlueprintDefinition>>,
    pub schema_cache: NonIterMap<SchemaHash, Rc<VersionedScryptoSchema>>,
    pub auth_cache: NonIterMap<CanonicalBlueprintId, AuthConfig>,
    pub modules: SystemModuleMixer,
    pub finalization: SystemFinalization,
}

Fields

versioned_system_logic: SystemVersion

callback: V

blueprint_cache: NonIterMap<CanonicalBlueprintId, Rc<BlueprintDefinition>>

schema_cache: NonIterMap<SchemaHash, Rc<VersionedScryptoSchema>>

auth_cache: NonIterMap<CanonicalBlueprintId, AuthConfig>

modules: SystemModuleMixer

finalization: SystemFinalization

Implementations

impl<V: SystemCallbackObject> System<V>

pub fn new( versioned_system_logic: SystemVersion, callback: V, modules: SystemModuleMixer, finalization: SystemFinalization, ) -> Self

Trait Implementations

impl<V: SystemCallbackObject> HasModules for System<V>

fn modules_mut(&mut self) -> &mut SystemModuleMixer

impl<V: SystemCallbackObject> KernelCallbackObject for System<V>

type LockData = SystemLockData

Data to be stored with each substate lock

type CallFrameData = Actor

Data to be stored with every call frame

fn on_pin_node<Y: KernelInternalApi<System = Self>>( node_id: &NodeId, api: &mut Y, ) -> Result<(), RuntimeError>

Callback before a node is pinned to the heap

fn on_create_node<Y: KernelInternalApi<System = Self>>( event: CreateNodeEvent<'_>, api: &mut Y, ) -> Result<(), RuntimeError>

Callbacks before/on-io-access/after a new node is created

fn on_drop_node<Y: KernelInternalApi<System = Self>>( event: DropNodeEvent<'_>, api: &mut Y, ) -> Result<(), RuntimeError>

Callbacks before/on-io-access/after a node is dropped

fn on_move_module<Y: KernelInternalApi<System = Self>>( event: MoveModuleEvent<'_>, api: &mut Y, ) -> Result<(), RuntimeError>

Callback when a module is moved

fn on_open_substate<Y: KernelInternalApi<System = Self>>( event: OpenSubstateEvent<'_>, api: &mut Y, ) -> Result<(), RuntimeError>

Callback before/on-io-access/after a substate is opened

fn on_close_substate<Y: KernelInternalApi<System = Self>>( event: CloseSubstateEvent, api: &mut Y, ) -> Result<(), RuntimeError>

Callback before a substate is closed

fn on_read_substate<Y: KernelInternalApi<System = Self>>( event: ReadSubstateEvent<'_>, api: &mut Y, ) -> Result<(), RuntimeError>

Callback before a substate is read

fn on_write_substate<Y: KernelInternalApi<System = Self>>( event: WriteSubstateEvent<'_>, api: &mut Y, ) -> Result<(), RuntimeError>

Callback before a substate is written to

fn on_set_substate<Y: KernelInternalApi<System = Self>>( event: SetSubstateEvent<'_>, api: &mut Y, ) -> Result<(), RuntimeError>

Callback before/on-io-access a substate is set

fn on_remove_substate<Y: KernelInternalApi<System = Self>>( event: RemoveSubstateEvent<'_>, api: &mut Y, ) -> Result<(), RuntimeError>

Callback before/on-io-access a substate is removed

fn on_scan_keys<Y: KernelInternalApi<System = Self>>( event: ScanKeysEvent<'_>, api: &mut Y, ) -> Result<(), RuntimeError>

Callback before/on-io-access a key scan occurs

fn on_drain_substates<Y: KernelInternalApi<System = Self>>( event: DrainSubstatesEvent<'_>, api: &mut Y, ) -> Result<(), RuntimeError>

Callback before/on-io-access a substate drain occurs

fn on_scan_sorted_substates<Y: KernelInternalApi<System = Self>>( event: ScanSortedSubstatesEvent<'_>, api: &mut Y, ) -> Result<(), RuntimeError>

Callback before/on-io-access a sorted substate scan occurs

fn before_invoke<Y: KernelApi<CallbackObject = Self>>( invocation: &KernelInvocation<Actor>, api: &mut Y, ) -> Result<(), RuntimeError>

Callback before an invocation and a new call frame is created

fn on_execution_start<Y: KernelInternalApi<System = Self>>( api: &mut Y, ) -> Result<(), RuntimeError>

Callback after a new call frame is created for a new invocation

fn invoke_upstream<Y: KernelApi<CallbackObject = Self>>( input: &IndexedScryptoValue, api: &mut Y, ) -> Result<IndexedScryptoValue, RuntimeError>

Callback on invocation. This is where the callback object should execute application logic.

fn auto_drop<Y: KernelApi<CallbackObject = Self>>( nodes: Vec<NodeId>, api: &mut Y, ) -> Result<(), RuntimeError>

Callback after invocation during call frame cleanup and nodes are still owned by the executed call frame

fn on_execution_finish<Y: KernelInternalApi<System = Self>>( message: &CallFrameMessage, api: &mut Y, ) -> Result<(), RuntimeError>

Callback right after execution of invocation and where call of execution still exists

fn on_get_stack_id<Y: KernelInternalApi<System = Self>>( api: &mut Y, ) -> Result<(), RuntimeError>

fn on_switch_stack<Y: KernelInternalApi<System = Self>>( api: &mut Y, ) -> Result<(), RuntimeError>

fn on_send_to_stack<Y: KernelInternalApi<System = Self>>( value: &IndexedScryptoValue, api: &mut Y, ) -> Result<(), RuntimeError>

fn on_set_call_frame_data<Y: KernelInternalApi<System = Self>>( data: &Self::CallFrameData, api: &mut Y, ) -> Result<(), RuntimeError>

fn on_get_owned_nodes<Y: KernelInternalApi<System = Self>>( api: &mut Y, ) -> Result<(), RuntimeError>

fn after_invoke<Y: KernelApi<CallbackObject = Self>>( output: &IndexedScryptoValue, api: &mut Y, ) -> Result<(), RuntimeError>

Callback after an invocation and where invocation’s call frame has already been destroyed

fn on_allocate_node_id<Y: KernelInternalApi<System = Self>>( entity_type: EntityType, api: &mut Y, ) -> Result<(), RuntimeError>

Callback before node id allocation

fn on_mark_substate_as_transient<Y: KernelInternalApi<System = Self>>( node_id: &NodeId, partition_number: &PartitionNumber, substate_key: &SubstateKey, api: &mut Y, ) -> Result<(), RuntimeError>

Callback before a substate is marked as transient

fn on_substate_lock_fault<Y: KernelApi<CallbackObject = Self>>( node_id: NodeId, partition_num: PartitionNumber, offset: &SubstateKey, api: &mut Y, ) -> Result<bool, RuntimeError>

Callback when a substate does not exist

fn on_drop_node_mut<Y: KernelApi<CallbackObject = Self>>( node_id: &NodeId, api: &mut Y, ) -> Result<(), RuntimeError>

Callback before a node is dropped

impl<V: SystemCallbackObject> KernelTransactionExecutor for System<V>

type Init = SystemInit<<V as SystemCallbackObject>::Init>

Initialization object

type Executable = ExecutableTransaction

The transaction object

type ExecutionOutput = Vec<InstructionOutput>

Output to be returned at the end of execution

type Receipt = TransactionReceipt

Final receipt to be created after transaction execution

fn init( store: &mut impl CommitableSubstateStore, executable: &ExecutableTransaction, init_input: Self::Init, always_visible_global_nodes: &'static IndexSet<NodeId>, ) -> Result<(Self, Vec<CallFrameInit<Actor>>), Self::Receipt>

Create the callback object (system layer) and the initial call frame configuration for each intent

fn execute<Y: SystemBasedKernelApi>( api: &mut Y, executable: &ExecutableTransaction, ) -> Result<Vec<InstructionOutput>, RuntimeError>

Start execution

fn finalize( &mut self, executable: &ExecutableTransaction, info: StoreCommitInfo, ) -> Result<(), RuntimeError>

Finish execution

fn create_receipt<S: SubstateDatabase>( self, track: Track<'_, S>, interpretation_result: Result<Vec<InstructionOutput>, TransactionExecutionError>, ) -> TransactionReceipt

Create final receipt