Struct bdk::wallet::tx_builder::TxBuilder [−][src]
A transaction builder
A TxBuilder
is created by calling build_tx
or build_fee_bump
on a wallet. After
assigning it, you set options on it until finally calling finish
to consume the builder and
generate the transaction.
Each option setting method on TxBuilder
takes and returns &mut self
so you can chain calls
as in the following example:
// chaining let (psbt1, details) = { let mut builder = wallet.build_tx(); builder .ordering(TxOrdering::Untouched) .add_recipient(addr1.script_pubkey(), 50_000) .add_recipient(addr2.script_pubkey(), 50_000); builder.finish()? }; // non-chaining let (psbt2, details) = { let mut builder = wallet.build_tx(); builder.ordering(TxOrdering::Untouched); for addr in &[addr1, addr2] { builder.add_recipient(addr.script_pubkey(), 50_000); } builder.finish()? }; assert_eq!(psbt1.global.unsigned_tx.output[..2], psbt2.global.unsigned_tx.output[..2]);
At the moment coin_selection
is an exception to the rule as it consumes self
.
This means it is usually best to call coin_selection
on the return value of build_tx
before assigning it.
For further examples see this module’s documentation;
Implementations
impl<'a, B, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>, Ctx: TxBuilderContext> TxBuilder<'a, B, D, Cs, Ctx>
[src]
pub fn fee_rate(&mut self, fee_rate: FeeRate) -> &mut Self
[src]
Set a custom fee rate
pub fn fee_absolute(&mut self, fee_amount: u64) -> &mut Self
[src]
Set an absolute fee
pub fn policy_path(
&mut self,
policy_path: BTreeMap<String, Vec<usize>>,
keychain: KeychainKind
) -> &mut Self
[src]
&mut self,
policy_path: BTreeMap<String, Vec<usize>>,
keychain: KeychainKind
) -> &mut Self
Set the policy path to use while creating the transaction for a given keychain.
This method accepts a map where the key is the policy node id (see
Policy::id
) and the value is the list of the indexes of
the items that are intended to be satisfied from the policy node (see
SatisfiableItem::Thresh::items
).
Example
An example of when the policy path is needed is the following descriptor:
wsh(thresh(2,pk(A),sj:and_v(v:pk(B),n:older(6)),snj:and_v(v:pk(C),after(630000))))
,
derived from the miniscript policy thresh(2,pk(A),and(pk(B),older(6)),and(pk(C),after(630000)))
.
It declares three descriptor fragments, and at the top level it uses thresh()
to
ensure that at least two of them are satisfied. The individual fragments are:
pk(A)
and(pk(B),older(6))
and(pk(C),after(630000))
When those conditions are combined in pairs, it’s clear that the transaction needs to be created differently depending on how the user intends to satisfy the policy afterwards:
- If fragments
1
and2
are used, the transaction will need to use a specificn_sequence
in order to spend anOP_CSV
branch. - If fragments
1
and3
are used, the transaction will need to use a specificlocktime
in order to spend anOP_CLTV
branch. - If fragments
2
and3
are used, the transaction will need both.
When the spending policy is represented as a tree (see
Wallet::policies
), every node
is assigned a unique identifier that can be used in the policy path to specify which of
the node’s children the user intends to satisfy: for instance, assuming the thresh()
root node of this example has an id of aabbccdd
, the policy path map would look like:
{ "aabbccdd" => [0, 1] }
where the key is the node’s id, and the value is a list of the children that should be used, in no particular order.
If a particularly complex descriptor has multiple ambiguous thresholds in its structure, multiple entries can be added to the map, one for each node that requires an explicit path.
let mut path = BTreeMap::new(); path.insert("aabbccdd".to_string(), vec![0, 1]); let builder = wallet.build_tx() .add_recipient(to_address.script_pubkey(), 50_000) .policy_path(path, KeychainKind::External);
pub fn add_utxos(&mut self, outpoints: &[OutPoint]) -> Result<&mut Self, Error>
[src]
Add the list of outpoints to the internal list of UTXOs that must be spent.
If an error occurs while adding any of the UTXOs then none of them are added and the error is returned.
These have priority over the “unspendable” utxos, meaning that if a utxo is present both in the “utxos” and the “unspendable” list, it will be spent.
pub fn add_utxo(&mut self, outpoint: OutPoint) -> Result<&mut Self, Error>
[src]
Add a utxo to the internal list of utxos that must be spent
These have priority over the “unspendable” utxos, meaning that if a utxo is present both in the “utxos” and the “unspendable” list, it will be spent.
pub fn add_foreign_utxo(
&mut self,
outpoint: OutPoint,
psbt_input: Input,
satisfaction_weight: usize
) -> Result<&mut Self, Error>
[src]
&mut self,
outpoint: OutPoint,
psbt_input: Input,
satisfaction_weight: usize
) -> Result<&mut Self, Error>
Add a foreign UTXO i.e. a UTXO not owned by this wallet.
At a minimum to add a foreign UTXO we need:
outpoint
: To add it to the raw transaction.psbt_input
: To know the value.satisfaction_weight
: To know how much weight/vbytes the input will add to the transaction for fee calculation.
There are several security concerns about adding foregin UTXOs that application
developers should consider. First, how do you know the value of the input is correct? If a
non_witness_utxo
is provided in the psbt_input
then this method implicitly verifies the
value by checking it against the transaction. If only a witness_utxo
is provided then this
method doesn’t verify the value but just takes it as a given – it is up to you to check
that whoever sent you the input_psbt
was not lying!
Secondly, you must somehow provide satisfaction_weight
of the input. Depending on your
application it may be important that this be known precisely. If not, a malicious
counterparty may fool you into putting in a value that is too low, giving the transaction a
lower than expected feerate. They could also fool you into putting a value that is too high
causing you to pay a fee that is too high. The party who is broadcasting the transaction can
of course check the real input weight matches the expected weight prior to broadcasting.
To guarantee the satisfaction_weight
is correct, you can require the party providing the
psbt_input
provide a miniscript descriptor for the input so you can check it against the
script_pubkey
and then ask it for the max_satisfaction_weight
.
This is an EXPERIMENTAL feature, API and other major changes are expected.
Errors
This method returns errors in the following circumstances:
- The
psbt_input
does not contain awitness_utxo
ornon_witness_utxo
. - The data in
non_witness_utxo
does not match what is inoutpoint
.
Note if you set force_non_witness_utxo
any psbt_input
you pass to this method must
have non_witness_utxo
set otherwise you will get an error when finish
is called.
pub fn manually_selected_only(&mut self) -> &mut Self
[src]
Only spend utxos added by add_utxo
.
The wallet will not add additional utxos to the transaction even if they are needed to make the transaction valid.
pub fn unspendable(&mut self, unspendable: Vec<OutPoint>) -> &mut Self
[src]
Replace the internal list of unspendable utxos with a new list
It’s important to note that the “must-be-spent” utxos added with TxBuilder::add_utxo
have priority over these. See the docs of the two linked methods for more details.
pub fn add_unspendable(&mut self, unspendable: OutPoint) -> &mut Self
[src]
Add a utxo to the internal list of unspendable utxos
It’s important to note that the “must-be-spent” utxos added with TxBuilder::add_utxo
have priority over this. See the docs of the two linked methods for more details.
pub fn sighash(&mut self, sighash: SigHashType) -> &mut Self
[src]
Sign with a specific sig hash
Use this option very carefully
pub fn ordering(&mut self, ordering: TxOrdering) -> &mut Self
[src]
Choose the ordering for inputs and outputs of the transaction
pub fn nlocktime(&mut self, locktime: u32) -> &mut Self
[src]
Use a specific nLockTime while creating the transaction
This can cause conflicts if the wallet’s descriptors contain an “after” (OP_CLTV) operator.
pub fn version(&mut self, version: i32) -> &mut Self
[src]
Build a transaction with a specific version
The version
should always be greater than 0
and greater than 1
if the wallet’s
descriptors contain an “older” (OP_CSV) operator.
pub fn do_not_spend_change(&mut self) -> &mut Self
[src]
Do not spend change outputs
This effectively adds all the change outputs to the “unspendable” list. See
TxBuilder::unspendable
.
pub fn only_spend_change(&mut self) -> &mut Self
[src]
Only spend change outputs
This effectively adds all the non-change outputs to the “unspendable” list. See
TxBuilder::unspendable
.
pub fn change_policy(&mut self, change_policy: ChangeSpendPolicy) -> &mut Self
[src]
Set a specific ChangeSpendPolicy
. See TxBuilder::do_not_spend_change
and
TxBuilder::only_spend_change
for some shortcuts.
pub fn force_non_witness_utxo(&mut self) -> &mut Self
[src]
Fill-in the psbt::Input::non_witness_utxo
field even if the wallet only has SegWit
descriptors.
This is useful for signers which always require it, like Trezor hardware wallets.
pub fn include_output_redeem_witness_script(&mut self) -> &mut Self
[src]
Fill-in the psbt::Output::redeem_script
and
psbt::Output::witness_script
fields.
This is useful for signers which always require it, like ColdCard hardware wallets.
pub fn add_global_xpubs(&mut self) -> &mut Self
[src]
Fill-in the PSBT_GLOBAL_XPUB
field with the extended keys contained in both the external
and internal descriptors
This is useful for offline signers that take part to a multisig. Some hardware wallets like BitBox and ColdCard are known to require this.
pub fn drain_wallet(&mut self) -> &mut Self
[src]
Spend all the available inputs. This respects filters like TxBuilder::unspendable
and the change policy.
pub fn coin_selection<P: CoinSelectionAlgorithm<D>>(
self,
coin_selection: P
) -> TxBuilder<'a, B, D, P, Ctx>
[src]
self,
coin_selection: P
) -> TxBuilder<'a, B, D, P, Ctx>
Choose the coin selection algorithm
Overrides the DefaultCoinSelectionAlgorithm
.
Note that this function consumes the builder and returns it so it is usually best to put this as the first call on the builder.
pub fn finish(self) -> Result<(PSBT, TransactionDetails), Error>
[src]
Finish the building the transaction.
Returns the BIP174
“PSBT” and summary details about the transaction.
impl<'a, B, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>> TxBuilder<'a, B, D, Cs, CreateTx>
[src]
pub fn set_recipients(&mut self, recipients: Vec<(Script, u64)>) -> &mut Self
[src]
Replace the recipients already added with a new list
pub fn add_recipient(&mut self, script_pubkey: Script, amount: u64) -> &mut Self
[src]
Add a recipient to the internal list
pub fn set_single_recipient(&mut self, recipient: Script) -> &mut Self
[src]
Set a single recipient that will get all the selected funds minus the fee. No change will be created
This method overrides any recipient set with set_recipients
or
add_recipient
.
It can only be used in conjunction with drain_wallet
to send the
entire content of the wallet (minus filters) to a single recipient or with a
list of manually selected UTXOs by enabling manually_selected_only
and selecting them with or add_utxo
.
When bumping the fees of a transaction made with this option, the user should remeber to
add maintain_single_recipient
to correctly update the
single output instead of adding one more for the change.
pub fn enable_rbf(&mut self) -> &mut Self
[src]
Enable signaling RBF
This will use the default nSequence value of 0xFFFFFFFD
.
pub fn enable_rbf_with_sequence(&mut self, nsequence: u32) -> &mut Self
[src]
Enable signaling RBF with a specific nSequence value
This can cause conflicts if the wallet’s descriptors contain an “older” (OP_CSV) operator
and the given nsequence
is lower than the CSV value.
If the nsequence
is higher than 0xFFFFFFFD
an error will be thrown, since it would not
be a valid nSequence to signal RBF.
impl<'a, B, D: BatchDatabase> TxBuilder<'a, B, D, DefaultCoinSelectionAlgorithm, BumpFee>
[src]
pub fn maintain_single_recipient(&mut self) -> Result<&mut Self, Error>
[src]
Bump the fees of a transaction made with set_single_recipient
Unless extra inputs are specified with add_utxo
, this flag will make
bump_fee
reduce the value of the existing output, or fail if it would be consumed
entirely given the higher new fee rate.
If extra inputs are added and they are not entirely consumed in fees, a change output will not be added; the existing output will simply grow in value.
Fails if the transaction has more than one outputs.
Trait Implementations
impl<'a, Cs: Clone, Ctx, B, D> Clone for TxBuilder<'a, B, D, Cs, Ctx>
[src]
fn clone(&self) -> Self
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<'a, B: Debug, D: Debug, Cs: Debug, Ctx: Debug> Debug for TxBuilder<'a, B, D, Cs, Ctx>
[src]
Auto Trait Implementations
impl<'a, B, D, Cs, Ctx> !RefUnwindSafe for TxBuilder<'a, B, D, Cs, Ctx>
impl<'a, B, D, Cs, Ctx> !Send for TxBuilder<'a, B, D, Cs, Ctx>
impl<'a, B, D, Cs, Ctx> !Sync for TxBuilder<'a, B, D, Cs, Ctx>
impl<'a, B, D, Cs, Ctx> Unpin for TxBuilder<'a, B, D, Cs, Ctx> where
Cs: Unpin,
Ctx: Unpin,
Cs: Unpin,
Ctx: Unpin,
impl<'a, B, D, Cs, Ctx> !UnwindSafe for TxBuilder<'a, B, D, Cs, Ctx>
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T> Instrument for T
[src]
pub fn instrument(self, span: Span) -> Instrumented<Self>
[src]
pub fn in_current_span(self) -> Instrumented<Self>
[src]
impl<T> Instrument for T
[src]
pub fn instrument(self, span: Span) -> Instrumented<Self>
[src]
pub fn in_current_span(self) -> Instrumented<Self>
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Pointable for T
pub const ALIGN: usize
type Init = T
The type for initializers.
pub unsafe fn init(init: <T as Pointable>::Init) -> usize
pub unsafe fn deref<'a>(ptr: usize) -> &'a T
pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
pub unsafe fn drop(ptr: usize)
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,