Trait KernelCallbackObject

pub trait KernelCallbackObject: Sized {
    type LockData: Default + Clone;
    type CallFrameData: CallFrameReferences;

    // Required methods
    fn on_pin_node<Y: KernelInternalApi<System = Self>>(
        node_id: &NodeId,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_create_node<Y: KernelInternalApi<System = Self>>(
        event: CreateNodeEvent<'_>,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_drop_node<Y: KernelInternalApi<System = Self>>(
        event: DropNodeEvent<'_>,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_move_module<Y: KernelInternalApi<System = Self>>(
        event: MoveModuleEvent<'_>,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_open_substate<Y: KernelInternalApi<System = Self>>(
        event: OpenSubstateEvent<'_>,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_close_substate<Y: KernelInternalApi<System = Self>>(
        event: CloseSubstateEvent,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_read_substate<Y: KernelInternalApi<System = Self>>(
        event: ReadSubstateEvent<'_>,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_write_substate<Y: KernelInternalApi<System = Self>>(
        event: WriteSubstateEvent<'_>,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_set_substate<Y: KernelInternalApi<System = Self>>(
        event: SetSubstateEvent<'_>,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_remove_substate<Y: KernelInternalApi<System = Self>>(
        event: RemoveSubstateEvent<'_>,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_scan_keys<Y: KernelInternalApi<System = Self>>(
        event: ScanKeysEvent<'_>,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_drain_substates<Y: KernelInternalApi<System = Self>>(
        event: DrainSubstatesEvent<'_>,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_scan_sorted_substates<Y: KernelInternalApi<System = Self>>(
        event: ScanSortedSubstatesEvent<'_>,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn before_invoke<Y: KernelApi<CallbackObject = Self>>(
        invocation: &KernelInvocation<Self::CallFrameData>,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_execution_start<Y: KernelInternalApi<System = Self>>(
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn invoke_upstream<Y: KernelApi<CallbackObject = Self>>(
        args: &IndexedScryptoValue,
        api: &mut Y,
    ) -> Result<IndexedScryptoValue, RuntimeError>;
    fn auto_drop<Y: KernelApi<CallbackObject = Self>>(
        nodes: Vec<NodeId>,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_execution_finish<Y: KernelInternalApi<System = Self>>(
        message: &CallFrameMessage,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn after_invoke<Y: KernelApi<CallbackObject = Self>>(
        output: &IndexedScryptoValue,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_allocate_node_id<Y: KernelInternalApi<System = Self>>(
        entity_type: EntityType,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_mark_substate_as_transient<Y: KernelInternalApi<System = Self>>(
        node_id: &NodeId,
        partition_number: &PartitionNumber,
        substate_key: &SubstateKey,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    fn on_substate_lock_fault<Y: KernelApi<CallbackObject = Self>>(
        node_id: NodeId,
        partition_num: PartitionNumber,
        offset: &SubstateKey,
        api: &mut Y,
    ) -> Result<bool, RuntimeError>;
    fn on_drop_node_mut<Y: KernelApi<CallbackObject = Self>>(
        node_id: &NodeId,
        api: &mut Y,
    ) -> Result<(), RuntimeError>;
    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>;
}

Upper layer callback object which a kernel interacts with during execution

Required Associated Types

type LockData: Default + Clone

Data to be stored with each substate lock

type CallFrameData: CallFrameReferences

Data to be stored with every call frame

Required Methods

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<Self::CallFrameData>, 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>>( args: &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 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

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>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

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

type LockData = SystemLockData

type CallFrameData = Actor