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>

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

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<ECash, SendECashError>

Send ECash for the given amount. 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. It is safe to cancel the send method call before the reissue is complete in which case the reissued notes are returned to the regular balance. 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.

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

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

Receive the ECash by reissuing the notes and return the total amount of the ecash reissued. This method is idempotent.

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.