Skip to content

Commit 14d2e97

Browse files
TheBlueMattTheBlueMatt
authored
Merge pull request #1887 from TheBlueMatt/2022-11-definitely-valid
Remove cryptographically unreachable error conditions
2 parents 52edb35 + 2cfc1db commit 14d2e97

File tree

6 files changed

+124
-144
lines changed

6 files changed

+124
-144
lines changed

‎lightning/src/chain/channelmonitor.rs

Lines changed: 14 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -2443,8 +2443,8 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
24432443
let secret = self.get_secret(commitment_number).unwrap();
24442444
let per_commitment_key = ignore_error!(SecretKey::from_slice(&secret));
24452445
let per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key);
2446-
let revocation_pubkey = ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, &per_commitment_point, &self.holder_revocation_basepoint));
2447-
let delayed_key = ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key), &self.counterparty_commitment_params.counterparty_delayed_payment_base_key));
2446+
let revocation_pubkey = chan_utils::derive_public_revocation_key(&self.secp_ctx, &per_commitment_point, &self.holder_revocation_basepoint);
2447+
let delayed_key = chan_utils::derive_public_key(&self.secp_ctx, &PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key), &self.counterparty_commitment_params.counterparty_delayed_payment_base_key);
24482448

24492449
let revokeable_redeemscript = chan_utils::get_revokeable_redeemscript(&revocation_pubkey, self.counterparty_commitment_params.on_counterparty_tx_csv, &delayed_key);
24502450
let revokeable_p2wsh = revokeable_redeemscript.to_v0_p2wsh();
@@ -2556,31 +2556,18 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
25562556
} else { return (claimable_outpoints, to_counterparty_output_info); };
25572557

25582558
if let Some(transaction) = tx {
2559-
let revokeable_p2wsh_opt =
2560-
if let Ok(revocation_pubkey) = chan_utils::derive_public_revocation_key(
2561-
&self.secp_ctx, &per_commitment_point, &self.holder_revocation_basepoint)
2562-
{
2563-
if let Ok(delayed_key) = chan_utils::derive_public_key(&self.secp_ctx,
2564-
&per_commitment_point,
2565-
&self.counterparty_commitment_params.counterparty_delayed_payment_base_key)
2566-
{
2567-
Some(chan_utils::get_revokeable_redeemscript(&revocation_pubkey,
2568-
self.counterparty_commitment_params.on_counterparty_tx_csv,
2569-
&delayed_key).to_v0_p2wsh())
2570-
} else {
2571-
debug_assert!(false, "Failed to derive a delayed payment key for a commitment state we accepted");
2572-
None
2573-
}
2574-
} else {
2575-
debug_assert!(false, "Failed to derive a revocation pubkey key for a commitment state we accepted");
2576-
None
2577-
};
2578-
if let Some(revokeable_p2wsh) = revokeable_p2wsh_opt {
2579-
for (idx, outp) in transaction.output.iter().enumerate() {
2580-
if outp.script_pubkey == revokeable_p2wsh {
2581-
to_counterparty_output_info =
2582-
Some((idx.try_into().expect("Can't have > 2^32 outputs"), outp.value));
2583-
}
2559+
let revocation_pubkey = chan_utils::derive_public_revocation_key(
2560+
&self.secp_ctx, &per_commitment_point, &self.holder_revocation_basepoint);
2561+
let delayed_key = chan_utils::derive_public_key(&self.secp_ctx,
2562+
&per_commitment_point,
2563+
&self.counterparty_commitment_params.counterparty_delayed_payment_base_key);
2564+
let revokeable_p2wsh = chan_utils::get_revokeable_redeemscript(&revocation_pubkey,
2565+
self.counterparty_commitment_params.on_counterparty_tx_csv,
2566+
&delayed_key).to_v0_p2wsh();
2567+
for (idx, outp) in transaction.output.iter().enumerate() {
2568+
if outp.script_pubkey == revokeable_p2wsh {
2569+
to_counterparty_output_info =
2570+
Some((idx.try_into().expect("Can't have > 2^32 outputs"), outp.value));
25842571
}
25852572
}
25862573
}

‎lightning/src/chain/keysinterface.rs

Lines changed: 17 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -655,8 +655,7 @@ impl InMemorySigner {
655655
if spend_tx.input[input_idx].previous_output != descriptor.outpoint.into_bitcoin_outpoint() { return Err(()); }
656656
if spend_tx.input[input_idx].sequence.0 != descriptor.to_self_delay as u32 { return Err(()); }
657657

658-
let delayed_payment_key = chan_utils::derive_private_key(&secp_ctx, &descriptor.per_commitment_point, &self.delayed_payment_base_key)
659-
.expect("We constructed the payment_base_key, so we can only fail here if the RNG is busted.");
658+
let delayed_payment_key = chan_utils::derive_private_key(&secp_ctx, &descriptor.per_commitment_point, &self.delayed_payment_base_key);
660659
let delayed_payment_pubkey = PublicKey::from_secret_key(&secp_ctx, &delayed_payment_key);
661660
let witness_script = chan_utils::get_revokeable_redeemscript(&descriptor.revocation_pubkey, descriptor.to_self_delay, &delayed_payment_pubkey);
662661
let sighash = hash_to_message!(&sighash::SighashCache::new(spend_tx).segwit_signature_hash(input_idx, &witness_script, descriptor.output.value, EcdsaSighashType::All).unwrap()[..]);
@@ -710,7 +709,7 @@ impl BaseSign for InMemorySigner {
710709
let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, self.opt_anchors(), &keys);
711710
let htlc_sighashtype = if self.opt_anchors() { EcdsaSighashType::SinglePlusAnyoneCanPay } else { EcdsaSighashType::All };
712711
let htlc_sighash = hash_to_message!(&sighash::SighashCache::new(&htlc_tx).segwit_signature_hash(0, &htlc_redeemscript, htlc.amount_msat / 1000, htlc_sighashtype).unwrap()[..]);
713-
let holder_htlc_key = chan_utils::derive_private_key(&secp_ctx, &keys.per_commitment_point, &self.htlc_base_key).map_err(|_| ())?;
712+
let holder_htlc_key = chan_utils::derive_private_key(&secp_ctx, &keys.per_commitment_point, &self.htlc_base_key);
714713
htlc_sigs.push(sign(secp_ctx, &htlc_sighash, &holder_htlc_key));
715714
}
716715

@@ -743,11 +742,11 @@ impl BaseSign for InMemorySigner {
743742
}
744743

745744
fn sign_justice_revoked_output(&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()> {
746-
let revocation_key = chan_utils::derive_private_revocation_key(&secp_ctx, &per_commitment_key, &self.revocation_base_key).map_err(|_| ())?;
745+
let revocation_key = chan_utils::derive_private_revocation_key(&secp_ctx, &per_commitment_key, &self.revocation_base_key);
747746
let per_commitment_point = PublicKey::from_secret_key(secp_ctx, &per_commitment_key);
748-
let revocation_pubkey = chan_utils::derive_public_revocation_key(&secp_ctx, &per_commitment_point, &self.pubkeys().revocation_basepoint).map_err(|_| ())?;
747+
let revocation_pubkey = chan_utils::derive_public_revocation_key(&secp_ctx, &per_commitment_point, &self.pubkeys().revocation_basepoint);
749748
let witness_script = {
750-
let counterparty_delayedpubkey = chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.counterparty_pubkeys().delayed_payment_basepoint).map_err(|_| ())?;
749+
let counterparty_delayedpubkey = chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.counterparty_pubkeys().delayed_payment_basepoint);
751750
chan_utils::get_revokeable_redeemscript(&revocation_pubkey, self.holder_selected_contest_delay(), &counterparty_delayedpubkey)
752751
};
753752
let mut sighash_parts = sighash::SighashCache::new(justice_tx);
@@ -756,12 +755,12 @@ impl BaseSign for InMemorySigner {
756755
}
757756

758757
fn sign_justice_revoked_htlc(&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()> {
759-
let revocation_key = chan_utils::derive_private_revocation_key(&secp_ctx, &per_commitment_key, &self.revocation_base_key).map_err(|_| ())?;
758+
let revocation_key = chan_utils::derive_private_revocation_key(&secp_ctx, &per_commitment_key, &self.revocation_base_key);
760759
let per_commitment_point = PublicKey::from_secret_key(secp_ctx, &per_commitment_key);
761-
let revocation_pubkey = chan_utils::derive_public_revocation_key(&secp_ctx, &per_commitment_point, &self.pubkeys().revocation_basepoint).map_err(|_| ())?;
760+
let revocation_pubkey = chan_utils::derive_public_revocation_key(&secp_ctx, &per_commitment_point, &self.pubkeys().revocation_basepoint);
762761
let witness_script = {
763-
let counterparty_htlcpubkey = chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.counterparty_pubkeys().htlc_basepoint).map_err(|_| ())?;
764-
let holder_htlcpubkey = chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.pubkeys().htlc_basepoint).map_err(|_| ())?;
762+
let counterparty_htlcpubkey = chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.counterparty_pubkeys().htlc_basepoint);
763+
let holder_htlcpubkey = chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.pubkeys().htlc_basepoint);
765764
chan_utils::get_htlc_redeemscript_with_explicit_keys(&htlc, self.opt_anchors(), &counterparty_htlcpubkey, &holder_htlcpubkey, &revocation_pubkey)
766765
};
767766
let mut sighash_parts = sighash::SighashCache::new(justice_tx);
@@ -770,19 +769,14 @@ impl BaseSign for InMemorySigner {
770769
}
771770

772771
fn sign_counterparty_htlc_transaction(&self, htlc_tx: &Transaction, input: usize, amount: u64, per_commitment_point: &PublicKey, htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()> {
773-
if let Ok(htlc_key) = chan_utils::derive_private_key(&secp_ctx, &per_commitment_point, &self.htlc_base_key) {
774-
let witness_script = if let Ok(revocation_pubkey) = chan_utils::derive_public_revocation_key(&secp_ctx, &per_commitment_point, &self.pubkeys().revocation_basepoint) {
775-
if let Ok(counterparty_htlcpubkey) = chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.counterparty_pubkeys().htlc_basepoint) {
776-
if let Ok(htlcpubkey) = chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.pubkeys().htlc_basepoint) {
777-
chan_utils::get_htlc_redeemscript_with_explicit_keys(&htlc, self.opt_anchors(), &counterparty_htlcpubkey, &htlcpubkey, &revocation_pubkey)
778-
} else { return Err(()) }
779-
} else { return Err(()) }
780-
} else { return Err(()) };
781-
let mut sighash_parts = sighash::SighashCache::new(htlc_tx);
782-
let sighash = hash_to_message!(&sighash_parts.segwit_signature_hash(input, &witness_script, amount, EcdsaSighashType::All).unwrap()[..]);
783-
return Ok(sign(secp_ctx, &sighash, &htlc_key))
784-
}
785-
Err(())
772+
let htlc_key = chan_utils::derive_private_key(&secp_ctx, &per_commitment_point, &self.htlc_base_key);
773+
let revocation_pubkey = chan_utils::derive_public_revocation_key(&secp_ctx, &per_commitment_point, &self.pubkeys().revocation_basepoint);
774+
let counterparty_htlcpubkey = chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.counterparty_pubkeys().htlc_basepoint);
775+
let htlcpubkey = chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.pubkeys().htlc_basepoint);
776+
let witness_script = chan_utils::get_htlc_redeemscript_with_explicit_keys(&htlc, self.opt_anchors(), &counterparty_htlcpubkey, &htlcpubkey, &revocation_pubkey);
777+
let mut sighash_parts = sighash::SighashCache::new(htlc_tx);
778+
let sighash = hash_to_message!(&sighash_parts.segwit_signature_hash(input, &witness_script, amount, EcdsaSighashType::All).unwrap()[..]);
779+
Ok(sign(secp_ctx, &sighash, &htlc_key))
786780
}
787781

788782
fn sign_closing_transaction(&self, closing_tx: &ClosingTransaction, secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()> {

‎lightning/src/chain/package.rs

Lines changed: 40 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -381,57 +381,53 @@ impl PackageSolvingData {
381381
fn finalize_input<Signer: Sign>(&self, bumped_tx: &mut Transaction, i: usize, onchain_handler: &mut OnchainTxHandler<Signer>) -> bool {
382382
match self {
383383
PackageSolvingData::RevokedOutput(ref outp) => {
384-
if let Ok(chan_keys) = TxCreationKeys::derive_new(&onchain_handler.secp_ctx, &outp.per_commitment_point, &outp.counterparty_delayed_payment_base_key, &outp.counterparty_htlc_base_key, &onchain_handler.signer.pubkeys().revocation_basepoint, &onchain_handler.signer.pubkeys().htlc_basepoint) {
385-
let witness_script = chan_utils::get_revokeable_redeemscript(&chan_keys.revocation_key, outp.on_counterparty_tx_csv, &chan_keys.broadcaster_delayed_payment_key);
386-
//TODO: should we panic on signer failure ?
387-
if let Ok(sig) = onchain_handler.signer.sign_justice_revoked_output(&bumped_tx, i, outp.amount, &outp.per_commitment_key, &onchain_handler.secp_ctx) {
388-
let mut ser_sig = sig.serialize_der().to_vec();
389-
ser_sig.push(EcdsaSighashType::All as u8);
390-
bumped_tx.input[i].witness.push(ser_sig);
391-
bumped_tx.input[i].witness.push(vec!(1));
392-
bumped_tx.input[i].witness.push(witness_script.clone().into_bytes());
393-
} else { return false; }
394-
}
384+
let chan_keys = TxCreationKeys::derive_new(&onchain_handler.secp_ctx, &outp.per_commitment_point, &outp.counterparty_delayed_payment_base_key, &outp.counterparty_htlc_base_key, &onchain_handler.signer.pubkeys().revocation_basepoint, &onchain_handler.signer.pubkeys().htlc_basepoint);
385+
let witness_script = chan_utils::get_revokeable_redeemscript(&chan_keys.revocation_key, outp.on_counterparty_tx_csv, &chan_keys.broadcaster_delayed_payment_key);
386+
//TODO: should we panic on signer failure ?
387+
if let Ok(sig) = onchain_handler.signer.sign_justice_revoked_output(&bumped_tx, i, outp.amount, &outp.per_commitment_key, &onchain_handler.secp_ctx) {
388+
let mut ser_sig = sig.serialize_der().to_vec();
389+
ser_sig.push(EcdsaSighashType::All as u8);
390+
bumped_tx.input[i].witness.push(ser_sig);
391+
bumped_tx.input[i].witness.push(vec!(1));
392+
bumped_tx.input[i].witness.push(witness_script.clone().into_bytes());
393+
} else { return false; }
395394
},
396395
PackageSolvingData::RevokedHTLCOutput(ref outp) => {
397-
if let Ok(chan_keys) = TxCreationKeys::derive_new(&onchain_handler.secp_ctx, &outp.per_commitment_point, &outp.counterparty_delayed_payment_base_key, &outp.counterparty_htlc_base_key, &onchain_handler.signer.pubkeys().revocation_basepoint, &onchain_handler.signer.pubkeys().htlc_basepoint) {
398-
let witness_script = chan_utils::get_htlc_redeemscript_with_explicit_keys(&outp.htlc, onchain_handler.opt_anchors(), &chan_keys.broadcaster_htlc_key, &chan_keys.countersignatory_htlc_key, &chan_keys.revocation_key);
399-
//TODO: should we panic on signer failure ?
400-
if let Ok(sig) = onchain_handler.signer.sign_justice_revoked_htlc(&bumped_tx, i, outp.amount, &outp.per_commitment_key, &outp.htlc, &onchain_handler.secp_ctx) {
401-
let mut ser_sig = sig.serialize_der().to_vec();
402-
ser_sig.push(EcdsaSighashType::All as u8);
403-
bumped_tx.input[i].witness.push(ser_sig);
404-
bumped_tx.input[i].witness.push(chan_keys.revocation_key.clone().serialize().to_vec());
405-
bumped_tx.input[i].witness.push(witness_script.clone().into_bytes());
406-
} else { return false; }
407-
}
396+
let chan_keys = TxCreationKeys::derive_new(&onchain_handler.secp_ctx, &outp.per_commitment_point, &outp.counterparty_delayed_payment_base_key, &outp.counterparty_htlc_base_key, &onchain_handler.signer.pubkeys().revocation_basepoint, &onchain_handler.signer.pubkeys().htlc_basepoint);
397+
let witness_script = chan_utils::get_htlc_redeemscript_with_explicit_keys(&outp.htlc, onchain_handler.opt_anchors(), &chan_keys.broadcaster_htlc_key, &chan_keys.countersignatory_htlc_key, &chan_keys.revocation_key);
398+
//TODO: should we panic on signer failure ?
399+
if let Ok(sig) = onchain_handler.signer.sign_justice_revoked_htlc(&bumped_tx, i, outp.amount, &outp.per_commitment_key, &outp.htlc, &onchain_handler.secp_ctx) {
400+
let mut ser_sig = sig.serialize_der().to_vec();
401+
ser_sig.push(EcdsaSighashType::All as u8);
402+
bumped_tx.input[i].witness.push(ser_sig);
403+
bumped_tx.input[i].witness.push(chan_keys.revocation_key.clone().serialize().to_vec());
404+
bumped_tx.input[i].witness.push(witness_script.clone().into_bytes());
405+
} else { return false; }
408406
},
409407
PackageSolvingData::CounterpartyOfferedHTLCOutput(ref outp) => {
410-
if let Ok(chan_keys) = TxCreationKeys::derive_new(&onchain_handler.secp_ctx, &outp.per_commitment_point, &outp.counterparty_delayed_payment_base_key, &outp.counterparty_htlc_base_key, &onchain_handler.signer.pubkeys().revocation_basepoint, &onchain_handler.signer.pubkeys().htlc_basepoint) {
411-
let witness_script = chan_utils::get_htlc_redeemscript_with_explicit_keys(&outp.htlc, onchain_handler.opt_anchors(), &chan_keys.broadcaster_htlc_key, &chan_keys.countersignatory_htlc_key, &chan_keys.revocation_key);
412-
413-
if let Ok(sig) = onchain_handler.signer.sign_counterparty_htlc_transaction(&bumped_tx, i, &outp.htlc.amount_msat / 1000, &outp.per_commitment_point, &outp.htlc, &onchain_handler.secp_ctx) {
414-
let mut ser_sig = sig.serialize_der().to_vec();
415-
ser_sig.push(EcdsaSighashType::All as u8);
416-
bumped_tx.input[i].witness.push(ser_sig);
417-
bumped_tx.input[i].witness.push(outp.preimage.0.to_vec());
418-
bumped_tx.input[i].witness.push(witness_script.clone().into_bytes());
419-
}
408+
let chan_keys = TxCreationKeys::derive_new(&onchain_handler.secp_ctx, &outp.per_commitment_point, &outp.counterparty_delayed_payment_base_key, &outp.counterparty_htlc_base_key, &onchain_handler.signer.pubkeys().revocation_basepoint, &onchain_handler.signer.pubkeys().htlc_basepoint);
409+
let witness_script = chan_utils::get_htlc_redeemscript_with_explicit_keys(&outp.htlc, onchain_handler.opt_anchors(), &chan_keys.broadcaster_htlc_key, &chan_keys.countersignatory_htlc_key, &chan_keys.revocation_key);
410+
411+
if let Ok(sig) = onchain_handler.signer.sign_counterparty_htlc_transaction(&bumped_tx, i, &outp.htlc.amount_msat / 1000, &outp.per_commitment_point, &outp.htlc, &onchain_handler.secp_ctx) {
412+
let mut ser_sig = sig.serialize_der().to_vec();
413+
ser_sig.push(EcdsaSighashType::All as u8);
414+
bumped_tx.input[i].witness.push(ser_sig);
415+
bumped_tx.input[i].witness.push(outp.preimage.0.to_vec());
416+
bumped_tx.input[i].witness.push(witness_script.clone().into_bytes());
420417
}
421418
},
422419
PackageSolvingData::CounterpartyReceivedHTLCOutput(ref outp) => {
423-
if let Ok(chan_keys) = TxCreationKeys::derive_new(&onchain_handler.secp_ctx, &outp.per_commitment_point, &outp.counterparty_delayed_payment_base_key, &outp.counterparty_htlc_base_key, &onchain_handler.signer.pubkeys().revocation_basepoint, &onchain_handler.signer.pubkeys().htlc_basepoint) {
424-
let witness_script = chan_utils::get_htlc_redeemscript_with_explicit_keys(&outp.htlc, onchain_handler.opt_anchors(), &chan_keys.broadcaster_htlc_key, &chan_keys.countersignatory_htlc_key, &chan_keys.revocation_key);
425-
426-
bumped_tx.lock_time = PackedLockTime(outp.htlc.cltv_expiry); // Right now we don't aggregate time-locked transaction, if we do we should set lock_time before to avoid breaking hash computation
427-
if let Ok(sig) = onchain_handler.signer.sign_counterparty_htlc_transaction(&bumped_tx, i, &outp.htlc.amount_msat / 1000, &outp.per_commitment_point, &outp.htlc, &onchain_handler.secp_ctx) {
428-
let mut ser_sig = sig.serialize_der().to_vec();
429-
ser_sig.push(EcdsaSighashType::All as u8);
430-
bumped_tx.input[i].witness.push(ser_sig);
431-
// Due to BIP146 (MINIMALIF) this must be a zero-length element to relay.
432-
bumped_tx.input[i].witness.push(vec![]);
433-
bumped_tx.input[i].witness.push(witness_script.clone().into_bytes());
434-
}
420+
let chan_keys = TxCreationKeys::derive_new(&onchain_handler.secp_ctx, &outp.per_commitment_point, &outp.counterparty_delayed_payment_base_key, &outp.counterparty_htlc_base_key, &onchain_handler.signer.pubkeys().revocation_basepoint, &onchain_handler.signer.pubkeys().htlc_basepoint);
421+
let witness_script = chan_utils::get_htlc_redeemscript_with_explicit_keys(&outp.htlc, onchain_handler.opt_anchors(), &chan_keys.broadcaster_htlc_key, &chan_keys.countersignatory_htlc_key, &chan_keys.revocation_key);
422+
423+
bumped_tx.lock_time = PackedLockTime(outp.htlc.cltv_expiry); // Right now we don't aggregate time-locked transaction, if we do we should set lock_time before to avoid breaking hash computation
424+
if let Ok(sig) = onchain_handler.signer.sign_counterparty_htlc_transaction(&bumped_tx, i, &outp.htlc.amount_msat / 1000, &outp.per_commitment_point, &outp.htlc, &onchain_handler.secp_ctx) {
425+
let mut ser_sig = sig.serialize_der().to_vec();
426+
ser_sig.push(EcdsaSighashType::All as u8);
427+
bumped_tx.input[i].witness.push(ser_sig);
428+
// Due to BIP146 (MINIMALIF) this must be a zero-length element to relay.
429+
bumped_tx.input[i].witness.push(vec![]);
430+
bumped_tx.input[i].witness.push(witness_script.clone().into_bytes());
435431
}
436432
},
437433
_ => { panic!("API Error!"); }

0 commit comments

Comments
 (0)