Sequence, Transaction, TxIn, TxOut, Txid, Weight,
};
use rand::rngs::StdRng;
-use rand::{thread_rng, SeedableRng};
+use rand::SeedableRng;
mod common;
use common::*;
#[should_panic(expected = "NoRecipients")]
fn test_create_tx_empty_recipients() {
let (mut wallet, _) = get_funded_wallet_wpkh();
- wallet
- .build_tx()
- .finish_with_aux_rand(&mut thread_rng())
- .unwrap();
+ wallet.build_tx().finish().unwrap();
}
#[test]
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.manually_selected_only();
- builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ builder.finish().unwrap();
}
#[test]
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.version(0);
- assert!(matches!(
- builder.finish_with_aux_rand(&mut thread_rng()),
- Err(CreateTxError::Version0)
- ));
+ assert!(matches!(builder.finish(), Err(CreateTxError::Version0)));
}
#[test]
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.version(1);
- assert!(matches!(
- builder.finish_with_aux_rand(&mut thread_rng()),
- Err(CreateTxError::Version1Csv)
- ));
+ assert!(matches!(builder.finish(), Err(CreateTxError::Version1Csv)));
}
#[test]
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.version(42);
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(psbt.unsigned_tx.version.0, 42);
}
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
// Since we never synced the wallet we don't have a last_sync_height
// we could use to try to prevent fee sniping. We default to 0.
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
// If there's no current_height we're left with using the last sync height
assert_eq!(
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(psbt.unsigned_tx.lock_time.to_consensus_u32(), 100_000);
}
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.current_height(630_001)
.nlocktime(absolute::LockTime::from_height(630_000).unwrap());
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
// When we explicitly specify a nlocktime
// we don't try any fee sniping prevention trick
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.nlocktime(absolute::LockTime::from_height(630_000).unwrap());
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(psbt.unsigned_tx.lock_time.to_consensus_u32(), 630_000);
}
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.nlocktime(absolute::LockTime::from_height(50000).unwrap());
- assert!(matches!(builder.finish_with_aux_rand(&mut thread_rng()),
+ assert!(matches!(builder.finish(),
Err(CreateTxError::LockTime { requested, required })
if requested.to_consensus_u32() == 50_000 && required.to_consensus_u32() == 100_000));
}
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(6));
}
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
// When CSV is enabled it takes precedence over the rbf value (unless forced by the user).
// It will be set to the OP_CSV value, in this case 6
assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(6));
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.enable_rbf_with_sequence(Sequence(3));
- assert!(matches!(builder.finish_with_aux_rand(&mut thread_rng()),
+ assert!(matches!(builder.finish(),
Err(CreateTxError::RbfSequenceCsv { rbf, csv })
if rbf.to_consensus_u32() == 3 && csv.to_consensus_u32() == 6));
}
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(0xFFFFFFFE));
}
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.enable_rbf_with_sequence(Sequence(0xFFFFFFFE));
- assert!(matches!(
- builder.finish_with_aux_rand(&mut thread_rng()),
- Err(CreateTxError::RbfSequence)
- ));
+ assert!(matches!(builder.finish(), Err(CreateTxError::RbfSequence)));
}
#[test]
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.enable_rbf_with_sequence(Sequence(0xDEADBEEF));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(0xDEADBEEF));
}
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.do_not_spend_change();
- assert!(builder.finish_with_aux_rand(&mut thread_rng()).is_ok());
+ assert!(builder.finish().is_ok());
// wallet has no change, so setting `only_spend_change`
// should cause tx building to fail
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.only_spend_change();
assert!(matches!(
- builder.finish_with_aux_rand(&mut thread_rng()),
+ builder.finish(),
Err(CreateTxError::CoinSelection(
coin_selection::Error::InsufficientFunds { .. }
)),
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(0xFFFFFFFE));
}
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let fee = check_fee!(wallet, psbt);
assert_eq!(psbt.unsigned_tx.output.len(), 1);
.add_recipient(addr.script_pubkey(), Amount::from_sat(20_000))
.drain_to(drain_addr.script_pubkey())
.drain_wallet();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let fee = check_fee!(wallet, psbt);
let outputs = psbt.unsigned_tx.output;
.drain_to(addr.script_pubkey())
.add_utxos(&utxos)
.unwrap();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let fee = check_fee!(wallet, psbt);
assert_eq!(psbt.unsigned_tx.output.len(), 1);
let drain_addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(drain_addr.script_pubkey());
- builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ builder.finish().unwrap();
}
#[test]
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let fee = check_fee!(wallet, psbt);
assert_fee_rate!(psbt, fee.unwrap_or(Amount::ZERO), FeeRate::BROADCAST_MIN, @add_signature);
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.fee_rate(FeeRate::from_sat_per_vb_unchecked(5));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let fee = check_fee!(wallet, psbt);
assert_fee_rate!(psbt, fee.unwrap_or(Amount::ZERO), FeeRate::from_sat_per_vb_unchecked(5), @add_signature);
.drain_to(addr.script_pubkey())
.drain_wallet()
.fee_absolute(Amount::from_sat(100));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let fee = check_fee!(wallet, psbt);
assert_eq!(fee.unwrap_or(Amount::ZERO), Amount::from_sat(100));
.drain_to(addr.script_pubkey())
.drain_wallet()
.fee_absolute(Amount::ZERO);
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let fee = check_fee!(wallet, psbt);
assert_eq!(fee.unwrap_or(Amount::ZERO), Amount::ZERO);
.drain_to(addr.script_pubkey())
.drain_wallet()
.fee_absolute(Amount::from_sat(60_000));
- let _ = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let _ = builder.finish().unwrap();
}
#[test]
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(49_800));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let fee = check_fee!(wallet, psbt);
assert_eq!(psbt.unsigned_tx.output.len(), 1);
.drain_to(addr.script_pubkey())
.drain_wallet()
.fee_rate(FeeRate::from_sat_per_vb_unchecked(454));
- builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ builder.finish().unwrap();
}
#[test]
.add_recipient(addr.script_pubkey(), Amount::from_sat(30_000))
.add_recipient(addr.script_pubkey(), Amount::from_sat(10_000))
.ordering(bdk_wallet::wallet::tx_builder::TxOrdering::Bip69Lexicographic);
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let fee = check_fee!(wallet, psbt);
assert_eq!(psbt.unsigned_tx.output.len(), 3);
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(30_000));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(psbt.inputs[0].sighash_type, None);
}
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(30_000))
.sighash(EcdsaSighashType::Single.into());
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(
psbt.inputs[0].sighash_type,
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(psbt.inputs[0].bip32_derivation.len(), 1);
assert_eq!(
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(psbt.outputs[0].bip32_derivation.len(), 1);
let expected_derivation_path = format!("m/44'/0'/0'/0/{}", addr.index);
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(
psbt.inputs[0].redeem_script,
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(psbt.inputs[0].redeem_script, None);
assert_eq!(
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let script = ScriptBuf::from_hex(
"21032b0558078bec38694a84933d659303e2575dae7e91685911454115bfd64487e3ac",
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert!(psbt.inputs[0].non_witness_utxo.is_some());
assert!(psbt.inputs[0].witness_utxo.is_none());
.drain_to(addr.script_pubkey())
.only_witness_utxo()
.drain_wallet();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert!(psbt.inputs[0].non_witness_utxo.is_none());
assert!(psbt.inputs[0].witness_utxo.is_some());
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert!(psbt.inputs[0].witness_utxo.is_some());
}
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert!(psbt.inputs[0].non_witness_utxo.is_some());
assert!(psbt.inputs[0].witness_utxo.is_some());
vout: 0,
})
.unwrap();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let sent_received =
wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
})
.unwrap()
.manually_selected_only();
- builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ builder.finish().unwrap();
}
#[test]
.assume_checked();
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(10_000));
- builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ builder.finish().unwrap();
}
#[test]
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(30_000))
.policy_path(path, KeychainKind::External);
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(0xFFFFFFFF));
}
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(30_000))
.policy_path(path, KeychainKind::External);
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(144));
}
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(30_000))
.policy_path(path, KeychainKind::External);
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(psbt.unsigned_tx.input[0].sequence, Sequence(0xFFFFFFFE));
}
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.add_global_xpubs();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let key = bip32::Xpub::from_str("tpubDCKxNyM3bLgbEX13Mcd8mYxbVg9ajDkWXMh29hMWBurKfVmBfWAM96QVP3zaUcN51HvkZ3ar4VwP82kC8JZhhux8vFQoJintSpVBwpFvyU3").unwrap();
let fingerprint = bip32::Fingerprint::from_hex("73756c7f").unwrap();
foreign_utxo_satisfaction.to_wu() as usize,
)
.unwrap();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
wallet1.insert_txout(utxo.outpoint, utxo.txout);
let fee = check_fee!(wallet1, psbt);
let sent_received =
foreign_utxo_satisfaction.to_wu() as usize,
)
.unwrap();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let tx = psbt.extract_tx().expect("failed to extract tx");
wallet1.calculate_fee(&tx).unwrap();
}
)
.unwrap();
assert!(
- builder.finish_with_aux_rand(&mut thread_rng()).is_err(),
+ builder.finish().is_err(),
"psbt_input with witness_utxo should fail with only witness_utxo"
);
}
)
.unwrap();
assert!(
- builder.finish_with_aux_rand(&mut thread_rng()).is_ok(),
+ builder.finish().is_ok(),
"psbt_input with just witness_utxo should succeed when `only_witness_utxo` is enabled"
);
}
)
.unwrap();
assert!(
- builder.finish_with_aux_rand(&mut thread_rng()).is_ok(),
+ builder.finish().is_ok(),
"psbt_input with non_witness_utxo should succeed by default"
);
}
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.add_global_xpubs();
- builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ builder.finish().unwrap();
}
#[test]
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.add_global_xpubs();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let key = bip32::Xpub::from_str("tpubD6NzVbkrYhZ4Y55A58Gv9RSNF5hy84b5AJqYy7sCcjFrkcLpPre8kmgfit6kY1Zs3BLgeypTDBZJM222guPpdz7Cup5yzaMu62u7mYGbwFL").unwrap();
let fingerprint = bip32::Fingerprint::from_hex("997a323b").unwrap();
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let tx = psbt.extract_tx().expect("failed to extract tx");
let txid = tx.compute_txid();
wallet
.insert_tx(tx, ConfirmationTime::Unconfirmed { last_seen: 0 })
.unwrap();
- wallet
- .build_fee_bump(txid)
- .unwrap()
- .finish_with_aux_rand(&mut thread_rng())
- .unwrap();
+ wallet.build_fee_bump(txid).unwrap().finish().unwrap();
}
#[test]
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let tx = psbt.extract_tx().expect("failed to extract tx");
let txid = tx.compute_txid();
)
.unwrap();
- wallet
- .build_fee_bump(txid)
- .unwrap()
- .finish_with_aux_rand(&mut thread_rng())
- .unwrap();
+ wallet.build_fee_bump(txid).unwrap().finish().unwrap();
}
#[test]
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let feerate = psbt.fee_rate().unwrap();
let tx = psbt.extract_tx().expect("failed to extract tx");
let mut builder = wallet.build_fee_bump(txid).unwrap();
builder.fee_rate(FeeRate::BROADCAST_MIN);
- let res = builder.finish_with_aux_rand(&mut thread_rng());
+ let res = builder.finish();
assert_matches!(
res,
Err(CreateTxError::FeeRateTooLow { .. }),
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let tx = psbt.extract_tx().expect("failed to extract tx");
let txid = tx.compute_txid();
let mut builder = wallet.build_fee_bump(txid).unwrap();
builder.fee_absolute(Amount::from_sat(10));
- builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ builder.finish().unwrap();
}
#[test]
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let tx = psbt.extract_tx().expect("failed to extract tx");
let txid = tx.compute_txid();
let mut builder = wallet.build_fee_bump(txid).unwrap();
builder.fee_absolute(Amount::ZERO);
- builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ builder.finish().unwrap();
}
#[test]
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000))
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let original_sent_received =
wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
let original_fee = check_fee!(wallet, psbt);
let feerate = FeeRate::from_sat_per_kwu(625); // 2.5 sat/vb
let mut builder = wallet.build_fee_bump(txid).unwrap();
builder.fee_rate(feerate).enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let sent_received =
wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
let fee = check_fee!(wallet, psbt);
let mut builder = wallet.build_fee_bump(txid).unwrap();
builder.fee_absolute(Amount::from_sat(200));
builder.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let sent_received =
wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
let fee = check_fee!(wallet, psbt);
.drain_to(addr.script_pubkey())
.drain_wallet()
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let tx = psbt.clone().extract_tx().expect("failed to extract tx");
let original_sent_received = wallet.sent_and_received(&tx);
let original_fee = check_fee!(wallet, psbt);
.drain_to(addr.script_pubkey())
// drain wallet output amount will be re-calculated with new fee rate
.drain_wallet();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let sent_received =
wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
let fee = check_fee!(wallet, psbt);
.drain_to(addr.script_pubkey())
.drain_wallet()
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let original_fee = check_fee!(wallet, psbt);
let tx = psbt.extract_tx().expect("failed to extract tx");
let original_sent_received = wallet.sent_and_received(&tx);
.drain_to(addr.script_pubkey())
// drain wallet output amount will be re-calculated with new fee rate
.drain_wallet();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let tx = &psbt.unsigned_tx;
let sent_received = wallet.sent_and_received(tx);
let fee = check_fee!(wallet, psbt);
.unwrap()
.manually_selected_only()
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let tx = psbt.extract_tx().expect("failed to extract tx");
let original_sent_received = wallet.sent_and_received(&tx);
builder
.drain_wallet()
.fee_rate(FeeRate::from_sat_per_vb_unchecked(5));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let sent_received = wallet.sent_and_received(&psbt.extract_tx().expect("failed to extract tx"));
assert_eq!(sent_received.0, Amount::from_sat(75_000));
.unwrap()
.manually_selected_only()
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let tx = psbt.extract_tx().expect("failed to extract tx");
let original_sent_received = wallet.sent_and_received(&tx);
let txid = tx.compute_txid();
builder
.manually_selected_only()
.fee_rate(FeeRate::from_sat_per_vb_unchecked(255));
- builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ builder.finish().unwrap();
}
#[test]
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(45_000))
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let tx = psbt.extract_tx().expect("failed to extract tx");
let original_details = wallet.sent_and_received(&tx);
let txid = tx.compute_txid();
let mut builder = wallet.build_fee_bump(txid).unwrap();
builder.fee_rate(FeeRate::from_sat_per_vb_unchecked(50));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let sent_received =
wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
let fee = check_fee!(wallet, psbt);
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(45_000))
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let tx = psbt.extract_tx().expect("failed to extract tx");
let original_sent_received = wallet.sent_and_received(&tx);
let txid = tx.compute_txid();
let mut builder = wallet.build_fee_bump(txid).unwrap();
builder.fee_absolute(Amount::from_sat(6_000));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let sent_received =
wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
let fee = check_fee!(wallet, psbt);
.unwrap()
.manually_selected_only()
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let original_sent_received =
wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
let original_fee = check_fee!(wallet, psbt);
// the original output untouched.
let mut builder = wallet.build_fee_bump(txid).unwrap();
builder.fee_rate(FeeRate::from_sat_per_vb_unchecked(50));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let sent_received =
wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
let fee = check_fee!(wallet, psbt);
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(45_000))
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let original_sent_received =
wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
let original_fee = check_fee!(wallet, psbt);
// We use epsilon here to avoid asking for a slightly too high feerate
let fee_abs = 50_000 + 25_000 - 45_000 - 10;
builder.fee_rate(Amount::from_sat(fee_abs) / new_tx_weight);
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let sent_received =
wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
let fee = check_fee!(wallet, psbt);
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(45_000))
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let mut tx = psbt.extract_tx().expect("failed to extract tx");
let original_sent_received = wallet.sent_and_received(&tx);
let txid = tx.compute_txid();
.add_utxo(incoming_op)
.unwrap()
.fee_rate(FeeRate::from_sat_per_vb_unchecked(5));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let sent_received =
wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
let fee = check_fee!(wallet, psbt);
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(45_000))
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let mut tx = psbt.extract_tx().expect("failed to extract tx");
let original_sent_received = wallet.sent_and_received(&tx);
let txid = tx.compute_txid();
.add_utxo(incoming_op)
.unwrap()
.fee_absolute(Amount::from_sat(250));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let sent_received =
wallet.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
let fee = check_fee!(wallet, psbt);
.drain_wallet()
.drain_to(addr.script_pubkey())
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
// Now we receive one transaction with 0 confirmations. We won't be able to use that for
// fee bumping, as it's still unconfirmed!
receive_output(
.unwrap();
let mut builder = wallet.build_fee_bump(txid).unwrap();
builder.fee_rate(FeeRate::from_sat_per_vb_unchecked(25));
- builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ builder.finish().unwrap();
}
#[test]
.drain_wallet()
.drain_to(addr.script_pubkey())
.enable_rbf();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let mut tx = psbt.extract_tx().expect("failed to extract tx");
let txid = tx.compute_txid();
for txin in &mut tx.input {
.drain_to(addr.script_pubkey())
// drain wallet output amount will be re-calculated with new fee rate
.drain_wallet();
- builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ builder.finish().unwrap();
}
#[test]
.unwrap()
.enable_rbf()
.fee_rate(fee_rate);
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let fee = check_fee!(wallet, psbt);
assert_eq!(psbt.inputs.len(), 1);
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
assert!(finalized);
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
assert!(finalized);
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
assert!(finalized);
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
assert!(finalized);
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
assert!(finalized);
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
psbt.inputs[0].bip32_derivation.clear();
assert_eq!(psbt.inputs[0].bip32_derivation.len(), 0);
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(45_000))
.include_output_redeem_witness_script();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
// p2sh-p2wsh transaction should contain both witness and redeem scripts
assert!(psbt
builder
.add_recipient(addr.script_pubkey(), Amount::from_sat(45_000))
.include_output_redeem_witness_script();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
// add another input to the psbt that is at least passable.
let dud_input = bitcoin::psbt::Input {
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
assert!(wallet
.sign(
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
let finalized = wallet
.sign(
.drain_to(addr.script_pubkey())
.sighash(sighash.into())
.drain_wallet();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
let result = wallet.sign(&mut psbt, Default::default());
assert!(
.assume_checked();
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(45_000));
- builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ builder.finish().unwrap();
}
#[test]
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
let finalized = wallet.sign(&mut psbt, SignOptions::default()).unwrap();
assert!(finalized);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(
psbt.inputs[0]
.drain_to(addr.script_pubkey())
.drain_wallet()
.policy_path(path, KeychainKind::External);
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let mut input_key_origins = psbt.inputs[0]
.tap_key_origins
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
assert_eq!(
psbt.inputs[0].tap_merkle_root,
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
let witness_utxo = psbt.inputs[0].witness_utxo.take();
let result = wallet.sign(
let addr = wallet.next_unused_address(KeychainKind::External);
let mut builder = wallet.build_tx();
builder.drain_to(addr.script_pubkey()).drain_wallet();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
psbt.inputs[0].witness_utxo = None;
psbt.inputs[0].non_witness_utxo =
foreign_utxo_satisfaction.to_wu() as usize,
)
.unwrap();
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
let sent_received =
wallet1.sent_and_received(&psbt.clone().extract_tx().expect("failed to extract tx"));
wallet1.insert_txout(utxo.outpoint, utxo.txout);
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
assert!(
wallet.sign(&mut psbt, Default::default()).unwrap(),
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
assert!(
wallet
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
assert!(
wallet
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
let mut script_leaves: Vec<_> = psbt.inputs[0]
.tap_scripts
.clone()
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
let mut script_leaves: Vec<_> = psbt.inputs[0]
.tap_scripts
.clone()
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
wallet
.sign(
let mut builder = wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(25_000));
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
// re-create the wallet with an empty db
let wallet_empty = Wallet::new(
.drain_to(addr.script_pubkey())
.sighash(TapSighashType::All.into())
.drain_wallet();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
let result = wallet.sign(&mut psbt, Default::default());
assert!(
.drain_to(addr.script_pubkey())
.sighash(sighash.into())
.drain_wallet();
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
let witness_utxo = psbt.inputs[0].witness_utxo.take();
.add_recipient(addr.script_pubkey(), balance.immature / 2)
.current_height(confirmation_height);
assert!(matches!(
- builder.finish_with_aux_rand(&mut thread_rng()),
+ builder.finish(),
Err(CreateTxError::CoinSelection(
coin_selection::Error::InsufficientFunds {
needed: _,
.add_recipient(addr.script_pubkey(), balance.immature / 2)
.current_height(not_yet_mature_time);
assert_matches!(
- builder.finish_with_aux_rand(&mut thread_rng()),
+ builder.finish(),
Err(CreateTxError::CoinSelection(
coin_selection::Error::InsufficientFunds {
needed: _,
builder
.add_recipient(addr.script_pubkey(), balance.confirmed / 2)
.current_height(maturity_time);
- builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ builder.finish().unwrap();
}
#[test]
builder.add_recipient(addr.script_pubkey(), Amount::ZERO);
assert_matches!(
- builder.finish_with_aux_rand(&mut thread_rng()),
+ builder.finish(),
Err(CreateTxError::OutputBelowDustLimit(0))
);
.allow_dust(true)
.add_recipient(addr.script_pubkey(), Amount::ZERO);
- assert!(builder.finish_with_aux_rand(&mut thread_rng()).is_ok());
+ assert!(builder.finish().is_ok());
}
#[test]
.drain_wallet()
.fee_rate(fee_rate)
.add_data(&data);
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
let fee = check_fee!(wallet, psbt);
let (op_return_vout, _) = psbt
.unsigned_tx
.drain_to(addr.script_pubkey())
.drain_wallet()
.fee_rate(fee_rate);
- let mut psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let mut psbt = builder.finish().unwrap();
let fee = check_fee!(wallet, psbt);
wallet
let mut builder = $wallet.build_tx();
builder.add_recipient(addr.script_pubkey(), Amount::from_sat(10_000));
- let psbt = builder.finish_with_aux_rand(&mut thread_rng()).unwrap();
+ let psbt = builder.finish().unwrap();
psbt
}};
projects / bdk / commitdiff