Struct bdk::wallet::Wallet

source ·
pub struct Wallet<D = ()> { /* private fields */ }
Expand description

A Bitcoin wallet

The Wallet struct acts as a way of coherently interfacing with output descriptors and related transactions. Its main components are:

  1. output descriptors from which it can derive addresses.
  2. signers that can contribute signatures to addresses instantiated from the descriptors.

Implementations§

Creates a wallet that does not persist data.

Create a wallet from a descriptor (and an optional change_descriptor) and load related transaction data from db.

Get the Bitcoin network the wallet is using.

Iterator over all keychains in this wallet

Return a derived address using the external descriptor, see AddressIndex for available address index selection strategies. If none of the keys in the descriptor are derivable (i.e. does not end with /*) then the same address will always be returned for any AddressIndex.

Return a derived address using the internal (change) descriptor.

If the wallet doesn’t have an internal descriptor it will use the external descriptor.

see AddressIndex for available address index selection strategies. If none of the keys in the descriptor are derivable (i.e. does not end with /*) then the same address will always be returned for any AddressIndex.

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

Finds how the wallet derived the script pubkey spk.

Will only return Some(_) if the wallet has given out the spk.

Return the list of unspent outputs of this wallet

Get all the checkpoints the wallet is currently storing indexed by height.

Returns the latest checkpoint.

Returns a iterators of all the script pubkeys for the Internal and Externalvariants inKeychainKind`.

This is inteded to be used when doing a full scan of your addresses (e.g. after restoring from seed words). You pass the BTreeMap of iterators to a blockchain data source (e.g. electrum server) which will go through each address until it reaches a stop grap.

Note carefully that iterators go over all script pubkeys on the keychains (not what script pubkeys the wallet is storing internally).

Gets an iterator over all the script pubkeys in a single keychain.

See spks_of_all_keychains for more documentation

Returns the utxo owned by this wallet corresponding to outpoint if it exists in the wallet’s database.

Return a single transactions made and received by the wallet

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

Add a new checkpoint to the wallet’s internal view of the chain. This stages but does not commit the change.

Returns whether anything changed with the insertion (e.g. false if checkpoint was already there).

Add a transaction to the wallet’s internal view of the chain. This stages but does not commit the change.

There are a number reasons tx could be rejected with an Err(_). The most important one is that the transaction is at a height that is greater than latest_checkpoint. Therefore you should use insert_checkpoint to insert new checkpoints before manually inserting new transactions.

Returns whether anything changed with the transaction insertion (e.g. false if the transaction was already inserted at the same position).

👎Deprecated: use Wallet::transactions instead

Deprecated. use Wallet::transactions instead.

Iterate over the transactions in the wallet in order of ascending confirmation time with unconfirmed transactions last.

Return the balance, separated into available, trusted-pending, untrusted-pending and immature values.

Add an external signer

See the signer module for an example.

Get the signers

Example
let wallet = Wallet::new_no_persist("wpkh(tprv8ZgxMBicQKsPe73PBRSmNbTfbcsZnwWhz5eVmhHpi31HW29Z7mc9B4cWGRQzopNUzZUT391DeDJxL2PefNunWyLgqCKRMDkU1s2s8bAfoSk/84'/0'/0'/0/*)", None, Network::Testnet)?;
for secret_key in wallet.get_signers(KeychainKind::External).signers().iter().filter_map(|s| s.descriptor_secret_key()) {
    // secret_key: tprv8ZgxMBicQKsPe73PBRSmNbTfbcsZnwWhz5eVmhHpi31HW29Z7mc9B4cWGRQzopNUzZUT391DeDJxL2PefNunWyLgqCKRMDkU1s2s8bAfoSk/84'/0'/0'/0/*
    println!("secret_key: {}", secret_key);
}

Ok::<(), Box<dyn std::error::Error>>(())

Start building a transaction.

This returns a blank TxBuilder from which you can specify the parameters for the transaction.

Example
let (psbt, details) = {
   let mut builder =  wallet.build_tx();
   builder
       .add_recipient(to_address.script_pubkey(), 50_000);
   builder.finish()?
};

// sign and broadcast ...

Bump the fee of a transaction previously created with this wallet.

Returns an error if the transaction is already confirmed or doesn’t explicitly signal replace by fee (RBF). If the transaction can be fee bumped then it returns a TxBuilder pre-populated with the inputs and outputs of the original transaction.

Example
let (mut psbt, _) = {
    let mut builder = wallet.build_tx();
    builder
        .add_recipient(to_address.script_pubkey(), 50_000)
        .enable_rbf();
    builder.finish()?
};
let _ = wallet.sign(&mut psbt, SignOptions::default())?;
let tx = psbt.extract_tx();
// broadcast tx but it's taking too long to confirm so we want to bump the fee
let (mut psbt, _) =  {
    let mut builder = wallet.build_fee_bump(tx.txid())?;
    builder
        .fee_rate(FeeRate::from_sat_per_vb(5.0));
    builder.finish()?
};

let _ = wallet.sign(&mut psbt, SignOptions::default())?;
let fee_bumped_tx = psbt.extract_tx();
// broadcast fee_bumped_tx to replace original

Sign a transaction with all the wallet’s signers, in the order specified by every signer’s SignerOrdering. This function returns the Result type with an encapsulated bool that has the value true if the PSBT was finalized, or false otherwise.

The SignOptions can be used to tweak the behavior of the software signers, and the way the transaction is finalized at the end. Note that it can’t be guaranteed that every signers will follow the options, but the “software signers” (WIF keys and xprv) defined in this library will.

Example
let (mut psbt, _) = {
    let mut builder = wallet.build_tx();
    builder.add_recipient(to_address.script_pubkey(), 50_000);
    builder.finish()?
};
let  finalized = wallet.sign(&mut psbt, SignOptions::default())?;
assert!(finalized, "we should have signed all the inputs");

Return the spending policies for the wallet’s descriptor

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

Finalize a PSBT, i.e., for each input determine if sufficient data is available to pass validation and construct the respective scriptSig or scriptWitness. Please refer to BIP174 for further information.

Returns true if the PSBT could be finalized, and false otherwise.

The SignOptions can be used to tweak the behavior of the finalizer.

Return the secp256k1 context used for all signing operations

Returns the descriptor used to create addresses for a particular keychain.

The derivation index of this wallet. It will return None if it has not derived any addresses. Otherwise, it will return the index of the highest address it has derived.

The index of the next address that you would get if you were to ask the wallet for a new address

Informs the wallet that you no longer intend to broadcast a tx that was built from it.

This frees up the change address used when creating the tx for use in future transactions.

get the corresponding PSBT Input for a LocalUtxo

Return the checksum of the public descriptor associated to keychain

Internally calls Self::get_descriptor_for_keychain to fetch the right descriptor

Applies an update to the wallet and stages the changes (but does not commit them).

Usually you create an update by interacting with some blockchain data source and inserting transactions related to your wallet into it.

Commits all curently staged changed to the persistence backend returning and error when this fails.

Returns the changes that will be staged with the next call to commit.

Get a reference to the inner TxGraph.

Get a reference to the inner ChainGraph.

Trait Implementations§

Converts this type into a shared reference of the (usually inferred) input type.
Converts this type into a shared reference of the (usually inferred) input type.
Formats the value using the given formatter. Read more

Auto Trait Implementations§

Blanket Implementations§

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.