Struct MintClientModule 

pub struct MintClientModule {
    pub(crate) federation_id: FederationId,
    pub(crate) cfg: MintClientConfig,
    pub(crate) root_secret: DerivableSecret,
    pub(crate) notifier: ModuleNotifier<MintClientStateMachines>,
    pub(crate) client_ctx: ClientContext<Self>,
    pub(crate) balance_update_sender: Sender<()>,
    pub(crate) tweak_receiver: Receiver<[u8; 16]>,
}

Fields

federation_id: FederationId

cfg: MintClientConfig

root_secret: DerivableSecret

notifier: ModuleNotifier<MintClientStateMachines>

client_ctx: ClientContext<Self>

balance_update_sender: Sender<()>

tweak_receiver: Receiver<[u8; 16]>

Implementations

impl MintClientModule

pub(crate) async fn select_funding_input( &self, dbtx: &mut DatabaseTransaction<'_>, excess_output: Amount, ) -> Option<Vec<SpendableNote>>

pub(crate) async fn rebalance( &self, dbtx: &mut DatabaseTransaction<'_>, fee: &FeeConsensus, excess_input: Amount, ) -> (Vec<SpendableNote>, Vec<Denomination>)

pub(crate) fn create_input_bundle( operation_id: OperationId, notes: Vec<SpendableNote>, include_receive_sm: bool, amount_unit: AmountUnit, ) -> ClientInputBundle<MintInput, MintClientStateMachines>

pub(crate) async fn create_output_bundle( &self, operation_id: OperationId, requested_denominations: Vec<Denomination>, ) -> ClientOutputBundle<MintOutput, MintClientStateMachines>

Build the blinded outputs and their output state machines for a reissue transaction.

Cancel safety

Cancel safe: this only reads pre-ground blinding tweaks from an in-memory channel and constructs values, it performs no database writes. Dropping the future merely discards the tweaks it had taken, which are random (so nothing is lost) and replenished by the background grinder task.

pub(crate) async fn await_output_sm_success( &self, operation_id: OperationId, outpoint: OutPoint, ) -> Result<()>

Wait for the output state machine of the given outpoint to reach a terminal state.

Cancel safety

Cancel safe: this only subscribes to the operation’s state notifications and waits, it performs no database writes. Dropping the future stops the wait; the underlying state machine keeps running in the executor.

pub async fn get_count_by_denomination(&self) -> BTreeMap<Denomination, u64>

Count the ECash notes in the client’s database by denomination.

pub(crate) async fn get_count_by_denomination_dbtx( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> BTreeMap<Denomination, u64>

pub async fn send( &self, amount: Amount, custom_meta: Value, include_invite: bool, ) -> Result<(OperationId, ECash), SendECashError>

Send ECash for the given amount and return the send operation ID. The amount will be rounded up to a multiple of 512 msats which is the smallest denomination used throughout the client. If the rounded amount cannot be covered with the ecash notes in the client’s database the client will create a transaction to reissue the required denominations. To cancel a successful ecash send simply receive it yourself.

If include_invite is set, the federation’s invite code is embedded in the returned ecash so a recipient that has not joined the federation can do so directly from the received ecash.

Cancel safety

This method is cancel safe. Every database mutation it makes happens inside a single autocommit transaction (spending the notes for the fast path, and creating the change-making reissue transaction otherwise), so dropping the future either commits a unit of work in full or leaves the database untouched: notes are never removed without a persisted operation that produces the ecash or returns the change. Federation submission is driven by a state machine in the executor rather than awaited here, so a cancelled call cannot abort an in-flight reissue; if change-making had already been submitted it completes on its own and the notes return to the balance.

pub(crate) async fn send_ecash_dbtx( &self, dbtx: &mut DatabaseTransaction<'_>, remaining_amount: Amount, custom_meta: Value, include_invite: bool, ) -> Result<Option<(OperationId, ECash)>, Infallible>

Fast path for Self::send: if exact change is already held, spend those notes and record the send operation. Returns None when exact change is not available, leaving the caller to make change.

Cancel safety

All writes go to the passed dbtx, so this inherits the cancel safety of that transaction: it must be run inside an autocommit (as send does) for the note spend and the operation log entry to commit or roll back together.

pub async fn receive( &self, ecash: ECash, custom_meta: Value, ) -> Result<OperationId, ReceiveECashError>

Receive the ECash by reissuing the notes and return the operation ID.

pub async fn receive_fee_quote(&self, ecash: &ECash) -> Result<FeeQuote>

Computes the exact fee a receive(ecash) would incur given the client’s current note inventory, without submitting anything.

This runs the same change generation the real receive does (create_final_inputs_and_outputs, including funding selection and rebalancing) against a non-committable transaction that is dropped rather than committed, so the client’s notes are read but left untouched. The quote is point-in-time: it depends on the current inventory and can move as notes change.

pub async fn send_fee_quote(&self, amount: Amount) -> Result<FeeQuote>

Computes the fee a send(amount) would incur given the client’s current note inventory, without sending anything.

A send is free when the client’s existing notes can cover the (rounded) amount exactly — it just hands those notes out. Otherwise the send first reissues itself the right denominations, and that self-reissue transaction is the only thing a send ever pays a fee for. This quote mirrors that: it returns FeeQuote::ZERO when exact change is available, and otherwise quotes the reissue the same way the real send submits it (explicit outputs represent_amount(amount), no explicit inputs) via the shared, module-agnostic fee quote over the real inventory. The quote is point-in-time: it depends on the current inventory and can move as notes change.

pub(crate) async fn can_make_exact_change( &self, remaining_amount: Amount, ) -> bool

Returns whether the client’s current notes can be handed out to cover amount exactly — the free path in Self::send — without modifying the inventory. Shares its greedy selection with Self::send_ecash_dbtx via Self::select_exact_change.

pub(crate) async fn select_exact_change( dbtx: &mut DatabaseTransaction<'_>, remaining_amount: Amount, ) -> Option<Vec<SpendableNote>>

Greedily selects spendable notes (largest-first) summing to exactly remaining_amount, or None if the inventory can’t make exact change. Reads the DB but does not modify it. Single source of truth for the free (hand-out-existing-notes) selection shared by Self::send_ecash_dbtx and Self::can_make_exact_change.

pub async fn await_final_receive_operation_state( &self, operation_id: OperationId, ) -> Result<FinalReceiveOperationState>

Await the final state of the receive operation.

pub(crate) async fn remove_spendable_note( &self, dbtx: &mut DatabaseTransaction<'_>, spendable_note: &SpendableNote, )

Trait Implementations

impl ClientModule for MintClientModule

type Init = MintClientInit

type Common = MintModuleTypes

Common module types shared between client and server

type Backup = NoModuleBackup

Data stored in regular backups so that restoring doesn’t have to start from epoch 0

type ModuleStateMachineContext = MintClientContext

Data and API clients available to state machine transitions of this module

type States = MintClientStateMachines

All possible states this client can submit to the executor

fn context(&self) -> Self::ModuleStateMachineContext

fn input_fee( &self, amounts: &Amounts, _input: &<Self::Common as ModuleCommon>::Input, ) -> Option<Amounts>

Returns the fee the processing of this input requires.

fn output_fee( &self, amounts: &Amounts, _output: &<Self::Common as ModuleCommon>::Output, ) -> Option<Amounts>

Returns the fee the processing of this output requires.

fn handle_cli_command<'life0, 'life1, 'async_trait>( &'life0 self, args: &'life1 [OsString], ) -> Pin<Box<dyn Future<Output = Result<Value>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn supports_being_primary(&self) -> PrimaryModuleSupport

Does this module support being a primary module

fn create_final_inputs_and_outputs<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, operation_id: OperationId, unit: AmountUnit, input_amount: Amount, output_amount: Amount, ) -> Pin<Box<dyn Future<Output = Result<(ClientInputBundle<MintInput, MintClientStateMachines>, ClientOutputBundle<MintOutput, MintClientStateMachines>)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Creates all inputs and outputs necessary to balance the transaction. The function returns an error if and only if the client’s funds are not sufficient to create the inputs necessary to fully fund the transaction.

fn await_primary_module_output<'life0, 'async_trait>( &'life0 self, operation_id: OperationId, outpoint: OutPoint, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Waits for the funds from an output created by Self::create_final_inputs_and_outputs to become available. This function returning typically implies a change in the output of Self::get_balance.

fn get_balance<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, unit: AmountUnit, ) -> Pin<Box<dyn Future<Output = Amount> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Returns the balance held by this module and available for funding transactions.

fn subscribe_balance_changes<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = BoxStream<'static, ()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a stream that will output the updated module balance each time it changes.

fn decoder() -> Decoder

fn kind() -> ModuleKind

fn start<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Initialize client.

fn handle_rpc<'life0, 'async_trait>( &'life0 self, _method: String, _request: Value, ) -> Pin<Box<dyn Future<Output = Pin<Box<dyn Stream<Item = Result<Value, Error>> + Send + 'life0>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

fn supports_backup(&self) -> bool

fn backup<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Self::Backup, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

fn get_balances<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _dbtx: &'life1 mut DatabaseTransaction<'life2>, ) -> Pin<Box<dyn Future<Output = Amounts> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

Returns the balance held by this module and available for funding transactions.

fn leave<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _dbtx: &'life1 mut DatabaseTransaction<'life2>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

Leave the federation

impl Debug for MintClientModule

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

Formats the value using the given formatter.