Struct ClientBuilder 

pub struct ClientBuilder<AUTH> {
    pub store: Option<StoreBuilder>,
    /* private fields */
}

A builder for constructing a Miden client.

This builder allows you to configure the various components required by the client, such as the RPC endpoint, store, RNG, and authenticator. It is generic over the authenticator type.

Network-Aware Constructors

Use one of the network-specific constructors to get sensible defaults for a specific network:

• for_testnet() - Pre-configured for Miden testnet
• for_devnet() - Pre-configured for Miden devnet
• for_localhost() - Pre-configured for local development

The builder provides defaults for:

• RPC endpoint: Automatically configured based on the network
• Transaction prover: Remote for testnet/devnet, local for localhost
• RNG: Random seed-based prover randomness

Components

The client requires several components to function:

• RPC client (NodeRpcClient): Provides connectivity to the Miden node for submitting transactions, syncing state, and fetching account/note data. Configure via rpc() or grpc_client().

• Store (Store): Provides persistence for accounts, notes, and transaction history. Configure via store().

• RNG (FeltRng): Provides randomness for generating keys, serial numbers, and other cryptographic operations. If not provided, a random seed-based RNG is created automatically. Configure via rng().

• Authenticator (TransactionAuthenticator): Handles transaction signing when signatures are requested from within the VM. Configure via authenticator().

• Transaction prover (TransactionProver): Generates proofs for transactions. Defaults to a local prover if not specified. Configure via prover().

• Note transport (NoteTransportClient): Optional component for exchanging private notes through the Miden note transport network. Configure via note_transport().

• Debug mode: Enables debug mode for transaction execution. Configure via in_debug_mode().

• Transaction discard delta: Number of blocks after which pending transactions are considered stale and discarded. Configure via tx_discard_delta().

• Max block number delta: Maximum number of blocks the client can be behind the network for transactions and account proofs to be considered valid. Configure via max_block_number_delta().

Fields

store: Option<StoreBuilder>

An optional store provided by the user.

Implementations

impl<AUTH> ClientBuilder<AUTH>

where AUTH: BuilderAuthenticator,

Network-specific constructors for ClientBuilder.

These constructors automatically configure the builder for a specific network, including RPC endpoint, transaction prover, and note transport (where applicable).

pub fn for_testnet() -> ClientBuilder<AUTH>

Creates a ClientBuilder pre-configured for Miden testnet.

This automatically configures:

• RPC: https://rpc.testnet.miden.io
• Prover: Remote prover at https://tx-prover.testnet.miden.io
• Note transport: https://transport.miden.io

You still need to provide:

• A store (via .store())
• An authenticator (via .authenticator())

All defaults can be overridden by calling the corresponding builder methods after for_testnet().

Example

let client = ClientBuilder::for_testnet()
    .store(store)
    .authenticator(Arc::new(keystore))
    .build()
    .await?;

pub fn for_devnet() -> ClientBuilder<AUTH>

Creates a ClientBuilder pre-configured for Miden devnet.

This automatically configures:

• RPC: https://rpc.devnet.miden.io
• Prover: Remote prover at https://tx-prover.devnet.miden.io

Note transport is not configured by default for devnet.

You still need to provide:

• A store (via .store())
• An authenticator (via .authenticator())

All defaults can be overridden by calling the corresponding builder methods after for_devnet().

Example

let client = ClientBuilder::for_devnet()
    .store(store)
    .authenticator(Arc::new(keystore))
    .build()
    .await?;

pub fn for_localhost() -> ClientBuilder<AUTH>

Creates a ClientBuilder pre-configured for localhost.

This automatically configures:

• RPC: http://localhost:57291
• Prover: Local (default)

Note transport is not configured by default for localhost.

You still need to provide:

• A store (via .store())
• An authenticator (via .authenticator())

All defaults can be overridden by calling the corresponding builder methods after for_localhost().

Example

let client = ClientBuilder::for_localhost()
    .store(store)
    .authenticator(Arc::new(keystore))
    .build()
    .await?;

impl<AUTH> ClientBuilder<AUTH>

where AUTH: BuilderAuthenticator,

pub fn new() -> ClientBuilder<AUTH>

Create a new ClientBuilder with default settings.

pub fn in_debug_mode(self, debug: DebugMode) -> ClientBuilder<AUTH>

Enable or disable debug mode.

pub fn rpc(self, client: Arc<dyn NodeRpcClient>) -> ClientBuilder<AUTH>

Sets a custom RPC client directly.

pub fn grpc_client( self, endpoint: &Endpoint, timeout_ms: Option<u64>, ) -> ClientBuilder<AUTH>

Sets a gRPC client from the endpoint and optional timeout.

pub fn store(self, store: Arc<dyn Store>) -> ClientBuilder<AUTH>

Provide a store to be used by the client.

pub fn rng(self, rng: Box<dyn ClientFeltRng>) -> ClientBuilder<AUTH>

Optionally provide a custom RNG.

pub fn authenticator(self, authenticator: Arc<AUTH>) -> ClientBuilder<AUTH>

Optionally provide a custom authenticator instance.

pub fn max_block_number_delta(self, delta: u32) -> ClientBuilder<AUTH>

Optionally set a maximum number of blocks that the client can be behind the network. By default, there’s no maximum.

pub fn tx_discard_delta(self, delta: Option<u32>) -> ClientBuilder<AUTH>

Sets the number of blocks after which pending transactions are considered stale and discarded.

If a transaction has not been included in a block within this many blocks after submission, it will be discarded. If None, transactions will be kept indefinitely.

By default, the delta is set to TX_DISCARD_DELTA (20 blocks).

pub fn tx_graceful_blocks(self, delta: Option<u32>) -> ClientBuilder<AUTH>

👎Deprecated since 0.10.0: Use tx_discard_delta instead

Sets the number of blocks after which pending transactions are considered stale and discarded.

This is an alias for tx_discard_delta.

pub fn note_transport( self, client: Arc<dyn NoteTransportClient>, ) -> ClientBuilder<AUTH>

Sets a custom note transport client directly.

pub fn prover( self, prover: Arc<dyn TransactionProver + Send + Sync>, ) -> ClientBuilder<AUTH>

Sets a custom transaction prover.

pub fn endpoint(&self) -> Option<&Endpoint>

Returns the endpoint configured for this builder, if any.

This is set automatically when using network-specific constructors like for_testnet(), for_devnet(), or for_localhost().

pub async fn build(self) -> Result<Client<AUTH>, ClientError>

Build and return the Client.

Errors

• Returns an error if no RPC client was provided.
• Returns an error if the store cannot be instantiated.

impl ClientBuilder<FilesystemKeyStore>

Convenience method for ClientBuilder when using FilesystemKeyStore as the authenticator.

pub fn filesystem_keystore( self, keystore_path: impl Into<PathBuf>, ) -> Result<ClientBuilder<FilesystemKeyStore>, ClientError>

Creates a FilesystemKeyStore from the given path and sets it as the authenticator.

This is a convenience method that creates the keystore and configures it as the authenticator in a single call. The keystore provides transaction signing capabilities using keys stored on the filesystem.

Errors

Returns an error if the keystore cannot be created from the given path.

Example

let client = ClientBuilder::new()
    .rpc(rpc_client)
    .store(store)
    .filesystem_keystore("path/to/keys")?
    .build()
    .await?;

Trait Implementations

impl<AUTH> ClientBuilderSqliteExt<AUTH> for ClientBuilder<AUTH>

where AUTH: BuilderAuthenticator,

fn sqlite_store(self, database_filepath: PathBuf) -> ClientBuilder<AUTH>

Sets a SqliteStore to the ClientBuilder. The store will be instantiated when the build method is called.

impl<AUTH> Default for ClientBuilder<AUTH>

fn default() -> ClientBuilder<AUTH>

Returns the “default value” for a type.