logo
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. A Database where it tracks transactions and utxos related to the descriptors.
  3. signers that can contribute signatures to addresses instantiated from the descriptors.

Implementations

👎 Deprecated:

Just use Wallet::new – all wallets are offline now!

Create a new “offline” wallet

Create a wallet.

The only way this can fail is if the descriptors passed in do not match the checksums in database.

Get the Bitcoin network the wallet is using.

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.

Ensures that there are at least max_addresses addresses cached in the database if the descriptor is derivable, or 1 address if it is not. Will return Ok(true) if there are new addresses generated (either external or internal), and Ok(false) if all the required addresses are already cached. This function is useful to explicitly cache addresses in a wallet to do things like check Wallet::is_mine on transaction output scripts.

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

Return the list of unspent outputs of this wallet

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

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.

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

Return an unsorted list of transactions made and received by the wallet

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

To sort transactions, the following code can be used:

tx_list.sort_by(|a, b| {
    b.confirmation_time
        .as_ref()
        .map(|t| t.height)
        .cmp(&a.confirmation_time.as_ref().map(|t| t.height))
});

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

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

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

Add an external signer

See the signer module for an example.

Get the signers

Example
let wallet = Wallet::new("wpkh(tprv8ZgxMBicQKsPe73PBRSmNbTfbcsZnwWhz5eVmhHpi31HW29Z7mc9B4cWGRQzopNUzZUT391DeDJxL2PefNunWyLgqCKRMDkU1s2s8bAfoSk/84'/0'/0'/0/*)", None, Network::Testnet, MemoryDatabase::new())?;
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>>(())
👎 Deprecated

Add an address validator

See the address_validator module for an example.

👎 Deprecated

Get the address validators

See the address_validator module.

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

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.

get the corresponding PSBT Input for a LocalUtxo

Return an immutable reference to the internal database

Sync the internal database with the blockchain

Return the checksum of the public descriptor associated to keychain

Internally calls Self::get_descriptor_for_keychain to fetch the right descriptor

Trait Implementations

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

Performs the conversion.

Performs the conversion.

The alignment of pointer.

The type for initializers.

Initializes a with the given initializer. Read more

Dereferences the given pointer. Read more

Mutably dereferences the given pointer. Read more

Drops the object pointed to by the given pointer. Read more

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.