Struct bdk::wallet::Wallet

pub struct Wallet<B, D> { /* fields omitted */ }

A Bitcoin wallet

A wallet takes descriptors, a database and a blockchain and implements the basic functions that a Bitcoin wallets needs to operate, like generating addresses, returning the balance, creating transactions, etc.

A wallet can be either "online" if the blockchain type provided implements Blockchain, or "offline" if it is the unit type (). Offline wallets only expose methods that don't need any interaction with the blockchain to work.

Implementations

impl<D> Wallet<(), D> where
    D: BatchDatabase, 

pub fn new_offline<E: ToWalletDescriptor>(
    descriptor: E,
    change_descriptor: Option<E>,
    network: Network,
    database: D
) -> Result<Self, Error>

Create a new "offline" wallet

impl<B, D> Wallet<B, D> where
    D: BatchDatabase, 

pub fn get_new_address(&self) -> Result<Address, Error>

Return a newly generated address using the external descriptor

pub fn is_mine(&self, script: &Script) -> Result<bool, Error>

Return whether or not a script is part of this wallet (either internal or external)

pub fn list_unspent(&self) -> Result<Vec<UTXO>, Error>

Return the list of unspent outputs of this wallet

Note that this methods only operate on the internal database, which first needs to be Wallet::sync manually.

pub fn list_transactions(
    &self,
    include_raw: bool
) -> Result<Vec<TransactionDetails>, Error>

Return the list of transactions made and received by the wallet

Optionally fill the TransactionDetails::transaction field with the raw transaction if include_raw is true.

Note that this methods only operate on the internal database, which first needs to be Wallet::sync manually.

pub fn get_balance(&self) -> Result<u64, Error>

Return the balance, meaning the sum of this wallet's unspent outputs' values

Note that this methods only operate on the internal database, which first needs to be Wallet::sync manually.

pub fn add_signer(
    &mut self,
    keychain: KeychainKind,
    id: SignerId,
    ordering: SignerOrdering,
    signer: Arc<dyn Signer>
)

Add an external signer

See the signer module for an example.

pub fn add_address_validator(&mut self, validator: Arc<dyn AddressValidator>)

Add an address validator

See the address_validator module for an example.

pub fn create_tx<Cs: CoinSelectionAlgorithm<D>>(
    &self,
    builder: TxBuilder<D, Cs, CreateTx>
) -> Result<(PSBT, TransactionDetails), Error>

Create a new transaction following the options specified in the builder

Example

let (psbt, details) = wallet.create_tx(
    TxBuilder::with_recipients(vec![(to_address.script_pubkey(), 50_000)])
)?;
// sign and broadcast ...

pub fn bump_fee<Cs: CoinSelectionAlgorithm<D>>(
    &self,
    txid: &Txid,
    builder: TxBuilder<D, Cs, BumpFee>
) -> Result<(PSBT, TransactionDetails), Error>

Bump the fee of a transaction following the options specified in the builder

Return an error if the transaction is already confirmed or doesn't explicitly signal RBF.

NOTE: if the original transaction was made with TxBuilder::set_single_recipient, the TxBuilder::maintain_single_recipient flag should be enabled to correctly reduce the only output's value in order to increase the fees.

If the builder specifies some utxos that must be spent, they will be added to the transaction regardless of whether they are necessary or not to cover additional fees.

Example

let txid = Txid::from_str("faff0a466b70f5d5f92bd757a92c1371d4838bdd5bc53a06764e2488e51ce8f8").unwrap();
let (psbt, details) = wallet.bump_fee(
    &txid,
    TxBuilder::new().fee_rate(FeeRate::from_sat_per_vb(5.0)),
)?;
// sign and broadcast ...

pub fn sign(
    &self,
    mut psbt: PSBT,
    assume_height: Option<u32>
) -> Result<(PSBT, bool), Error>

Sign a transaction with all the wallet's signers, in the order specified by every signer's SignerOrdering

Example

let (signed_psbt, finalized) = wallet.sign(psbt, None)?;

pub fn policies(&self, keychain: KeychainKind) -> Result<Option<Policy>, Error>

Return the spending policies for the wallet's descriptor

pub fn public_descriptor(
    &self,
    keychain: KeychainKind
) -> Result<Option<ExtendedDescriptor>, Error>

Return the "public" version of the wallet's descriptor, meaning a new descriptor that has the same structure but with every secret key removed

This can be used to build a watch-only version of a wallet

pub fn finalize_psbt(
    &self,
    mut psbt: PSBT,
    assume_height: Option<u32>
) -> Result<(PSBT, bool), Error>

Try to finalize a PSBT

pub fn secp_ctx(&self) -> &Secp256k1<All>

Return the secp256k1 context used for all signing operations

impl<B, D> Wallet<B, D> where
    B: Blockchain,
    D: BatchDatabase, 

pub fn new<E: ToWalletDescriptor>(
    descriptor: E,
    change_descriptor: Option<E>,
    network: Network,
    database: D,
    client: B
) -> Result<Self, Error>

Create a new "online" wallet

pub fn sync<P: 'static + Progress>(
    &self,
    progress_update: P,
    max_address_param: Option<u32>
) -> Result<(), Error>

Sync the internal database with the blockchain

pub fn client(&self) -> &B

Return a reference to the internal blockchain client

pub fn network(&self) -> Network

Get the Bitcoin network the wallet is using.

pub fn broadcast(&self, tx: Transaction) -> Result<Txid, Error>

Broadcast a transaction to the network