Struct radix_engine::system::system_modules::SystemModuleMixer

pub struct SystemModuleMixer {
    pub enabled_modules: EnabledModules,
    pub(super) kernel_trace: KernelTraceModule,
    pub(super) limits: LimitsModule,
    pub(super) costing: CostingModule,
    pub(super) auth: AuthModule,
    pub(crate) transaction_runtime: TransactionRuntimeModule,
    pub(super) execution_trace: ExecutionTraceModule,
}

Fields

enabled_modules: EnabledModules

kernel_trace: KernelTraceModule

limits: LimitsModule

costing: CostingModule

auth: AuthModule

transaction_runtime: TransactionRuntimeModule

execution_trace: ExecutionTraceModule

Implementations

impl SystemModuleMixer

pub fn new( enabled_modules: EnabledModules, network_definition: NetworkDefinition, tx_hash: Hash, auth_zone_params: AuthZoneParams, fee_reserve: SystemLoanFeeReserve, fee_table: FeeTable, payload_len: usize, num_of_signature_validations: usize, execution_config: &ExecutionConfig ) -> Self

pub fn unpack( self ) -> (CostingModule, TransactionRuntimeModule, ExecutionTraceModule)

impl SystemModuleMixer

pub fn on_call_method<Y, V>( api: &mut SystemService<'_, Y, V>, receiver: &NodeId, module_id: ModuleId, direct_access: bool, ident: &str, args: &IndexedScryptoValue ) -> Result<NodeId, RuntimeError>

where V: SystemCallbackObject, Y: KernelApi<SystemConfig<V>>,

pub fn on_call_method_finish<Y, V>( api: &mut SystemService<'_, Y, V>, auth_zone: NodeId ) -> Result<(), RuntimeError>

where V: SystemCallbackObject, Y: KernelApi<SystemConfig<V>>,

pub fn on_call_function<V, Y>( api: &mut SystemService<'_, Y, V>, blueprint_id: &BlueprintId, ident: &str ) -> Result<NodeId, RuntimeError>

where V: SystemCallbackObject, Y: KernelApi<SystemConfig<V>>,

pub fn on_call_function_finish<V, Y>( api: &mut SystemService<'_, Y, V>, auth_zone: NodeId ) -> Result<(), RuntimeError>

where V: SystemCallbackObject, Y: KernelApi<SystemConfig<V>>,

pub fn add_log( &mut self, level: Level, message: String ) -> Result<(), RuntimeError>

pub fn assert_can_add_event(&mut self) -> Result<(), RuntimeError>

pub fn add_event_unchecked(&mut self, event: Event) -> Result<(), RuntimeError>

pub fn checked_add_event(&mut self, event: Event) -> Result<(), RuntimeError>

pub fn set_panic_message(&mut self, message: String) -> Result<(), RuntimeError>

pub fn add_replacement( &mut self, old: (NodeId, ModuleId), new: (NodeId, ModuleId) )

pub fn fee_reserve(&mut self) -> Option<&SystemLoanFeeReserve>

pub fn costing(&mut self) -> Option<&CostingModule>

pub fn costing_mut(&mut self) -> Option<&mut CostingModule>

pub fn limits_mut(&mut self) -> Option<&mut LimitsModule>

pub fn transaction_hash(&self) -> Option<Hash>

pub fn generate_ruid(&mut self) -> Option<[u8; 32]>

pub fn update_instruction_index(&mut self, new_index: usize)

pub fn apply_execution_cost( &mut self, costing_entry: ExecutionCostingEntry<'_> ) -> Result<(), RuntimeError>

pub fn apply_finalization_cost( &mut self, costing_entry: FinalizationCostingEntry<'_> ) -> Result<(), RuntimeError>

pub fn apply_storage_cost( &mut self, storage_type: StorageType, size_increase: usize ) -> Result<(), RuntimeError>

pub fn lock_fee( &mut self, vault_id: NodeId, locked_fee: LiquidFungibleResource, contingent: bool )

pub fn events(&self) -> &Vec<Event>

pub fn logs(&self) -> &Vec<(Level, String)>

Trait Implementations

impl InitSystemModule for SystemModuleMixer

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

impl<V: SystemCallbackObject> SystemModule<SystemConfig<V>> for SystemModuleMixer

fn on_teardown<Y: KernelApi<SystemConfig<V>>>( api: &mut Y ) -> Result<(), RuntimeError>

fn before_invoke<Y: KernelApi<SystemConfig<V>>>( api: &mut Y, invocation: &KernelInvocation<Actor> ) -> Result<(), RuntimeError>

fn on_execution_start<Y: KernelApi<SystemConfig<V>>>( api: &mut Y ) -> Result<(), RuntimeError>

fn on_execution_finish<Y: KernelApi<SystemConfig<V>>>( api: &mut Y, message: &CallFrameMessage ) -> Result<(), RuntimeError>

fn after_invoke<Y: KernelApi<SystemConfig<V>>>( api: &mut Y, output: &IndexedScryptoValue ) -> Result<(), RuntimeError>

fn on_allocate_node_id<Y: KernelApi<SystemConfig<V>>>( api: &mut Y, entity_type: EntityType ) -> Result<(), RuntimeError>

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

fn on_pin_node( system: &mut SystemConfig<V>, node_id: &NodeId ) -> Result<(), RuntimeError>

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

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

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

fn on_mark_substate_as_transient( system: &mut SystemConfig<V>, node_id: &NodeId, partition_number: &PartitionNumber, substate_key: &SubstateKey ) -> Result<(), RuntimeError>

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

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

fn on_close_substate<Y: KernelInternalApi<SystemConfig<V>>>( api: &mut Y, event: &CloseSubstateEvent ) -> Result<(), RuntimeError>

fn on_set_substate( system: &mut SystemConfig<V>, event: &SetSubstateEvent<'_> ) -> Result<(), RuntimeError>

fn on_remove_substate( system: &mut SystemConfig<V>, event: &RemoveSubstateEvent<'_> ) -> Result<(), RuntimeError>

fn on_scan_keys( system: &mut SystemConfig<V>, event: &ScanKeysEvent<'_> ) -> Result<(), RuntimeError>

fn on_drain_substates( system: &mut SystemConfig<V>, event: &DrainSubstatesEvent<'_> ) -> Result<(), RuntimeError>

fn on_scan_sorted_substates( system: &mut SystemConfig<V>, event: &ScanSortedSubstatesEvent<'_> ) -> Result<(), RuntimeError>