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 receive_fee(&self) -> Result<Amount>

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 async fn receive(&self) -> Address

Returns the next unused receive address, polling until the initial address derivation has completed.

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

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

pub(crate) fn next_valid_index(&self, start_index: u64) -> u64

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

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) -> 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.