Struct Wallet 

pub struct Wallet {
    pub(crate) cfg: WalletConfig,
    pub(crate) db: Database,
    pub(crate) btc_rpc: ServerBitcoinRpcMonitor,
}

Fields

cfg: WalletConfig

db: Database

btc_rpc: ServerBitcoinRpcMonitor

Implementations

impl Wallet

pub(crate) fn new( cfg: WalletConfig, db: &Database, task_group: &TaskGroup, btc_rpc: ServerBitcoinRpcMonitor, ) -> Wallet

pub(crate) fn spawn_broadcast_unconfirmed_txs_task( btc_rpc: ServerBitcoinRpcMonitor, db: Database, task_group: &TaskGroup, )

pub(crate) async fn process_block_count( &self, dbtx: &mut DatabaseTransaction<'_>, block_count_vote: u64, peer: PeerId, ) -> Result<()>

pub(crate) async fn process_signatures( &self, dbtx: &mut DatabaseTransaction<'_>, txid: Txid, signatures: Vec<Signature>, peer: PeerId, ) -> Result<()>

pub(crate) async fn await_local_sync_to_block_count(&self, block_count: u64)

pub async fn consensus_block_count( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> u64

pub async fn consensus_feerate( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> Option<u64>

pub async fn consensus_fee( &self, dbtx: &mut DatabaseTransaction<'_>, tx_vbytes: u64, ) -> Option<Amount>

pub async fn send_fee( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> Option<Amount>

pub async fn receive_fee( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> Option<Amount>

pub(crate) fn descriptor(&self, tweak: &Hash) -> Wsh<PublicKey>

pub(crate) fn sign_tx(&self, unsigned_tx: &FederationTx) -> Vec<Signature>

pub(crate) fn verify_signatures( &self, unsigned_tx: &FederationTx, signatures: &[Signature], pk: PublicKey, ) -> Result<()>

pub(crate) fn finalize_tx( &self, federation_tx: &mut FederationTx, signatures: &BTreeMap<PeerId, Vec<Signature>>, )

pub(crate) async fn tx_id( &self, dbtx: &mut DatabaseTransaction<'_>, outpoint: OutPoint, ) -> Option<Txid>

pub(crate) async fn get_deposits( &self, dbtx: &mut DatabaseTransaction<'_>, start_index: u64, end_index: u64, ) -> DepositRange

pub(crate) async fn pending_tx_chain( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> Vec<TxInfo>

pub(crate) async fn tx_chain( &self, dbtx: &mut DatabaseTransaction<'_>, n: usize, ) -> Vec<TxInfo>

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

pub fn network_ui(&self) -> Network

Get the network for UI display

pub async fn federation_wallet_ui(&self) -> Option<FederationWallet>

Get the current federation wallet info for UI display

pub async fn consensus_block_count_ui(&self) -> u64

Get the current consensus block count for UI display

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

Get the current consensus feerate for UI display

pub async fn send_fee_ui(&self) -> Option<Amount>

Get the current send fee for UI display

pub async fn receive_fee_ui(&self) -> Option<Amount>

Get the current receive fee for UI display

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

Get the current pending transaction info for UI display

pub async fn tx_chain_ui(&self, n: usize) -> Vec<TxInfo>

Get the current transaction log for UI display

pub async fn recovery_keys_ui( &self, ) -> Option<(BTreeMap<PeerId, String>, String)>

Export recovery keys for federation shutdown. Returns None if the federation wallet has not been initialized yet.

Trait Implementations

impl Debug for Wallet

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

Formats the value using the given formatter.

impl ServerModule for Wallet

type Common = WalletModuleTypes

type Init = WalletInit

fn consensus_proposal<'a, 'life0, 'life1, 'async_trait>( &'a self, dbtx: &'life0 mut DatabaseTransaction<'life1>, ) -> Pin<Box<dyn Future<Output = Vec<WalletConsensusItem>> + Send + 'async_trait>>

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

This module’s contribution to the next consensus proposal. This method is only guaranteed to be called once every few seconds. Consensus items are not meant to be latency critical; do not create them as a response to a processed transaction. Only use consensus items to establish consensus on a value that is required to verify transactions, like unix time, block heights and feerates, and model all other state changes trough transactions. The intention for this method is to always return all available consensus items even if they are redundant while process_consensus_item returns an error for the redundant proposals.

fn process_consensus_item<'a, 'b, 'life0, 'async_trait>( &'a self, dbtx: &'life0 mut DatabaseTransaction<'b>, consensus_item: WalletConsensusItem, peer: PeerId, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'b: 'async_trait, 'life0: 'async_trait,

This function is called once for every consensus item. The function should return Ok if and only if the consensus item changes the system state. Therefore this method should return an error in case of merely redundant consensus items such that they will be purged from the history of the federation. This enables consensus_proposal to return all available consensus item without wasting disk space with redundant consensus items.

fn process_input<'a, 'b, 'c, 'life0, 'async_trait>( &'a self, dbtx: &'life0 mut DatabaseTransaction<'c>, input: &'b WalletInput, _in_point: InPoint, ) -> Pin<Box<dyn Future<Output = Result<InputMeta, WalletInputError>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'b: 'async_trait, 'c: 'async_trait, 'life0: 'async_trait,

Try to spend a transaction input. On success all necessary updates will be part of the database transaction. On failure (e.g. double spend) the database transaction is rolled back and the operation will take no effect.

fn process_output<'a, 'b, 'life0, 'async_trait>( &'a self, dbtx: &'life0 mut DatabaseTransaction<'b>, output: &'a WalletOutput, outpoint: OutPoint, ) -> Pin<Box<dyn Future<Output = Result<TransactionItemAmounts, WalletOutputError>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'b: 'async_trait, 'life0: 'async_trait,

Try to create an output (e.g. issue notes, peg-out BTC, …). On success all necessary updates to the database will be part of the database transaction. On failure (e.g. double spend) the database transaction is rolled back and the operation will take no effect.

fn output_status<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _dbtx: &'life1 mut DatabaseTransaction<'life2>, _outpoint: OutPoint, ) -> Pin<Box<dyn Future<Output = Option<WalletOutputOutcome>> + Send + 'async_trait>>

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

👎Deprecated: https://github.com/fedimint/fedimint/issues/6671

Deprecated: Modules should not be using it. Instead, they should implement their own custom endpoints with semantics, versioning, serialization, etc. that suits them. Potentially multiple or none.

fn audit<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, audit: &'life3 mut Audit, module_instance_id: ModuleInstanceId, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

Queries the database and returns all assets and liabilities of the module.

fn api_endpoints(&self) -> Vec<ApiEndpoint<Self>>

Returns a list of custom API endpoints defined by the module. These are made available both to users as well as to other modules. They thus should be deterministic, only dependant on their input and the current epoch.

fn module_kind() -> ModuleKind

fn decoder() -> Decoder

Returns a decoder for the following associated types of this module:

fn verify_input( &self, _input: &<Self::Common as ModuleCommon>::Input, ) -> Result<(), <Self::Common as ModuleCommon>::InputError>