Struct Client

pub struct Client<R: FeltRng> { /* private fields */ }

A light client for connecting to the Miden rollup network.

Miden client is responsible for managing a set of accounts. Specifically, the client:

• Keeps track of the current and historical states of a set of accounts and related objects such as notes and transactions.
• Connects to one or more Miden nodes to periodically sync with the current state of the network.
• Executes, proves, and submits transactions to the network as directed by the user.

Implementations

impl<R: FeltRng> Client<R>

pub async fn new_account( &mut self, template: AccountTemplate, ) -> Result<(Account, Word), ClientError>

Creates a new Account based on an AccountTemplate and saves it in the client’s store. A new tag derived from the account will start being tracked by the client.

pub async fn import_account( &mut self, account_data: AccountData, ) -> Result<(), ClientError>

Saves in the store the Account corresponding to account_data.

Errors

Will return an error if trying to import a new account without providing its seed

Panics

Will panic when trying to import a non-new account without a seed since this functionality is not currently implemented

pub async fn insert_account( &mut self, account: &Account, account_seed: Option<Word>, auth_info: &AuthSecretKey, ) -> Result<(), ClientError>

Inserts a new account into the client’s store.

Errors

If an account is new and no seed is provided, the function errors out because the client cannot execute transactions against new accounts for which it does not know the seed.

pub async fn get_account_headers( &self, ) -> Result<Vec<(AccountHeader, Option<Word>)>, ClientError>

Returns a list of AccountHeader of all accounts stored in the database along with the seeds used to create them.

Said accounts’ state is the state after the last performed sync.

pub async fn get_account( &self, account_id: AccountId, ) -> Result<(Account, Option<Word>), ClientError>

Retrieves a full Account object. The seed will be returned if the account is new, otherwise it will be None.

This function returns the Account’s latest state. If the account is new (that is, has never executed a transaction), the returned seed will be Some(Word); otherwise the seed will be None

Errors

Returns a StoreError::AccountDataNotFound if there is no account for the provided ID

pub async fn get_account_header_by_id( &self, account_id: AccountId, ) -> Result<(AccountHeader, Option<Word>), ClientError>

Retrieves an AccountHeader object for the specified AccountId along with the seed used to create it. The seed will be returned if the account is new, otherwise it will be None.

Said account’s state is the state according to the last sync performed.

Errors

Returns a StoreError::AccountDataNotFound if there is no account for the provided ID

pub async fn get_account_auth( &self, account_id: AccountId, ) -> Result<AuthSecretKey, ClientError>

Returns an AuthSecretKey object utilized to authenticate an account.

Errors

Returns a ClientError::StoreError with a StoreError::AccountDataNotFound if the provided ID does not correspond to an existing account.

impl<R: FeltRng> Client<R>

pub async fn import_note( &mut self, note_file: NoteFile, ) -> Result<NoteId, ClientError>

Imports a new input note into the client’s store. The information stored depends on the type of note file provided. If the note existed previously, it will be updated with the new information. The tag specified by the NoteFile will start being tracked.

• If the note file is a NoteFile::NoteId, the note is fetched from the node and stored in the client’s store. If the note is private or does not exist, an error is returned.
• If the note file is a NoteFile::NoteDetails, a new note is created with the provided details and tag.
• If the note file is a NoteFile::NoteWithProof, the note is stored with the provided inclusion proof and metadata. The block header data is only fetched from the node if the note is committed in the past relative to the client.

impl<R: FeltRng> Client<R>

pub async fn get_input_notes( &self, filter: NoteFilter, ) -> Result<Vec<InputNoteRecord>, ClientError>

Retrieves the input notes managed by the client from the store.

Errors

Returns a ClientError::StoreError if the filter is NoteFilter::Unique and there is no Note with the provided ID

pub async fn get_consumable_notes( &self, account_id: Option<AccountId>, ) -> Result<Vec<(InputNoteRecord, Vec<NoteConsumability>)>, ClientError>

Returns the input notes and their consumability.

If account_id is None then all consumable input notes are returned.

pub async fn get_note_consumability( &self, note: InputNoteRecord, ) -> Result<Vec<NoteConsumability>, ClientError>

Returns the consumability of the provided note.

pub async fn get_input_note( &self, note_id: NoteId, ) -> Result<InputNoteRecord, ClientError>

Retrieves the input note given a NoteId

Errors

Returns an error if there is no Note with the provided ID

pub async fn get_output_notes( &self, filter: NoteFilter, ) -> Result<Vec<OutputNoteRecord>, ClientError>

Returns output notes managed by this client.

pub async fn get_output_note( &self, note_id: NoteId, ) -> Result<OutputNoteRecord, ClientError>

Returns the output note with the specified hash.

pub fn compile_note_script( &self, note_script_ast: &str, ) -> Result<NoteScript, ClientError>

Compiles the provided program into a NoteScript

impl<R: FeltRng> Client<R>

pub async fn get_note_tags(&self) -> Result<Vec<NoteTagRecord>, ClientError>

Returns the list of note tags tracked by the client.

When syncing the state with the node, these tags will be added to the sync request and note-related information will be retrieved for notes that have matching tags.

Note: Tags for accounts that are being tracked by the client are managed automatically by the client and do not need to be added here. That is, notes for managed accounts will be retrieved automatically by the client when syncing.

pub async fn get_unique_note_tags( &self, ) -> Result<BTreeSet<NoteTag>, ClientError>

Returns the unique note tags (without source) that the client is interested in.

pub async fn add_note_tag(&mut self, tag: NoteTag) -> Result<(), ClientError>

Adds a note tag for the client to track.

pub async fn remove_note_tag(&mut self, tag: NoteTag) -> Result<(), ClientError>

Removes a note tag for the client to track.

impl<R: FeltRng> Client<R>

pub async fn get_sync_height(&self) -> Result<u32, ClientError>

Returns the block number of the last state sync block.

pub async fn sync_state(&mut self) -> Result<SyncSummary, ClientError>

Syncs the client’s state with the current state of the Miden network. Before doing so, it ensures the genesis block exists in the local store.

Returns the block number the client has been synced to.

impl<R: FeltRng> Client<R>

pub async fn get_transactions( &self, filter: TransactionFilter, ) -> Result<Vec<TransactionRecord>, ClientError>

Retrieves tracked transactions, filtered by TransactionFilter.

pub async fn new_transaction( &mut self, account_id: AccountId, transaction_request: TransactionRequest, ) -> Result<TransactionResult, ClientError>

Creates and executes a transaction specified by the request against the specified account, but does not change the local database.

If the transaction utilizes foreign account data, there is a chance that the client does not have the required block header in the local database. In these scenarios, a sync to the chain tip is performed, and the required block header is retrieved.

Errors

• Returns ClientError::MissingOutputNotes if the TransactionRequest ouput notes are not a subset of executor’s output notes.
• Returns a ClientError::TransactionExecutorError if the execution fails.
• Returns a ClientError::TransactionRequestError if the request is invalid.

pub async fn submit_transaction( &mut self, tx_result: TransactionResult, ) -> Result<(), ClientError>

Proves the specified transaction, submits it to the network, and saves the transaction into the local database for tracking.

pub fn compile_tx_script<T>( &self, inputs: T, program: &str, ) -> Result<TransactionScript, ClientError>

where T: IntoIterator<Item = (Word, Vec<Felt>)>,

Compiles the provided transaction script source and inputs into a TransactionScript

pub async fn validate_request( &self, account_id: AccountId, transaction_request: &TransactionRequest, ) -> Result<(), ClientError>

Validates that the specified transaction request can be executed by the specified account.

This function checks that the account has enough balance to cover the outgoing assets. This does’t guarantee that the transaction will succeed, but it’s useful to avoid submitting transactions that are guaranteed to fail.

impl<R: FeltRng> Client<R>

pub fn new( rpc_api: Box<dyn NodeRpcClient + Send>, rng: R, store: Arc<dyn Store>, authenticator: Arc<dyn TransactionAuthenticator>, tx_prover: Arc<dyn TransactionProver>, in_debug_mode: bool, ) -> Self

Returns a new instance of Client.

Arguments

• api: An instance of NodeRpcClient which provides a way for the client to connect to the Miden node.
• store: An instance of Store, which provides a way to write and read entities to provide persistence.
• executor_store: An instance of Store that provides a way for TransactionExecutor to retrieve relevant inputs at the moment of transaction execution. It should be the same store as the one for store, but it doesn’t have to be the same instance.
• authenticator: Defines the transaction authenticator that will be used by the transaction executor whenever a signature is requested from within the VM.
• tx_prover: Defines how transaction proving is performed.
• in_debug_mode: Instantiates the transaction executor (and in turn, its compiler) in debug mode, which will enable debug logs for scripts compiled with this mode for easier MASM debugging.

Errors

Returns an error if the client could not be instantiated.

pub fn rng(&mut self) -> &mut R

Returns a reference to the client’s random number generator. This can be used to generate randomness for various purposes such as serial numbers, keys, etc.