Struct MockChainBuilder 

pub struct MockChainBuilder { /* private fields */ }

A builder for a MockChain.

Implementations

impl MockChainBuilder

pub fn new() -> Self

Initializes a new mock chain builder with an empty state.

By default, the native_asset_id is set to ACCOUNT_ID_NATIVE_ASSET_FAUCET and can be overwritten using Self::native_asset_id.

The verification_base_fee is initialized to 0 which means no fees are required by default.

pub fn with_accounts( accounts: impl IntoIterator<Item = Account>, ) -> Result<Self>

Initializes a new mock chain builder with the provided accounts.

This method only adds the accounts and cannot not register any seed or authenticator for it. Calling MockChain::build_tx_context on accounts added in this way will not work if the account is new or if they need an authenticator.

Due to these limitations, prefer using other methods to add accounts to the chain, e.g. MockChainBuilder::add_account_from_builder.

pub fn native_asset_id(self, native_asset_id: AccountId) -> Self

Sets the native asset ID of the chain.

This must be a fungible faucet AccountId and is the asset in which fees will be accepted by the transaction kernel.

pub fn verification_base_fee(self, verification_base_fee: u32) -> Self

Sets the verification_base_fee of the chain.

See FeeParameters for more details.

pub fn build(self) -> Result<MockChain>

Consumes the builder, creates the genesis block of the chain and returns the MockChain.

pub fn create_new_wallet(&mut self, auth_method: Auth) -> Result<Account>

Creates a new public BasicWallet account and registers the authenticator (if any) and seed.

This does not add the account to the chain state, but it can still be used to call MockChain::build_tx_context to automatically handle the authenticator and seed.

pub fn add_existing_wallet(&mut self, auth_method: Auth) -> Result<Account>

Adds an existing public BasicWallet account to the initial chain state and registers the authenticator (if any).

pub fn add_existing_wallet_with_assets( &mut self, auth_method: Auth, assets: impl IntoIterator<Item = Asset>, ) -> Result<Account>

Adds an existing public BasicWallet account to the initial chain state and registers the authenticator (if any).

pub fn create_new_faucet( &mut self, auth_method: Auth, token_symbol: &str, max_supply: u64, ) -> Result<Account>

Creates a new public BasicFungibleFaucet account and registers the authenticator (if any) and seed.

This does not add the account to the chain state, but it can still be used to call MockChain::build_tx_context to automatically handle the authenticator and seed.

pub fn add_existing_faucet( &mut self, auth_method: Auth, token_symbol: &str, max_supply: u64, total_issuance: Option<u64>, ) -> Result<Account>

Adds an existing public BasicFungibleFaucet account to the initial chain state and registers the authenticator (if the given Auth results in the creation of one).

pub fn create_new_mock_account(&mut self, auth_method: Auth) -> Result<Account>

Creates a new public account with an MockAccountComponent and registers the authenticator (if any).

pub fn add_existing_mock_account( &mut self, auth_method: Auth, ) -> Result<Account>

Adds an existing public account with an MockAccountComponent to the initial chain state and registers the authenticator (if any).

pub fn add_existing_mock_account_with_storage( &mut self, auth_method: Auth, slots: impl IntoIterator<Item = StorageSlot>, ) -> Result<Account>

Adds an existing public account with an MockAccountComponent to the initial chain state and registers the authenticator (if any).

pub fn add_existing_mock_account_with_assets( &mut self, auth_method: Auth, assets: impl IntoIterator<Item = Asset>, ) -> Result<Account>

Adds an existing public account with an MockAccountComponent to the initial chain state and registers the authenticator (if any).

pub fn add_existing_mock_account_with_storage_and_assets( &mut self, auth_method: Auth, slots: impl IntoIterator<Item = StorageSlot>, assets: impl IntoIterator<Item = Asset>, ) -> Result<Account>

Adds an existing public account with an MockAccountComponent to the initial chain state and registers the authenticator (if any).

pub fn add_account_from_builder( &mut self, auth_method: Auth, account_builder: AccountBuilder, account_state: AccountState, ) -> Result<Account>

Builds the provided AccountBuilder with the provided auth method and registers the authenticator (if any).

• If AccountState::Exists is given the account is built as an existing account and added to the initial chain state. It can then be used in a transaction without having to validate its seed.
• If AccountState::New is given the account is built as a new account and is not added to the chain. Its seed and authenticator are registered (if any). Its first transaction will be its creation transaction. MockChain::build_tx_context can be called with the account to automatically handle the authenticator and seed.

pub fn add_account(&mut self, account: Account) -> Result<()>

Adds the provided account to the list of genesis accounts.

This method only adds the account and does not store its account credentials (seed and authenticator) for it. Calling MockChain::build_tx_context on accounts added in this way will not work if the account is new or if they need an authenticator.

Due to these limitations, prefer using other methods to add accounts to the chain, e.g. MockChainBuilder::add_account_from_builder.

pub fn add_note(&mut self, note: impl Into<OutputNote>)

Adds the provided note to the initial chain state.

pub fn add_p2any_note( &mut self, sender_account_id: AccountId, asset: &[Asset], ) -> Result<Note>

Creates a new P2ANY note from the provided parameters and adds it to the list of genesis notes. This note is similar to a P2ID note but can be consumed by any account.

In the created MockChain, the note will be immediately spendable by target_account_id and carries no additional reclaim or timelock conditions.

pub fn add_p2id_note( &mut self, sender_account_id: AccountId, target_account_id: AccountId, asset: &[Asset], note_type: NoteType, ) -> Result<Note, NoteError>

Creates a new P2ID note from the provided parameters and adds it to the list of genesis notes.

In the created MockChain, the note will be immediately spendable by target_account_id and carries no additional reclaim or timelock conditions.

pub fn add_p2ide_note( &mut self, sender_account_id: AccountId, target_account_id: AccountId, asset: &[Asset], note_type: NoteType, reclaim_height: Option<BlockNumber>, timelock_height: Option<BlockNumber>, ) -> Result<Note, NoteError>

Adds a P2IDE OutputNote (pay‑to‑ID‑extended) to the list of genesis notes.

A P2IDE note can include an optional timelock_height and/or an optional reclaim_height after which the sender_account_id may reclaim the funds.

pub fn add_swap_note( &mut self, sender: AccountId, offered_asset: Asset, requested_asset: Asset, payback_note_type: NoteType, ) -> Result<(Note, NoteDetails)>

Adds a public SWAP OutputNote to the list of genesis notes.

pub fn add_spawn_note<'note>( &mut self, sender_id: AccountId, output_notes: impl IntoIterator<Item = &'note Note>, ) -> Result<Note>

Adds a public SPAWN note to the list of genesis notes.

A SPAWN note contains a note script that creates all output_notes that get passed as a parameter.

pub fn add_p2id_note_with_fee( &mut self, target_account_id: AccountId, amount: u64, ) -> Result<Note>

Creates a new P2ID note with the provided amount of the native fee asset of the chain.

The native asset ID of the asset can be set using Self::native_asset_id. By default it is ACCOUNT_ID_NATIVE_ASSET_FAUCET.

In the created MockChain, the note will be immediately spendable by target_account_id.

Trait Implementations

impl Clone for MockChainBuilder

fn clone(&self) -> MockChainBuilder

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MockChainBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MockChainBuilder

fn default() -> Self

Returns the “default value” for a type.