Struct Wallet

pub struct Wallet {
    pub(crate) cfg: WalletConfig,
    pub(crate) secp: Secp256k1<All>,
    pub(crate) btc_rpc: DynBitcoindRpc,
    pub(crate) our_peer_id: PeerId,
    pub(crate) block_count_rx: Receiver<Option<u32>>,
    pub(crate) fee_rate_rx: Receiver<Feerate>,
    pub(crate) task_group: TaskGroup,
}

Fields

cfg: WalletConfig

secp: Secp256k1<All>

btc_rpc: DynBitcoindRpc

our_peer_id: PeerId

block_count_rx: Receiver<Option<u32>>

Block count updated periodically by a background task

fee_rate_rx: Receiver<Feerate>

Fee rate updated periodically by a background task

task_group: TaskGroup

Implementations

impl Wallet

pub async fn new( cfg: WalletConfig, db: &Database, task_group: &TaskGroup, our_peer_id: PeerId, ) -> Result<Wallet>

pub async fn new_with_bitcoind( cfg: WalletConfig, db: &Database, bitcoind: DynBitcoindRpc, task_group: &TaskGroup, our_peer_id: PeerId, ) -> Result<Wallet, WalletCreationError>

pub(crate) fn sign_peg_out_psbt( &self, psbt: &mut Psbt, peer: PeerId, signature: &PegOutSignatureItem, ) -> Result<(), ProcessPegOutSigError>

Try to attach signatures to a pending peg-out tx.

pub(crate) fn finalize_peg_out_psbt( &self, unsigned: UnsignedTransaction, ) -> Result<PendingTransaction, ProcessPegOutSigError>

pub(crate) fn get_block_count(&self) -> Result<u32>

pub fn get_fee_rate_opt(&self) -> Feerate

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

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

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

pub async fn consensus_nonce( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> [u8; 33]

pub(crate) async fn sync_up_to_consensus_count<'a>( &self, dbtx: &mut DatabaseTransaction<'a>, old_count: u32, new_count: u32, )

pub(crate) async fn recognize_change_utxo<'a>( &self, dbtx: &mut DatabaseTransaction<'a>, pending_tx: &PendingTransaction, )

Add a change UTXO to our spendable UTXO database after it was included in a block that we got consensus on.

pub(crate) async fn remove_rbf_transactions<'a>( &self, dbtx: &mut DatabaseTransaction<'a>, pending_tx: &PendingTransaction, )

Removes the PendingTransaction and any transactions tied to it via RBF

pub(crate) async fn block_is_known( &self, dbtx: &mut DatabaseTransaction<'_>, block_hash: BlockHash, ) -> bool

pub(crate) async fn create_peg_out_tx( &self, dbtx: &mut DatabaseTransaction<'_>, output: &WalletOutputV0, change_tweak: &[u8; 33], ) -> Result<UnsignedTransaction, WalletOutputError>

pub(crate) async fn available_utxos( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> Vec<(UTXOKey, SpendableUTXO)>

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

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

pub(crate) fn offline_wallet(&self) -> StatelessWallet<'_>

pub(crate) fn spawn_broadcast_pending_task( task_group: &TaskGroup, bitcoind: &DynBitcoindRpc, db: &Database, )

pub(crate) fn spawn_bitcoin_update_task( cfg: &WalletConfig, task_group: &TaskGroup, bitcoind: &DynBitcoindRpc, ) -> Result<(Receiver<Option<u32>>, Receiver<Feerate>)>

pub(crate) async fn graceful_shutdown(&self)

Shutdown the task group shared throughout fedimintd, giving 60 seconds for other services to gracefully shutdown.

pub(crate) async fn wait_for_finality_confs_or_shutdown( &self, consensus_block_count: u32, )

Returns once our bitcoin backend observes finality delay confirmations of the consensus block count. If we don’t observe enough confirmations after one hour, we gracefully shutdown fedimintd. This is necessary since we can no longer participate in consensus if our bitcoin backend is unable to observe the same chain tip as our peers.

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, ) -> 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, out_point: OutPoint, ) -> Pin<Box<dyn Future<Output = Result<TransactionItemAmount, 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>, out_point: OutPoint, ) -> Pin<Box<dyn Future<Output = Option<WalletOutputOutcome>> + Send + 'async_trait>>

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

Retrieve the current status of the output. Depending on the module this might contain data needed by the client to access funds or give an estimate of when funds will be available. Returns None if the output is unknown, NOT if it is just not ready yet.

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>