Struct MockChainBuilder 

pub struct MockChainBuilder { /* private fields */ }

Available on crate feature testing only.

A builder for a MockChain’s genesis block.

Example

let mut builder = MockChain::builder();
let existing_wallet =
    builder.add_existing_wallet_with_assets(Auth::IncrNonce, [FungibleAsset::mock(500)])?;
let new_wallet = builder.create_new_wallet(Auth::IncrNonce)?;

let existing_note = builder.add_p2id_note(
    existing_wallet.id(),
    new_wallet.id(),
    &[FungibleAsset::mock(100)],
    NoteType::Private,
)?;
let chain = builder.build()?;

// The existing wallet and note should be part of the chain state.
assert!(chain.committed_account(existing_wallet.id()).is_ok());
assert!(chain.committed_notes().get(&existing_note.id()).is_some());

// The new wallet should *not* be part of the chain state - it must be created in
// a transaction first.
assert!(chain.committed_account(new_wallet.id()).is_err());

Note the distinction between add_ and create_ APIs. Any add_ APIs will add something to the genesis chain state while create_ APIs do not mutate the genesis state. The latter are simply convenient for creating accounts or notes that will be created by transactions.

See also the MockChain docs for examples on using the mock chain.

Implementations

impl MockChainBuilder

pub fn new() -> MockChainBuilder

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<MockChainBuilder, Error>

Initializes a new mock chain builder with the provided accounts.

This method only adds the accounts and cannot not register any authenticators for them. Calling MockChain::build_tx_context on accounts added in this way will not work if the account needs 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) -> MockChainBuilder

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, ) -> MockChainBuilder

Sets the verification_base_fee of the chain.

See FeeParameters for more details.

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

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, Error>

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

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

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

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, Error>

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, Error>

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

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

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

Adds an existing BasicFungibleFaucet account to the initial chain state and registers the authenticator.

Basic fungible faucets always use AccountStorageMode::Public and require authentication.

pub fn add_existing_network_faucet( &mut self, token_symbol: &str, max_supply: u64, owner_account_id: AccountId, total_issuance: Option<u64>, ) -> Result<Account, Error>

Adds an existing NetworkFungibleFaucet account to the initial chain state.

Network fungible faucets always use AccountStorageMode::Network and Auth::NoAuth.

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

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, Error>

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, Error>

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, Error>

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, Error>

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, Error>

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 authenticator is registered (if present). Its first transaction will be its creation transaction. MockChain::build_tx_context can be called with the account to automatically add the authenticator.

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

Adds the provided account to the list of genesis accounts.

This method only adds the account and does not store its account authenticator for it. Calling MockChain::build_tx_context on accounts added in this way will not work if the account needs 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_output_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, note_type: NoteType, assets: impl IntoIterator<Item = Asset>, ) -> Result<Note, Error>

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.

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), Error>

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

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

where I: ExactSizeIterator<Item = &'note 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.

Errors

Returns an error if:

• the sender account ID of the provided output notes is not consistent or does not match the transaction’s sender.

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

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.

pub fn rng_mut(&mut self) -> &mut RpoRandomCoin

Returns a mutable reference to the builder’s RNG.

This can be used when creating accounts or notes and randomness is required.

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<(), Error>

Formats the value using the given formatter.

impl Default for MockChainBuilder

fn default() -> MockChainBuilder

Returns the “default value” for a type.