Struct WalletClientModule 

pub struct WalletClientModule {
    pub(crate) root_secret: DerivableSecret,
    pub(crate) cfg: WalletClientConfig,
    pub(crate) notifier: ModuleNotifier<WalletClientStateMachines>,
    pub(crate) client_ctx: ClientContext<Self>,
    pub(crate) db: Database,
    pub(crate) module_api: DynModuleApi,
}

Fields

root_secret: DerivableSecret

cfg: WalletClientConfig

notifier: ModuleNotifier<WalletClientStateMachines>

client_ctx: ClientContext<Self>

db: Database

module_api: DynModuleApi

Implementations

impl WalletClientModule

pub fn get_network(&self) -> Network

Returns the Bitcoin network for this federation.

pub async fn total_value(&self) -> FederationResult<Amount>

Fetch the total value of bitcoin controlled by the federation.

pub async fn block_count(&self) -> FederationResult<u64>

Fetch the consensus block count of the federation.

pub async fn feerate(&self) -> FederationResult<Option<u64>>

Fetch the current consensus feerate.

pub async fn pending_tx_chain(&self) -> FederationResult<Vec<TxInfo>>

Fetch information on the chain of pending bitcoin transactions.

pub async fn tx_chain(&self) -> FederationResult<Vec<TxInfo>>

Display log of bitcoin transactions.

pub async fn send_fee(&self) -> Result<Amount, SendError>

Fetch the current fee required to send an onchain payment.

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

Computes the federation fee an onchain send of an output worth amount (the payment amount plus the on-chain miner fee) would incur, without submitting anything.

A send submits a single wallet output worth amount; the primary module balances it by spending ecash to fund the output and minting any change. This quotes the fee of that transaction — the wallet output fee, the mint input fees on the funding notes, any mint change output fees, and sub-denomination dust — via the shared, module-agnostic fee quote.

The on-chain Bitcoin miner fee is deliberately excluded: it is part of the output amount (see Self::send_fee), not the on-federation transaction fee.

pub async fn receive_fee(&self) -> Result<Amount, ReceiveError>

Fetch the current fee required to claim an onchain deposit (peg-in).

pub async fn send( &self, address: Address<NetworkUnchecked>, value: Amount, fee: Option<Amount>, custom_meta: Value, ) -> Result<OperationId, SendError>

Send an onchain payment with the given fee.

pub async fn await_final_send_operation_state( &self, operation_id: OperationId, ) -> Result<FinalSendOperationState>

Await the final state of the send operation.

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 valid_index(&self) -> Option<u64>

Returns the highest valid receive address index that the background scanner has derived so far, or None if it has not derived one yet.

pub async fn receive(&self) -> Address

Returns the next unused receive address.

To wait for a payment to this address race-free, read the client’s current event log position (via the global get_next_event_log_id) before calling this, then pass that position to Self::await_receive; it will only consider payments received after that position.

If the background scanner has already derived a valid address index this returns immediately. Otherwise it blocks, letting the scanner grind until it finds the next valid index, and returns once one is available.

pub async fn await_receive( &self, position: EventLogId, ) -> Result<(FinalReceiveOperationState, EventLogId)>

Block until the next on-chain payment recorded at or after position is received and successfully claimed by the federation.

Returns the peg-in’s final state together with the event log position just past it, so that a subsequent call can resume from there to wait for the following receive.

A peg-in attempt may be aborted (rejected by the federation), in which case the still-unspent output is reprocessed into a new receive operation; this keeps waiting until one succeeds.

pub(crate) async fn next_receive_operation( &self, position: EventLogId, ) -> (OperationId, EventLogId)

Scan the event log from position for the next ReceivePaymentEvent, blocking until one is found, and return its operation id together with the event log position just past it.

pub(crate) fn derive_address(&self, index: u64) -> Address

pub(crate) fn derive_tweak(&self, index: u64) -> Keypair

pub(crate) async fn next_valid_index( &self, start_index: u64, handle: &TaskHandle, ) -> Option<u64>

Find the next valid index starting from (and including) start_index.

Only ~1/65536 indices are valid, so the search is CPU-bound and may scan many indices before finding one. The scan runs in bounded batches and yields to the executor between them, so it does not stall the runtime — important on wasm, which is single-threaded. It stops and returns None once the task group begins shutting down.

pub(crate) async fn receive_output( &self, output_index: u64, value: Amount, address_index: u64, fee: Amount, outpoint: Option<OutPoint>, ) -> (OperationId, TransactionId)

Issue ecash for an unspent output with a given fee.

pub(crate) fn spawn_output_scanner( &self, task_group: &TaskGroup, client_span: &Span, )

pub(crate) async fn check_outputs(&self, handle: &TaskHandle) -> Result<bool>

pub(crate) async fn process_unspent_output( &self, output: &OutputInfo, address_index: u64, ) -> Result<bool>

Trait Implementations

impl ClientModule for WalletClientModule

type Init = WalletClientInit

type Common = WalletModuleTypes

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 = WalletClientContext

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

type States = WalletClientStateMachines

All possible states this client can submit to the executor

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

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

Returns the fee the processing of this input requires.

fn output_fee( &self, amount: &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 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 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<<Self::Common as ModuleCommon>::Input, Self::States>, ClientOutputBundle<<Self::Common as ModuleCommon>::Output, Self::States>), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + '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, _out_point: OutPoint, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + '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 '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 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 subscribe_balance_changes<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Pin<Box<dyn Stream<Item = ()> + Send>>> + Send + 'async_trait>>

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

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

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 Clone for WalletClientModule

fn clone(&self) -> WalletClientModule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WalletClientModule

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

Formats the value using the given formatter.