Struct TransactionRequestBuilder 

pub struct TransactionRequestBuilder { /* private fields */ }

A builder for a TransactionRequest.

Use this builder to construct a TransactionRequest by adding input notes, specifying scripts, and setting other transaction parameters.

Implementations

impl TransactionRequestBuilder

pub fn new() -> Self

Creates a new, empty TransactionRequestBuilder.

pub fn input_notes( self, notes: impl IntoIterator<Item = (Note, Option<NoteArgs>)>, ) -> Self

Adds the specified notes as input notes to the transaction request.

pub fn own_output_notes( self, notes: impl IntoIterator<Item = OutputNote>, ) -> Self

Specifies the output notes that should be created in the transaction script and will be used as a transaction script template. These notes will also be added to the expected output recipients of the transaction.

If a transaction script template is already set (e.g. by calling with_custom_script), the TransactionRequestBuilder::build method will return an error.

pub fn custom_script(self, script: TransactionScript) -> Self

Specifies a custom transaction script to be used.

If a script template is already set (e.g. by calling with_own_output_notes), the TransactionRequestBuilder::build method will return an error.

pub fn foreign_accounts( self, foreign_accounts: impl IntoIterator<Item = impl Into<ForeignAccount>>, ) -> Self

Specifies one or more foreign accounts (public or private) that contain data utilized by the transaction.

At execution, the client queries the node and retrieves the appropriate data, depending on whether each foreign account is public or private:

• Public accounts: the node retrieves the state and code for the account and injects them as advice inputs.
• Private accounts: the node retrieves a proof of the account’s existence and injects that as advice inputs.

pub fn expected_output_recipients(self, recipients: Vec<NoteRecipient>) -> Self

Specifies a transaction’s expected output note recipients.

The set of specified recipients is treated as a subset of the recipients for notes that may be created by a transaction. That is, the transaction must create notes for all the specified expected recipients, but it may also create notes for other recipients not included in this set.

pub fn expected_future_notes(self, notes: Vec<(NoteDetails, NoteTag)>) -> Self

Specifies a set of notes which may be created when a transaction’s output notes are consumed.

For example, after a SWAP note is consumed, a payback note is expected to be created. This allows the client to track this note accordingly.

pub fn extend_advice_map<I, V>(self, iter: I) -> Self

where I: IntoIterator<Item = (Word, V)>, V: AsRef<[Felt]>,

Extends the advice map with the specified ([Word], Vec<[Felt]>) pairs.

pub fn extend_merkle_store<T: IntoIterator<Item = InnerNodeInfo>>( self, iter: T, ) -> Self

Extends the merkle store with the specified InnerNodeInfo elements.

pub fn expiration_delta(self, expiration_delta: u16) -> Self

The number of blocks in relation to the transaction’s reference block after which the transaction will expire. By default, the transaction will not expire.

Setting transaction expiration delta defines an upper bound for transaction expiration, but other code executed during the transaction may impose an even smaller transaction expiration delta.

pub fn ignore_invalid_input_notes(self) -> Self

The resulting transaction will silently ignore invalid input notes when being executed. By default, this will not happen.

pub fn script_arg(self, script_arg: Word) -> Self

Sets an optional Word that will be pushed to the operand stack before the transaction script execution. If the advice map is extended with some user defined entries, this script argument could be used as a key to access the corresponding value.

pub fn auth_arg(self, auth_arg: Word) -> Self

Sets an optional Word that will be pushed to the stack for the authentication procedure during transaction execution.

pub fn build_consume_notes( self, notes: Vec<Note>, ) -> Result<TransactionRequest, TransactionRequestError>

Consumes the builder and returns a TransactionRequest for a transaction to consume the specified notes.

• notes is a list of notes to be consumed.

pub fn build_mint_fungible_asset( self, asset: FungibleAsset, target_id: AccountId, note_type: NoteType, rng: &mut ClientRng, ) -> Result<TransactionRequest, TransactionRequestError>

Consumes the builder and returns a TransactionRequest for a transaction to mint fungible assets. This request must be executed against a fungible faucet account.

• asset is the fungible asset to be minted.
• target_id is the account ID of the account to receive the minted asset.
• note_type determines the visibility of the note to be created.
• rng is the random number generator used to generate the serial number for the created note.

This function cannot be used with a previously set custom script.

pub fn build_pay_to_id( self, payment_data: PaymentNoteDescription, note_type: NoteType, rng: &mut ClientRng, ) -> Result<TransactionRequest, TransactionRequestError>

Consumes the builder and returns a TransactionRequest for a transaction to send a P2ID or P2IDE note. This request must be executed against the wallet sender account.

• payment_data is the data for the payment transaction that contains the asset to be transferred, the sender account ID, and the target account ID. If the recall or timelock heights are set, a P2IDE note will be created; otherwise, a P2ID note will be created.
• note_type determines the visibility of the note to be created.
• rng is the random number generator used to generate the serial number for the created note.

This function cannot be used with a previously set custom script.

pub fn build_swap( self, swap_data: &SwapTransactionData, note_type: NoteType, payback_note_type: NoteType, rng: &mut ClientRng, ) -> Result<TransactionRequest, TransactionRequestError>

Consumes the builder and returns a TransactionRequest for a transaction to send a SWAP note. This request must be executed against the wallet sender account.

• swap_data is the data for the swap transaction that contains the sender account ID, the offered asset, and the requested asset.
• note_type determines the visibility of the note to be created.
• payback_note_type determines the visibility of the payback note.
• rng is the random number generator used to generate the serial number for the created note.

This function cannot be used with a previously set custom script.

pub fn build(self) -> Result<TransactionRequest, TransactionRequestError>

Consumes the builder and returns a TransactionRequest.

Errors

• If both a custom script and own output notes are set.
• If an expiration delta is set when a custom script is set.
• If an invalid note variant is encountered in the own output notes.

Trait Implementations

impl Clone for TransactionRequestBuilder

fn clone(&self) -> TransactionRequestBuilder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionRequestBuilder

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

Formats the value using the given formatter.

impl Default for TransactionRequestBuilder

fn default() -> Self

Returns the “default value” for a type.