Struct MockConsensusNode

pub struct MockConsensusNode {
    pub task_manager: TaskManager,
    pub client: Arc<Client>,
    pub backend: Arc<Backend>,
    pub executor: RuntimeExecutor,
    pub transaction_pool: Arc<FullPool<Client, Block, Header>>,
    pub select_chain: FullSelectChain,
    pub network_service: Arc<dyn NetworkService + Send + Sync>,
    pub xdm_gossip_notification_service: Option<Box<dyn NotificationService>>,
    pub sync_service: Arc<SyncingService<Block>>,
    pub rpc_handlers: RpcHandlers,
    pub network_starter: Option<NetworkStarter>,
    pub key: Sr25519Keyring,
    /* private fields */
}

A mock Subspace consensus node instance used for testing.

Fields

task_manager: TaskManager

TaskManager’s instance.

client: Arc<Client>

Client’s instance.

backend: Arc<Backend>

Backend.

executor: RuntimeExecutor

Code executor.

transaction_pool: Arc<FullPool<Client, Block, Header>>

Transaction pool.

select_chain: FullSelectChain

The SelectChain Strategy

network_service: Arc<dyn NetworkService + Send + Sync>

Network service.

xdm_gossip_notification_service: Option<Box<dyn NotificationService>>

Cross-domain gossip notification service.

sync_service: Arc<SyncingService<Block>>

Sync service.

rpc_handlers: RpcHandlers

RPC handlers.

network_starter: Option<NetworkStarter>

Network starter

key: Sr25519Keyring

Ferdie key

Implementations

impl MockConsensusNode

pub fn run( tokio_handle: Handle, key: Sr25519Keyring, base_path: BasePath, ) -> MockConsensusNode

Run a mock consensus node

pub fn run_with_finalization_depth( tokio_handle: Handle, key: Sr25519Keyring, base_path: BasePath, finalize_block_depth: Option<NumberFor<Block>>, ) -> MockConsensusNode

Run a mock consensus node with finalization depth

pub fn start_network(&mut self)

Start the mock consensus node network

pub fn xdm_gossip_worker_builder(&mut self) -> &mut GossipWorkerBuilder

Get the cross domain gossip message worker builder

pub fn start_cross_domain_gossip_message_worker(&mut self)

Start the cross domain gossip message worker.

pub fn next_slot(&self) -> u64

Return the next slot number

pub fn set_next_slot(&mut self, next_slot: u64)

Set the next slot number

pub fn produce_slot(&mut self) -> (Slot, PotOutput)

Produce a slot only, without waiting for the potential slot handlers.

pub async fn notify_new_slot_and_wait_for_bundle( &mut self, new_slot: (Slot, PotOutput), ) -> Option<OpaqueBundle<NumberFor<Block>, Hash, DomainHeader, Balance>>

Notify the executor about the new slot and wait for the bundle produced at this slot.

pub async fn produce_slot_and_wait_for_bundle_submission( &mut self, ) -> ((Slot, PotOutput), OpaqueBundle<NumberFor<Block>, Hash, DomainHeader, Balance>)

Produce a new slot and wait for a bundle produced at this slot.

pub fn new_slot_notification_stream( &mut self, ) -> UnboundedReceiver<(Slot, PotOutput)>

Subscribe the new slot notification

pub fn new_acknowledgement_sender_stream( &mut self, ) -> TracingUnboundedReceiver<Sender<()>>

Subscribe the acknowledgement sender stream

pub async fn confirm_acknowledgement(&mut self)

Wait for all the acknowledgements before return

It is used to wait for the acknowledgement of the domain worker to ensure it have finish all the previous tasks before return

pub async fn confirm_block_import_processed(&mut self)

Wait for the operator finish processing the consensus block before return

pub fn block_importing_notification_stream( &mut self, ) -> TracingUnboundedReceiver<(NumberFor<Block>, Sender<()>)>

Subscribe the block importing notification

pub fn get_bundle_from_tx_pool( &self, new_slot: (Slot, PotOutput), ) -> Option<OpaqueBundle<NumberFor<Block>, Hash, DomainHeader, Balance>>

Get the bundle that created at slot from the transaction pool

pub async fn submit_transaction( &self, tx: OpaqueExtrinsic, ) -> Result<H256, PoolError>

Submit a tx to the tx pool

pub async fn clear_tx_pool(&self) -> Result<(), Box<dyn Error>>

Remove all tx from the tx pool

pub async fn prune_tx_from_pool( &self, tx: &OpaqueExtrinsic, ) -> Result<(), Box<dyn Error>>

Remove a ready transaction from transaction pool.

pub fn does_receipt_exist( &self, er_hash: <DomainBlock as BlockT>::Hash, ) -> Result<bool, Box<dyn Error>>

Return if the given ER exist in the consensus state

pub fn wait_for_fraud_proof<FP>( &self, fraud_proof_predict: FP, ) -> Pin<Box<dyn Future<Output = ()> + Send>>

where FP: Fn(&FraudProof<NumberFor<Block>, <Block as BlockT>::Hash, <DomainBlock as BlockT>::Header, H256>) -> bool + Send + 'static,

Return a future that only resolve if a fraud proof that the given fraud_proof_predict return true is submitted to the consensus tx pool

pub fn free_balance(&self, account_id: AccountId) -> Balance

Get the free balance of the given account

impl MockConsensusNode

pub async fn produce_block_with_slot_at( &mut self, new_slot: (Slot, PotOutput), parent_hash: <Block as BlockT>::Hash, maybe_extrinsics: Option<Vec<<Block as BlockT>::Extrinsic>>, ) -> Result<<Block as BlockT>::Hash, Box<dyn Error>>

Produce a new block with the slot on top of parent_hash, with optional specified extrinsic list.

pub async fn produce_block_with_slot( &mut self, slot: (Slot, PotOutput), ) -> Result<(), Box<dyn Error>>

Produce a new block on top of the current best block, with the extrinsics collected from the transaction pool.

pub async fn produce_block_with_extrinsics( &mut self, extrinsics: Vec<<Block as BlockT>::Extrinsic>, ) -> Result<(), Box<dyn Error>>

Produce a new block on top of the current best block, with the specificed extrinsics.

pub async fn produce_blocks(&mut self, n: u64) -> Result<(), Box<dyn Error>>

Produce n number of blocks.

pub async fn produce_blocks_with_bundles( &mut self, n: u64, ) -> Result<(), Box<dyn Error>>

Produce n number of blocks and wait for bundle submitted to the block.

pub fn account_nonce(&self) -> u32

Get the nonce of the node account

pub fn construct_extrinsic( &mut self, nonce: u32, function: impl Into<<Runtime as Config>::RuntimeCall>, ) -> UncheckedExtrinsic

Construct an extrinsic.

pub async fn construct_and_send_extrinsic_with( &mut self, function: impl Into<<Runtime as Config>::RuntimeCall>, ) -> Result<RpcTransactionOutput, RpcTransactionError>

Construct and send extrinsic through rpc