mirror of
https://github.com/lightningdevkit/rust-lightning.git
synced 2025-03-15 15:39:09 +01:00
Update to rust-secp256k1 v0.11 and rust-bitcoin v0.14
This commit is contained in:
parent
5ee88ad9f2
commit
11e5975523
14 changed files with 238 additions and 211 deletions
|
@ -23,16 +23,16 @@ max_level_info = []
|
|||
max_level_debug = []
|
||||
|
||||
[dependencies]
|
||||
bitcoin = "0.13"
|
||||
bitcoin = "0.14"
|
||||
rust-crypto = "0.2"
|
||||
rand = "0.4"
|
||||
secp256k1 = "0.9"
|
||||
secp256k1 = "0.11"
|
||||
|
||||
[build-dependencies]
|
||||
cc = "1.0"
|
||||
|
||||
[dev-dependencies.bitcoin]
|
||||
version = "0.13"
|
||||
version = "0.14"
|
||||
features = ["bitcoinconsensus"]
|
||||
|
||||
[dev-dependencies]
|
||||
|
|
|
@ -18,11 +18,11 @@ honggfuzz_fuzz = ["honggfuzz"]
|
|||
[dependencies]
|
||||
afl = { version = "0.4", optional = true }
|
||||
lightning = { path = "..", features = ["fuzztarget"] }
|
||||
bitcoin = { version = "0.13", features = ["fuzztarget"] }
|
||||
bitcoin = { version = "0.14", features = ["fuzztarget"] }
|
||||
hex = "0.3"
|
||||
honggfuzz = { version = "0.5", optional = true }
|
||||
rust-crypto = "0.2"
|
||||
secp256k1 = { version = "0.9", features=["fuzztarget"] }
|
||||
secp256k1 = { version = "0.11", features=["fuzztarget"] }
|
||||
|
||||
[build-dependencies]
|
||||
cc = "1.0"
|
||||
|
|
|
@ -237,7 +237,7 @@ pub fn do_test(data: &[u8], logger: &Arc<Logger>) {
|
|||
let monitor = channelmonitor::SimpleManyChannelMonitor::new(watch.clone(), broadcast.clone());
|
||||
|
||||
let channelmanager = ChannelManager::new(our_network_key, slice_to_be32(get_slice!(4)), get_slice!(1)[0] != 0, Network::Bitcoin, fee_est.clone(), monitor.clone(), watch.clone(), broadcast.clone(), Arc::clone(&logger)).unwrap();
|
||||
let router = Arc::new(Router::new(PublicKey::from_secret_key(&secp_ctx, &our_network_key).unwrap(), Arc::clone(&logger)));
|
||||
let router = Arc::new(Router::new(PublicKey::from_secret_key(&secp_ctx, &our_network_key), Arc::clone(&logger)));
|
||||
|
||||
let peers = RefCell::new([false; 256]);
|
||||
let mut loss_detector = MoneyLossDetector::new(&peers, channelmanager.clone(), monitor.clone(), PeerManager::new(MessageHandler {
|
||||
|
|
|
@ -181,7 +181,7 @@ impl ChainWatchInterfaceUtil {
|
|||
for input in tx.input.iter() {
|
||||
for outpoint in watched.1.iter() {
|
||||
let &(outpoint_hash, outpoint_index) = outpoint;
|
||||
if outpoint_hash == input.prev_hash && outpoint_index == input.prev_index {
|
||||
if outpoint_hash == input.previous_output.txid && outpoint_index == input.previous_output.vout {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,7 +1,8 @@
|
|||
use bitcoin::util::hash::Sha256dHash;
|
||||
use bitcoin::blockdata::transaction::OutPoint as BitcoinOutPoint;
|
||||
|
||||
/// A reference to a transaction output.
|
||||
/// Differs from bitcoin::blockdata::transaction::TxOutRef as the index is a u16 instead of usize
|
||||
/// Differs from bitcoin::blockdata::transaction::OutPoint as the index is a u16 instead of u32
|
||||
/// due to LN's restrictions on index values. Should reduce (possibly) unsafe conversions this way.
|
||||
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
|
||||
pub struct OutPoint {
|
||||
|
@ -25,6 +26,13 @@ impl OutPoint {
|
|||
res[31] ^= ((self.index >> 0) & 0xff) as u8;
|
||||
res
|
||||
}
|
||||
|
||||
pub fn into_bitcoin_outpoint(self) -> BitcoinOutPoint {
|
||||
BitcoinOutPoint {
|
||||
txid: self.txid,
|
||||
vout: self.index as u32,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
use bitcoin::blockdata::script::{Script,Builder};
|
||||
use bitcoin::blockdata::opcodes;
|
||||
use bitcoin::blockdata::transaction::{TxIn,TxOut,Transaction};
|
||||
use bitcoin::blockdata::transaction::{TxIn,TxOut,OutPoint,Transaction};
|
||||
use bitcoin::util::hash::{Hash160,Sha256dHash};
|
||||
|
||||
use secp256k1::key::{PublicKey,SecretKey};
|
||||
|
@ -32,10 +32,10 @@ pub fn build_commitment_secret(commitment_seed: [u8; 32], idx: u64) -> [u8; 32]
|
|||
res
|
||||
}
|
||||
|
||||
pub fn derive_private_key(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey, base_secret: &SecretKey) -> Result<SecretKey, secp256k1::Error> {
|
||||
pub fn derive_private_key<T: secp256k1::Signing>(secp_ctx: &Secp256k1<T>, per_commitment_point: &PublicKey, base_secret: &SecretKey) -> Result<SecretKey, secp256k1::Error> {
|
||||
let mut sha = Sha256::new();
|
||||
sha.input(&per_commitment_point.serialize());
|
||||
sha.input(&PublicKey::from_secret_key(&secp_ctx, &base_secret).unwrap().serialize());
|
||||
sha.input(&PublicKey::from_secret_key(&secp_ctx, &base_secret).serialize());
|
||||
let mut res = [0; 32];
|
||||
sha.result(&mut res);
|
||||
|
||||
|
@ -44,21 +44,21 @@ pub fn derive_private_key(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey
|
|||
Ok(key)
|
||||
}
|
||||
|
||||
pub fn derive_public_key(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey, base_point: &PublicKey) -> Result<PublicKey, secp256k1::Error> {
|
||||
pub fn derive_public_key<T: secp256k1::Signing>(secp_ctx: &Secp256k1<T>, per_commitment_point: &PublicKey, base_point: &PublicKey) -> Result<PublicKey, secp256k1::Error> {
|
||||
let mut sha = Sha256::new();
|
||||
sha.input(&per_commitment_point.serialize());
|
||||
sha.input(&base_point.serialize());
|
||||
let mut res = [0; 32];
|
||||
sha.result(&mut res);
|
||||
|
||||
let hashkey = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &res)?).unwrap();
|
||||
let hashkey = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &res)?);
|
||||
base_point.combine(&secp_ctx, &hashkey)
|
||||
}
|
||||
|
||||
/// Derives a revocation key from its constituent parts
|
||||
pub fn derive_private_revocation_key(secp_ctx: &Secp256k1, per_commitment_secret: &SecretKey, revocation_base_secret: &SecretKey) -> Result<SecretKey, secp256k1::Error> {
|
||||
let revocation_base_point = PublicKey::from_secret_key(&secp_ctx, &revocation_base_secret).unwrap();
|
||||
let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret).unwrap();
|
||||
pub fn derive_private_revocation_key<T: secp256k1::Signing>(secp_ctx: &Secp256k1<T>, per_commitment_secret: &SecretKey, revocation_base_secret: &SecretKey) -> Result<SecretKey, secp256k1::Error> {
|
||||
let revocation_base_point = PublicKey::from_secret_key(&secp_ctx, &revocation_base_secret);
|
||||
let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret);
|
||||
|
||||
let rev_append_commit_hash_key = {
|
||||
let mut sha = Sha256::new();
|
||||
|
@ -87,7 +87,7 @@ pub fn derive_private_revocation_key(secp_ctx: &Secp256k1, per_commitment_secret
|
|||
Ok(part_a)
|
||||
}
|
||||
|
||||
pub fn derive_public_revocation_key(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey, revocation_base_point: &PublicKey) -> Result<PublicKey, secp256k1::Error> {
|
||||
pub fn derive_public_revocation_key<T: secp256k1::Verification>(secp_ctx: &Secp256k1<T>, per_commitment_point: &PublicKey, revocation_base_point: &PublicKey) -> Result<PublicKey, secp256k1::Error> {
|
||||
let rev_append_commit_hash_key = {
|
||||
let mut sha = Sha256::new();
|
||||
sha.input(&revocation_base_point.serialize());
|
||||
|
@ -124,7 +124,7 @@ pub struct TxCreationKeys {
|
|||
}
|
||||
|
||||
impl TxCreationKeys {
|
||||
pub fn new(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey, a_delayed_payment_base: &PublicKey, a_htlc_base: &PublicKey, b_revocation_base: &PublicKey, b_payment_base: &PublicKey, b_htlc_base: &PublicKey) -> Result<TxCreationKeys, secp256k1::Error> {
|
||||
pub fn new<T: secp256k1::Signing + secp256k1::Verification>(secp_ctx: &Secp256k1<T>, per_commitment_point: &PublicKey, a_delayed_payment_base: &PublicKey, a_htlc_base: &PublicKey, b_revocation_base: &PublicKey, b_payment_base: &PublicKey, b_htlc_base: &PublicKey) -> Result<TxCreationKeys, secp256k1::Error> {
|
||||
Ok(TxCreationKeys {
|
||||
per_commitment_point: per_commitment_point.clone(),
|
||||
revocation_key: derive_public_revocation_key(&secp_ctx, &per_commitment_point, &b_revocation_base)?,
|
||||
|
@ -241,8 +241,10 @@ pub fn get_htlc_redeemscript(htlc: &HTLCOutputInCommitment, keys: &TxCreationKey
|
|||
pub fn build_htlc_transaction(prev_hash: &Sha256dHash, feerate_per_kw: u64, to_self_delay: u16, htlc: &HTLCOutputInCommitment, a_delayed_payment_key: &PublicKey, revocation_key: &PublicKey) -> Transaction {
|
||||
let mut txins: Vec<TxIn> = Vec::new();
|
||||
txins.push(TxIn {
|
||||
prev_hash: prev_hash.clone(),
|
||||
prev_index: htlc.transaction_output_index,
|
||||
previous_output: OutPoint {
|
||||
txid: prev_hash.clone(),
|
||||
vout: htlc.transaction_output_index,
|
||||
},
|
||||
script_sig: Script::new(),
|
||||
sequence: 0,
|
||||
witness: Vec::new(),
|
||||
|
|
|
@ -251,7 +251,7 @@ pub struct Channel {
|
|||
channel_id: [u8; 32],
|
||||
channel_state: u32,
|
||||
channel_outbound: bool,
|
||||
secp_ctx: Secp256k1,
|
||||
secp_ctx: Secp256k1<secp256k1::All>,
|
||||
announce_publicly: bool,
|
||||
channel_value_satoshis: u64,
|
||||
|
||||
|
@ -302,12 +302,12 @@ pub struct Channel {
|
|||
their_max_accepted_htlcs: u16,
|
||||
//implied by OUR_MAX_HTLCS: our_max_accepted_htlcs: u16,
|
||||
|
||||
their_funding_pubkey: PublicKey,
|
||||
their_revocation_basepoint: PublicKey,
|
||||
their_payment_basepoint: PublicKey,
|
||||
their_delayed_payment_basepoint: PublicKey,
|
||||
their_htlc_basepoint: PublicKey,
|
||||
their_cur_commitment_point: PublicKey,
|
||||
their_funding_pubkey: Option<PublicKey>,
|
||||
their_revocation_basepoint: Option<PublicKey>,
|
||||
their_payment_basepoint: Option<PublicKey>,
|
||||
their_delayed_payment_basepoint: Option<PublicKey>,
|
||||
their_htlc_basepoint: Option<PublicKey>,
|
||||
their_cur_commitment_point: Option<PublicKey>,
|
||||
|
||||
their_prev_commitment_point: Option<PublicKey>,
|
||||
their_node_id: PublicKey,
|
||||
|
@ -401,10 +401,10 @@ impl Channel {
|
|||
let feerate = fee_estimator.get_est_sat_per_1000_weight(ConfirmationTarget::Normal);
|
||||
|
||||
let secp_ctx = Secp256k1::new();
|
||||
let our_channel_monitor_claim_key_hash = Hash160::from_data(&PublicKey::from_secret_key(&secp_ctx, &chan_keys.channel_monitor_claim_key).unwrap().serialize());
|
||||
let our_channel_monitor_claim_key_hash = Hash160::from_data(&PublicKey::from_secret_key(&secp_ctx, &chan_keys.channel_monitor_claim_key).serialize());
|
||||
let our_channel_monitor_claim_script = Builder::new().push_opcode(opcodes::All::OP_PUSHBYTES_0).push_slice(&our_channel_monitor_claim_key_hash[..]).into_script();
|
||||
let channel_monitor = ChannelMonitor::new(&chan_keys.revocation_base_key,
|
||||
&PublicKey::from_secret_key(&secp_ctx, &chan_keys.delayed_payment_base_key).unwrap(),
|
||||
&PublicKey::from_secret_key(&secp_ctx, &chan_keys.delayed_payment_base_key),
|
||||
&chan_keys.htlc_base_key,
|
||||
BREAKDOWN_TIMEOUT, our_channel_monitor_claim_script);
|
||||
|
||||
|
@ -447,12 +447,12 @@ impl Channel {
|
|||
their_to_self_delay: 0,
|
||||
their_max_accepted_htlcs: 0,
|
||||
|
||||
their_funding_pubkey: PublicKey::new(),
|
||||
their_revocation_basepoint: PublicKey::new(),
|
||||
their_payment_basepoint: PublicKey::new(),
|
||||
their_delayed_payment_basepoint: PublicKey::new(),
|
||||
their_htlc_basepoint: PublicKey::new(),
|
||||
their_cur_commitment_point: PublicKey::new(),
|
||||
their_funding_pubkey: None,
|
||||
their_revocation_basepoint: None,
|
||||
their_payment_basepoint: None,
|
||||
their_delayed_payment_basepoint: None,
|
||||
their_htlc_basepoint: None,
|
||||
their_cur_commitment_point: None,
|
||||
|
||||
their_prev_commitment_point: None,
|
||||
their_node_id: their_node_id,
|
||||
|
@ -557,10 +557,10 @@ impl Channel {
|
|||
}
|
||||
|
||||
let secp_ctx = Secp256k1::new();
|
||||
let our_channel_monitor_claim_key_hash = Hash160::from_data(&PublicKey::from_secret_key(&secp_ctx, &chan_keys.channel_monitor_claim_key).unwrap().serialize());
|
||||
let our_channel_monitor_claim_key_hash = Hash160::from_data(&PublicKey::from_secret_key(&secp_ctx, &chan_keys.channel_monitor_claim_key).serialize());
|
||||
let our_channel_monitor_claim_script = Builder::new().push_opcode(opcodes::All::OP_PUSHBYTES_0).push_slice(&our_channel_monitor_claim_key_hash[..]).into_script();
|
||||
let mut channel_monitor = ChannelMonitor::new(&chan_keys.revocation_base_key,
|
||||
&PublicKey::from_secret_key(&secp_ctx, &chan_keys.delayed_payment_base_key).unwrap(),
|
||||
&PublicKey::from_secret_key(&secp_ctx, &chan_keys.delayed_payment_base_key),
|
||||
&chan_keys.htlc_base_key,
|
||||
BREAKDOWN_TIMEOUT, our_channel_monitor_claim_script);
|
||||
channel_monitor.set_their_htlc_base_key(&msg.htlc_basepoint);
|
||||
|
@ -605,12 +605,12 @@ impl Channel {
|
|||
their_to_self_delay: msg.to_self_delay,
|
||||
their_max_accepted_htlcs: msg.max_accepted_htlcs,
|
||||
|
||||
their_funding_pubkey: msg.funding_pubkey,
|
||||
their_revocation_basepoint: msg.revocation_basepoint,
|
||||
their_payment_basepoint: msg.payment_basepoint,
|
||||
their_delayed_payment_basepoint: msg.delayed_payment_basepoint,
|
||||
their_htlc_basepoint: msg.htlc_basepoint,
|
||||
their_cur_commitment_point: msg.first_per_commitment_point,
|
||||
their_funding_pubkey: Some(msg.funding_pubkey),
|
||||
their_revocation_basepoint: Some(msg.revocation_basepoint),
|
||||
their_payment_basepoint: Some(msg.payment_basepoint),
|
||||
their_delayed_payment_basepoint: Some(msg.delayed_payment_basepoint),
|
||||
their_htlc_basepoint: Some(msg.htlc_basepoint),
|
||||
their_cur_commitment_point: Some(msg.first_per_commitment_point),
|
||||
|
||||
their_prev_commitment_point: None,
|
||||
their_node_id: their_node_id,
|
||||
|
@ -639,13 +639,13 @@ impl Channel {
|
|||
|
||||
fn get_commitment_transaction_number_obscure_factor(&self) -> u64 {
|
||||
let mut sha = Sha256::new();
|
||||
let our_payment_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key).unwrap();
|
||||
let our_payment_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key);
|
||||
|
||||
if self.channel_outbound {
|
||||
sha.input(&our_payment_basepoint.serialize());
|
||||
sha.input(&self.their_payment_basepoint.serialize());
|
||||
sha.input(&self.their_payment_basepoint.unwrap().serialize());
|
||||
} else {
|
||||
sha.input(&self.their_payment_basepoint.serialize());
|
||||
sha.input(&self.their_payment_basepoint.unwrap().serialize());
|
||||
sha.input(&our_payment_basepoint.serialize());
|
||||
}
|
||||
let mut res = [0; 32];
|
||||
|
@ -679,8 +679,7 @@ impl Channel {
|
|||
let txins = {
|
||||
let mut ins: Vec<TxIn> = Vec::new();
|
||||
ins.push(TxIn {
|
||||
prev_hash: self.channel_monitor.get_funding_txo().unwrap().txid,
|
||||
prev_index: self.channel_monitor.get_funding_txo().unwrap().index as u32,
|
||||
previous_output: self.channel_monitor.get_funding_txo().unwrap().into_bitcoin_outpoint(),
|
||||
script_sig: Script::new(),
|
||||
sequence: ((0x80 as u32) << 8*3) | ((obscured_commitment_transaction_number >> 3*8) as u32),
|
||||
witness: Vec::new(),
|
||||
|
@ -805,7 +804,7 @@ impl Channel {
|
|||
|
||||
#[inline]
|
||||
fn get_closing_scriptpubkey(&self) -> Script {
|
||||
let our_channel_close_key_hash = Hash160::from_data(&PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.channel_close_key).unwrap().serialize());
|
||||
let our_channel_close_key_hash = Hash160::from_data(&PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.channel_close_key).serialize());
|
||||
Builder::new().push_opcode(opcodes::All::OP_PUSHBYTES_0).push_slice(&our_channel_close_key_hash[..]).into_script()
|
||||
}
|
||||
|
||||
|
@ -819,8 +818,7 @@ impl Channel {
|
|||
let txins = {
|
||||
let mut ins: Vec<TxIn> = Vec::new();
|
||||
ins.push(TxIn {
|
||||
prev_hash: self.channel_monitor.get_funding_txo().unwrap().txid,
|
||||
prev_index: self.channel_monitor.get_funding_txo().unwrap().index as u32,
|
||||
previous_output: self.channel_monitor.get_funding_txo().unwrap().into_bitcoin_outpoint(),
|
||||
script_sig: Script::new(),
|
||||
sequence: 0xffffffff,
|
||||
witness: Vec::new(),
|
||||
|
@ -879,11 +877,11 @@ impl Channel {
|
|||
/// The result is a transaction which we can revoke ownership of (ie a "local" transaction)
|
||||
/// TODO Some magic rust shit to compile-time check this?
|
||||
fn build_local_transaction_keys(&self, commitment_number: u64) -> Result<TxCreationKeys, HandleError> {
|
||||
let per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &self.build_local_commitment_secret(commitment_number)).unwrap();
|
||||
let delayed_payment_base = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.delayed_payment_base_key).unwrap();
|
||||
let htlc_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key).unwrap();
|
||||
let per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &self.build_local_commitment_secret(commitment_number));
|
||||
let delayed_payment_base = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.delayed_payment_base_key);
|
||||
let htlc_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key);
|
||||
|
||||
Ok(secp_derived_key!(TxCreationKeys::new(&self.secp_ctx, &per_commitment_point, &delayed_payment_base, &htlc_basepoint, &self.their_revocation_basepoint, &self.their_payment_basepoint, &self.their_htlc_basepoint)))
|
||||
Ok(secp_derived_key!(TxCreationKeys::new(&self.secp_ctx, &per_commitment_point, &delayed_payment_base, &htlc_basepoint, &self.their_revocation_basepoint.unwrap(), &self.their_payment_basepoint.unwrap(), &self.their_htlc_basepoint.unwrap())))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
@ -892,19 +890,19 @@ impl Channel {
|
|||
fn build_remote_transaction_keys(&self) -> Result<TxCreationKeys, HandleError> {
|
||||
//TODO: Ensure that the payment_key derived here ends up in the library users' wallet as we
|
||||
//may see payments to it!
|
||||
let payment_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key).unwrap();
|
||||
let revocation_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.revocation_base_key).unwrap();
|
||||
let htlc_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key).unwrap();
|
||||
let payment_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key);
|
||||
let revocation_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.revocation_base_key);
|
||||
let htlc_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key);
|
||||
|
||||
Ok(secp_derived_key!(TxCreationKeys::new(&self.secp_ctx, &self.their_cur_commitment_point, &self.their_delayed_payment_basepoint, &self.their_htlc_basepoint, &revocation_basepoint, &payment_basepoint, &htlc_basepoint)))
|
||||
Ok(secp_derived_key!(TxCreationKeys::new(&self.secp_ctx, &self.their_cur_commitment_point.unwrap(), &self.their_delayed_payment_basepoint.unwrap(), &self.their_htlc_basepoint.unwrap(), &revocation_basepoint, &payment_basepoint, &htlc_basepoint)))
|
||||
}
|
||||
|
||||
/// Gets the redeemscript for the funding transaction output (ie the funding transaction output
|
||||
/// pays to get_funding_redeemscript().to_v0_p2wsh()).
|
||||
pub fn get_funding_redeemscript(&self) -> Script {
|
||||
let builder = Builder::new().push_opcode(opcodes::All::OP_PUSHNUM_2);
|
||||
let our_funding_key = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key).unwrap().serialize();
|
||||
let their_funding_key = self.their_funding_pubkey.serialize();
|
||||
let our_funding_key = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key).serialize();
|
||||
let their_funding_key = self.their_funding_pubkey.unwrap().serialize();
|
||||
if our_funding_key[..] < their_funding_key[..] {
|
||||
builder.push_slice(&our_funding_key)
|
||||
.push_slice(&their_funding_key)
|
||||
|
@ -925,12 +923,12 @@ impl Channel {
|
|||
let funding_redeemscript = self.get_funding_redeemscript();
|
||||
|
||||
let sighash = Message::from_slice(&bip143::SighashComponents::new(&tx).sighash_all(&tx.input[0], &funding_redeemscript, self.channel_value_satoshis)[..]).unwrap();
|
||||
let our_sig = self.secp_ctx.sign(&sighash, &self.local_keys.funding_key).unwrap();
|
||||
let our_sig = self.secp_ctx.sign(&sighash, &self.local_keys.funding_key);
|
||||
|
||||
tx.input[0].witness.push(Vec::new()); // First is the multisig dummy
|
||||
|
||||
let our_funding_key = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key).unwrap().serialize();
|
||||
let their_funding_key = self.their_funding_pubkey.serialize();
|
||||
let our_funding_key = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key).serialize();
|
||||
let their_funding_key = self.their_funding_pubkey.unwrap().serialize();
|
||||
if our_funding_key[..] < their_funding_key[..] {
|
||||
tx.input[0].witness.push(our_sig.serialize_der(&self.secp_ctx).to_vec());
|
||||
tx.input[0].witness.push(their_sig.serialize_der(&self.secp_ctx).to_vec());
|
||||
|
@ -941,7 +939,7 @@ impl Channel {
|
|||
tx.input[0].witness[1].push(SigHashType::All as u8);
|
||||
tx.input[0].witness[2].push(SigHashType::All as u8);
|
||||
|
||||
tx.input[0].witness.push(funding_redeemscript.into_vec());
|
||||
tx.input[0].witness.push(funding_redeemscript.into_bytes());
|
||||
|
||||
our_sig
|
||||
}
|
||||
|
@ -962,8 +960,8 @@ impl Channel {
|
|||
|
||||
let our_htlc_key = secp_derived_key!(chan_utils::derive_private_key(&self.secp_ctx, &keys.per_commitment_point, &self.local_keys.htlc_base_key));
|
||||
let sighash = Message::from_slice(&bip143::SighashComponents::new(&tx).sighash_all(&tx.input[0], &htlc_redeemscript, htlc.amount_msat / 1000)[..]).unwrap();
|
||||
let is_local_tx = PublicKey::from_secret_key(&self.secp_ctx, &our_htlc_key).unwrap() == keys.a_htlc_key;
|
||||
Ok((htlc_redeemscript, self.secp_ctx.sign(&sighash, &our_htlc_key).unwrap(), is_local_tx))
|
||||
let is_local_tx = PublicKey::from_secret_key(&self.secp_ctx, &our_htlc_key) == keys.a_htlc_key;
|
||||
Ok((htlc_redeemscript, self.secp_ctx.sign(&sighash, &our_htlc_key), is_local_tx))
|
||||
}
|
||||
|
||||
/// Signs a transaction created by build_htlc_transaction. If the transaction is an
|
||||
|
@ -996,7 +994,7 @@ impl Channel {
|
|||
tx.input[0].witness.push(preimage.unwrap().to_vec());
|
||||
}
|
||||
|
||||
tx.input[0].witness.push(htlc_redeemscript.into_vec());
|
||||
tx.input[0].witness.push(htlc_redeemscript.into_bytes());
|
||||
|
||||
Ok(our_sig)
|
||||
}
|
||||
|
@ -1230,12 +1228,12 @@ impl Channel {
|
|||
self.their_htlc_minimum_msat = msg.htlc_minimum_msat;
|
||||
self.their_to_self_delay = msg.to_self_delay;
|
||||
self.their_max_accepted_htlcs = msg.max_accepted_htlcs;
|
||||
self.their_funding_pubkey = msg.funding_pubkey;
|
||||
self.their_revocation_basepoint = msg.revocation_basepoint;
|
||||
self.their_payment_basepoint = msg.payment_basepoint;
|
||||
self.their_delayed_payment_basepoint = msg.delayed_payment_basepoint;
|
||||
self.their_htlc_basepoint = msg.htlc_basepoint;
|
||||
self.their_cur_commitment_point = msg.first_per_commitment_point;
|
||||
self.their_funding_pubkey = Some(msg.funding_pubkey);
|
||||
self.their_revocation_basepoint = Some(msg.revocation_basepoint);
|
||||
self.their_payment_basepoint = Some(msg.payment_basepoint);
|
||||
self.their_delayed_payment_basepoint = Some(msg.delayed_payment_basepoint);
|
||||
self.their_htlc_basepoint = Some(msg.htlc_basepoint);
|
||||
self.their_cur_commitment_point = Some(msg.first_per_commitment_point);
|
||||
|
||||
let obscure_factor = self.get_commitment_transaction_number_obscure_factor();
|
||||
self.channel_monitor.set_commitment_obscure_factor(obscure_factor);
|
||||
|
@ -1258,10 +1256,10 @@ impl Channel {
|
|||
let local_sighash = Message::from_slice(&bip143::SighashComponents::new(&local_initial_commitment_tx).sighash_all(&local_initial_commitment_tx.input[0], &funding_script, self.channel_value_satoshis)[..]).unwrap();
|
||||
|
||||
// They sign the "local" commitment transaction, allowing us to broadcast the tx if we wish.
|
||||
secp_call!(self.secp_ctx.verify(&local_sighash, &sig, &self.their_funding_pubkey), "Invalid funding_created signature from peer");
|
||||
secp_call!(self.secp_ctx.verify(&local_sighash, &sig, &self.their_funding_pubkey.unwrap()), "Invalid funding_created signature from peer");
|
||||
|
||||
// We sign the "remote" commitment transaction, allowing them to broadcast the tx if they wish.
|
||||
Ok((remote_initial_commitment_tx, self.secp_ctx.sign(&remote_sighash, &self.local_keys.funding_key).unwrap()))
|
||||
Ok((remote_initial_commitment_tx, self.secp_ctx.sign(&remote_sighash, &self.local_keys.funding_key)))
|
||||
}
|
||||
|
||||
pub fn funding_created(&mut self, msg: &msgs::FundingCreated) -> Result<(msgs::FundingSigned, ChannelMonitor), HandleError> {
|
||||
|
@ -1321,7 +1319,7 @@ impl Channel {
|
|||
let local_sighash = Message::from_slice(&bip143::SighashComponents::new(&local_initial_commitment_tx).sighash_all(&local_initial_commitment_tx.input[0], &funding_script, self.channel_value_satoshis)[..]).unwrap();
|
||||
|
||||
// They sign the "local" commitment transaction, allowing us to broadcast the tx if we wish.
|
||||
secp_call!(self.secp_ctx.verify(&local_sighash, &msg.signature, &self.their_funding_pubkey), "Invalid funding_signed signature from peer");
|
||||
secp_call!(self.secp_ctx.verify(&local_sighash, &msg.signature, &self.their_funding_pubkey.unwrap()), "Invalid funding_signed signature from peer");
|
||||
|
||||
self.sign_commitment_transaction(&mut local_initial_commitment_tx, &msg.signature);
|
||||
self.channel_monitor.provide_latest_local_commitment_tx_info(local_initial_commitment_tx.clone(), local_keys, self.feerate_per_kw, Vec::new());
|
||||
|
@ -1343,8 +1341,8 @@ impl Channel {
|
|||
return Err(HandleError{err: "Peer sent a funding_locked at a strange time", action: None});
|
||||
}
|
||||
|
||||
self.their_prev_commitment_point = Some(self.their_cur_commitment_point);
|
||||
self.their_cur_commitment_point = msg.next_per_commitment_point;
|
||||
self.their_prev_commitment_point = self.their_cur_commitment_point;
|
||||
self.their_cur_commitment_point = Some(msg.next_per_commitment_point);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
@ -1505,7 +1503,7 @@ impl Channel {
|
|||
let mut local_commitment_tx = self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false);
|
||||
let local_commitment_txid = local_commitment_tx.0.txid();
|
||||
let local_sighash = Message::from_slice(&bip143::SighashComponents::new(&local_commitment_tx.0).sighash_all(&local_commitment_tx.0.input[0], &funding_script, self.channel_value_satoshis)[..]).unwrap();
|
||||
secp_call!(self.secp_ctx.verify(&local_sighash, &msg.signature, &self.their_funding_pubkey), "Invalid commitment tx signature from peer");
|
||||
secp_call!(self.secp_ctx.verify(&local_sighash, &msg.signature, &self.their_funding_pubkey.unwrap()), "Invalid commitment tx signature from peer");
|
||||
|
||||
if msg.htlc_signatures.len() != local_commitment_tx.1.len() {
|
||||
return Err(HandleError{err: "Got wrong number of HTLC signatures from remote", action: None});
|
||||
|
@ -1531,7 +1529,7 @@ impl Channel {
|
|||
htlcs_and_sigs.push(((*htlc).clone(), msg.htlc_signatures[idx], htlc_sig));
|
||||
}
|
||||
|
||||
let next_per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &self.build_local_commitment_secret(self.cur_local_commitment_transaction_number - 1)).unwrap();
|
||||
let next_per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &self.build_local_commitment_secret(self.cur_local_commitment_transaction_number - 1));
|
||||
let per_commitment_secret = chan_utils::build_commitment_secret(self.local_keys.commitment_seed, self.cur_local_commitment_transaction_number + 1);
|
||||
|
||||
// Update state now that we've passed all the can-fail calls...
|
||||
|
@ -1655,7 +1653,7 @@ impl Channel {
|
|||
return Err(HandleError{err: "Got revoke/ACK message when channel was not in an operational state", action: None});
|
||||
}
|
||||
if let Some(their_prev_commitment_point) = self.their_prev_commitment_point {
|
||||
if PublicKey::from_secret_key(&self.secp_ctx, &secp_call!(SecretKey::from_slice(&self.secp_ctx, &msg.per_commitment_secret), "Peer provided an invalid per_commitment_secret")).unwrap() != their_prev_commitment_point {
|
||||
if PublicKey::from_secret_key(&self.secp_ctx, &secp_call!(SecretKey::from_slice(&self.secp_ctx, &msg.per_commitment_secret), "Peer provided an invalid per_commitment_secret")) != their_prev_commitment_point {
|
||||
return Err(HandleError{err: "Got a revoke commitment secret which didn't correspond to their current pubkey", action: None});
|
||||
}
|
||||
}
|
||||
|
@ -1666,8 +1664,8 @@ impl Channel {
|
|||
// OK, we step the channel here and *then* if the new generation fails we can fail the
|
||||
// channel based on that, but stepping stuff here should be safe either way.
|
||||
self.channel_state &= !(ChannelState::AwaitingRemoteRevoke as u32);
|
||||
self.their_prev_commitment_point = Some(self.their_cur_commitment_point);
|
||||
self.their_cur_commitment_point = msg.next_per_commitment_point;
|
||||
self.their_prev_commitment_point = self.their_cur_commitment_point;
|
||||
self.their_cur_commitment_point = Some(msg.next_per_commitment_point);
|
||||
self.cur_remote_commitment_transaction_number -= 1;
|
||||
|
||||
let mut to_forward_infos = Vec::new();
|
||||
|
@ -1782,7 +1780,7 @@ impl Channel {
|
|||
let funding_redeemscript = self.get_funding_redeemscript();
|
||||
let sighash = Message::from_slice(&bip143::SighashComponents::new(&closing_tx).sighash_all(&closing_tx.input[0], &funding_redeemscript, self.channel_value_satoshis)[..]).unwrap();
|
||||
|
||||
(Some(proposed_feerate), Some(total_fee_satoshis), Some(self.secp_ctx.sign(&sighash, &self.local_keys.funding_key).unwrap()))
|
||||
(Some(proposed_feerate), Some(total_fee_satoshis), Some(self.secp_ctx.sign(&sighash, &self.local_keys.funding_key)))
|
||||
} else { (None, None, None) };
|
||||
|
||||
// From here on out, we may not fail!
|
||||
|
@ -1852,14 +1850,14 @@ impl Channel {
|
|||
}
|
||||
let mut sighash = Message::from_slice(&bip143::SighashComponents::new(&closing_tx).sighash_all(&closing_tx.input[0], &funding_redeemscript, self.channel_value_satoshis)[..]).unwrap();
|
||||
|
||||
match self.secp_ctx.verify(&sighash, &msg.signature, &self.their_funding_pubkey) {
|
||||
match self.secp_ctx.verify(&sighash, &msg.signature, &self.their_funding_pubkey.unwrap()) {
|
||||
Ok(_) => {},
|
||||
Err(_e) => {
|
||||
// The remote end may have decided to revoke their output due to inconsistent dust
|
||||
// limits, so check for that case by re-checking the signature here.
|
||||
closing_tx = self.build_closing_transaction(msg.fee_satoshis, true).0;
|
||||
sighash = Message::from_slice(&bip143::SighashComponents::new(&closing_tx).sighash_all(&closing_tx.input[0], &funding_redeemscript, self.channel_value_satoshis)[..]).unwrap();
|
||||
secp_call!(self.secp_ctx.verify(&sighash, &msg.signature, &self.their_funding_pubkey), "Invalid closing tx signature from peer");
|
||||
secp_call!(self.secp_ctx.verify(&sighash, &msg.signature, &self.their_funding_pubkey.unwrap()), "Invalid closing tx signature from peer");
|
||||
},
|
||||
};
|
||||
|
||||
|
@ -1877,7 +1875,7 @@ impl Channel {
|
|||
let closing_tx_max_weight = Self::get_closing_transaction_weight(&self.get_closing_scriptpubkey(), self.their_shutdown_scriptpubkey.as_ref().unwrap());
|
||||
let (closing_tx, used_total_fee) = self.build_closing_transaction($new_feerate * closing_tx_max_weight / 1000, false);
|
||||
sighash = Message::from_slice(&bip143::SighashComponents::new(&closing_tx).sighash_all(&closing_tx.input[0], &funding_redeemscript, self.channel_value_satoshis)[..]).unwrap();
|
||||
let our_sig = self.secp_ctx.sign(&sighash, &self.local_keys.funding_key).unwrap();
|
||||
let our_sig = self.secp_ctx.sign(&sighash, &self.local_keys.funding_key);
|
||||
self.last_sent_closing_fee = Some(($new_feerate, used_total_fee));
|
||||
return Ok((Some(msgs::ClosingSigned {
|
||||
channel_id: self.channel_id,
|
||||
|
@ -2065,7 +2063,7 @@ impl Channel {
|
|||
//a protocol oversight, but I assume I'm just missing something.
|
||||
if need_commitment_update {
|
||||
let next_per_commitment_secret = self.build_local_commitment_secret(self.cur_local_commitment_transaction_number);
|
||||
let next_per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &next_per_commitment_secret).unwrap();
|
||||
let next_per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &next_per_commitment_secret);
|
||||
return Ok(Some(msgs::FundingLocked {
|
||||
channel_id: self.channel_id,
|
||||
next_per_commitment_point: next_per_commitment_point,
|
||||
|
@ -2140,12 +2138,12 @@ impl Channel {
|
|||
feerate_per_kw: fee_estimator.get_est_sat_per_1000_weight(ConfirmationTarget::Background) as u32,
|
||||
to_self_delay: BREAKDOWN_TIMEOUT,
|
||||
max_accepted_htlcs: OUR_MAX_HTLCS,
|
||||
funding_pubkey: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key).unwrap(),
|
||||
revocation_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.revocation_base_key).unwrap(),
|
||||
payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key).unwrap(),
|
||||
delayed_payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.delayed_payment_base_key).unwrap(),
|
||||
htlc_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key).unwrap(),
|
||||
first_per_commitment_point: PublicKey::from_secret_key(&self.secp_ctx, &local_commitment_secret).unwrap(),
|
||||
funding_pubkey: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key),
|
||||
revocation_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.revocation_base_key),
|
||||
payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key),
|
||||
delayed_payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.delayed_payment_base_key),
|
||||
htlc_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key),
|
||||
first_per_commitment_point: PublicKey::from_secret_key(&self.secp_ctx, &local_commitment_secret),
|
||||
channel_flags: if self.announce_publicly {1} else {0},
|
||||
shutdown_scriptpubkey: None,
|
||||
})
|
||||
|
@ -2173,12 +2171,12 @@ impl Channel {
|
|||
minimum_depth: Channel::derive_minimum_depth(self.channel_value_satoshis*1000, self.value_to_self_msat),
|
||||
to_self_delay: BREAKDOWN_TIMEOUT,
|
||||
max_accepted_htlcs: OUR_MAX_HTLCS,
|
||||
funding_pubkey: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key).unwrap(),
|
||||
revocation_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.revocation_base_key).unwrap(),
|
||||
payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key).unwrap(),
|
||||
delayed_payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.delayed_payment_base_key).unwrap(),
|
||||
htlc_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key).unwrap(),
|
||||
first_per_commitment_point: PublicKey::from_secret_key(&self.secp_ctx, &local_commitment_secret).unwrap(),
|
||||
funding_pubkey: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key),
|
||||
revocation_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.revocation_base_key),
|
||||
payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key),
|
||||
delayed_payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.delayed_payment_base_key),
|
||||
htlc_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key),
|
||||
first_per_commitment_point: PublicKey::from_secret_key(&self.secp_ctx, &local_commitment_secret),
|
||||
shutdown_scriptpubkey: None,
|
||||
})
|
||||
}
|
||||
|
@ -2191,7 +2189,7 @@ impl Channel {
|
|||
let remote_sighash = Message::from_slice(&bip143::SighashComponents::new(&remote_initial_commitment_tx).sighash_all(&remote_initial_commitment_tx.input[0], &funding_script, self.channel_value_satoshis)[..]).unwrap();
|
||||
|
||||
// We sign the "remote" commitment transaction, allowing them to broadcast the tx if they wish.
|
||||
Ok((self.secp_ctx.sign(&remote_sighash, &self.local_keys.funding_key).unwrap(), remote_initial_commitment_tx))
|
||||
Ok((self.secp_ctx.sign(&remote_sighash, &self.local_keys.funding_key), remote_initial_commitment_tx))
|
||||
}
|
||||
|
||||
/// Updates channel state with knowledge of the funding transaction's txid/index, and generates
|
||||
|
@ -2255,7 +2253,7 @@ impl Channel {
|
|||
}
|
||||
|
||||
let were_node_one = our_node_id.serialize()[..] < self.their_node_id.serialize()[..];
|
||||
let our_bitcoin_key = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key).unwrap();
|
||||
let our_bitcoin_key = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key);
|
||||
|
||||
let msg = msgs::UnsignedChannelAnnouncement {
|
||||
features: msgs::GlobalFeatures::new(),
|
||||
|
@ -2263,12 +2261,12 @@ impl Channel {
|
|||
short_channel_id: self.get_short_channel_id().unwrap(),
|
||||
node_id_1: if were_node_one { our_node_id } else { self.get_their_node_id() },
|
||||
node_id_2: if were_node_one { self.get_their_node_id() } else { our_node_id },
|
||||
bitcoin_key_1: if were_node_one { our_bitcoin_key } else { self.their_funding_pubkey },
|
||||
bitcoin_key_2: if were_node_one { self.their_funding_pubkey } else { our_bitcoin_key },
|
||||
bitcoin_key_1: if were_node_one { our_bitcoin_key } else { self.their_funding_pubkey.unwrap() },
|
||||
bitcoin_key_2: if were_node_one { self.their_funding_pubkey.unwrap() } else { our_bitcoin_key },
|
||||
};
|
||||
|
||||
let msghash = Message::from_slice(&Sha256dHash::from_data(&msg.encode()[..])[..]).unwrap();
|
||||
let sig = self.secp_ctx.sign(&msghash, &self.local_keys.funding_key).unwrap();
|
||||
let sig = self.secp_ctx.sign(&msghash, &self.local_keys.funding_key);
|
||||
|
||||
Ok((msg, sig))
|
||||
}
|
||||
|
@ -2386,7 +2384,7 @@ impl Channel {
|
|||
let remote_commitment_tx = self.build_commitment_transaction(self.cur_remote_commitment_transaction_number, &remote_keys, false, true);
|
||||
let remote_commitment_txid = remote_commitment_tx.0.txid();
|
||||
let remote_sighash = Message::from_slice(&bip143::SighashComponents::new(&remote_commitment_tx.0).sighash_all(&remote_commitment_tx.0.input[0], &funding_script, self.channel_value_satoshis)[..]).unwrap();
|
||||
let our_sig = self.secp_ctx.sign(&remote_sighash, &self.local_keys.funding_key).unwrap();
|
||||
let our_sig = self.secp_ctx.sign(&remote_sighash, &self.local_keys.funding_key);
|
||||
|
||||
let mut htlc_sigs = Vec::new();
|
||||
|
||||
|
@ -2395,7 +2393,7 @@ impl Channel {
|
|||
let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, &remote_keys);
|
||||
let htlc_sighash = Message::from_slice(&bip143::SighashComponents::new(&htlc_tx).sighash_all(&htlc_tx.input[0], &htlc_redeemscript, htlc.amount_msat / 1000)[..]).unwrap();
|
||||
let our_htlc_key = secp_derived_key!(chan_utils::derive_private_key(&self.secp_ctx, &remote_keys.per_commitment_point, &self.local_keys.htlc_base_key));
|
||||
htlc_sigs.push(self.secp_ctx.sign(&htlc_sighash, &our_htlc_key).unwrap());
|
||||
htlc_sigs.push(self.secp_ctx.sign(&htlc_sighash, &our_htlc_key));
|
||||
}
|
||||
|
||||
// Update state now that we've passed all the can-fail calls...
|
||||
|
@ -2558,38 +2556,39 @@ mod tests {
|
|||
channel_monitor_claim_key: SecretKey::from_slice(&secp_ctx, &hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap(),
|
||||
commitment_seed: [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff],
|
||||
};
|
||||
assert_eq!(PublicKey::from_secret_key(&secp_ctx, &chan_keys.funding_key).unwrap().serialize()[..],
|
||||
assert_eq!(PublicKey::from_secret_key(&secp_ctx, &chan_keys.funding_key).serialize()[..],
|
||||
hex::decode("023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb").unwrap()[..]);
|
||||
|
||||
let mut chan = Channel::new_outbound(&feeest, chan_keys, PublicKey::new(), 10000000, 100000, false, 42, Arc::clone(&logger)).unwrap(); // Nothing uses their network key in this test
|
||||
let their_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap());
|
||||
let mut chan = Channel::new_outbound(&feeest, chan_keys, their_node_id, 10000000, 100000, false, 42, Arc::clone(&logger)).unwrap(); // Nothing uses their network key in this test
|
||||
chan.their_to_self_delay = 144;
|
||||
chan.our_dust_limit_satoshis = 546;
|
||||
|
||||
let funding_info = OutPoint::new(Sha256dHash::from_hex("8984484a580b825b9972d7adb15050b3ab624ccd731946b3eeddb92f4e7ef6be").unwrap(), 0);
|
||||
chan.channel_monitor.set_funding_info((funding_info, Script::new()));
|
||||
|
||||
chan.their_payment_basepoint = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("4444444444444444444444444444444444444444444444444444444444444444").unwrap()[..]).unwrap()).unwrap();
|
||||
assert_eq!(chan.their_payment_basepoint.serialize()[..],
|
||||
chan.their_payment_basepoint = Some(PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("4444444444444444444444444444444444444444444444444444444444444444").unwrap()[..]).unwrap()));
|
||||
assert_eq!(chan.their_payment_basepoint.unwrap().serialize()[..],
|
||||
hex::decode("032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991").unwrap()[..]);
|
||||
|
||||
chan.their_funding_pubkey = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("1552dfba4f6cf29a62a0af13c8d6981d36d0ef8d61ba10fb0fe90da7634d7e13").unwrap()[..]).unwrap()).unwrap();
|
||||
assert_eq!(chan.their_funding_pubkey.serialize()[..],
|
||||
chan.their_funding_pubkey = Some(PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("1552dfba4f6cf29a62a0af13c8d6981d36d0ef8d61ba10fb0fe90da7634d7e13").unwrap()[..]).unwrap()));
|
||||
assert_eq!(chan.their_funding_pubkey.unwrap().serialize()[..],
|
||||
hex::decode("030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c1").unwrap()[..]);
|
||||
|
||||
chan.their_htlc_basepoint = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("4444444444444444444444444444444444444444444444444444444444444444").unwrap()[..]).unwrap()).unwrap();
|
||||
assert_eq!(chan.their_htlc_basepoint.serialize()[..],
|
||||
chan.their_htlc_basepoint = Some(PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("4444444444444444444444444444444444444444444444444444444444444444").unwrap()[..]).unwrap()));
|
||||
assert_eq!(chan.their_htlc_basepoint.unwrap().serialize()[..],
|
||||
hex::decode("032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991").unwrap()[..]);
|
||||
|
||||
chan.their_revocation_basepoint = PublicKey::from_slice(&secp_ctx, &hex::decode("02466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27").unwrap()[..]).unwrap();
|
||||
chan.their_revocation_basepoint = Some(PublicKey::from_slice(&secp_ctx, &hex::decode("02466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27").unwrap()[..]).unwrap());
|
||||
|
||||
// We can't just use build_local_transaction_keys here as the per_commitment_secret is not
|
||||
// derived from a commitment_seed, so instead we copy it here and call
|
||||
// build_commitment_transaction.
|
||||
let delayed_payment_base = PublicKey::from_secret_key(&secp_ctx, &chan.local_keys.delayed_payment_base_key).unwrap();
|
||||
let delayed_payment_base = PublicKey::from_secret_key(&secp_ctx, &chan.local_keys.delayed_payment_base_key);
|
||||
let per_commitment_secret = SecretKey::from_slice(&secp_ctx, &hex::decode("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100").unwrap()[..]).unwrap();
|
||||
let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret).unwrap();
|
||||
let htlc_basepoint = PublicKey::from_secret_key(&secp_ctx, &chan.local_keys.htlc_base_key).unwrap();
|
||||
let keys = TxCreationKeys::new(&secp_ctx, &per_commitment_point, &delayed_payment_base, &htlc_basepoint, &chan.their_revocation_basepoint, &chan.their_payment_basepoint, &chan.their_htlc_basepoint).unwrap();
|
||||
let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret);
|
||||
let htlc_basepoint = PublicKey::from_secret_key(&secp_ctx, &chan.local_keys.htlc_base_key);
|
||||
let keys = TxCreationKeys::new(&secp_ctx, &per_commitment_point, &delayed_payment_base, &htlc_basepoint, &chan.their_revocation_basepoint.unwrap(), &chan.their_payment_basepoint.unwrap(), &chan.their_htlc_basepoint.unwrap()).unwrap();
|
||||
|
||||
let mut unsigned_tx: (Transaction, Vec<HTLCOutputInCommitment>);
|
||||
|
||||
|
@ -2598,7 +2597,7 @@ mod tests {
|
|||
unsigned_tx = chan.build_commitment_transaction(0xffffffffffff - 42, &keys, true, false);
|
||||
let their_signature = Signature::from_der(&secp_ctx, &hex::decode($their_sig_hex).unwrap()[..]).unwrap();
|
||||
let sighash = Message::from_slice(&bip143::SighashComponents::new(&unsigned_tx.0).sighash_all(&unsigned_tx.0.input[0], &chan.get_funding_redeemscript(), chan.channel_value_satoshis)[..]).unwrap();
|
||||
secp_ctx.verify(&sighash, &their_signature, &chan.their_funding_pubkey).unwrap();
|
||||
secp_ctx.verify(&sighash, &their_signature, &chan.their_funding_pubkey.unwrap()).unwrap();
|
||||
|
||||
chan.sign_commitment_transaction(&mut unsigned_tx.0, &their_signature);
|
||||
|
||||
|
@ -3086,10 +3085,10 @@ mod tests {
|
|||
let base_secret = SecretKey::from_slice(&secp_ctx, &hex::decode("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f").unwrap()[..]).unwrap();
|
||||
let per_commitment_secret = SecretKey::from_slice(&secp_ctx, &hex::decode("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100").unwrap()[..]).unwrap();
|
||||
|
||||
let base_point = PublicKey::from_secret_key(&secp_ctx, &base_secret).unwrap();
|
||||
let base_point = PublicKey::from_secret_key(&secp_ctx, &base_secret);
|
||||
assert_eq!(base_point.serialize()[..], hex::decode("036d6caac248af96f6afa7f904f550253a0f3ef3f5aa2fe6838a95b216691468e2").unwrap()[..]);
|
||||
|
||||
let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret).unwrap();
|
||||
let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret);
|
||||
assert_eq!(per_commitment_point.serialize()[..], hex::decode("025f7117a78150fe2ef97db7cfc83bd57b2e2c0d0dd25eaf467a4a1c2a45ce1486").unwrap()[..]);
|
||||
|
||||
assert_eq!(chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &base_point).unwrap().serialize()[..],
|
||||
|
|
|
@ -162,7 +162,7 @@ pub struct ChannelManager {
|
|||
announce_channels_publicly: bool,
|
||||
fee_proportional_millionths: u32,
|
||||
latest_block_height: AtomicUsize,
|
||||
secp_ctx: Secp256k1,
|
||||
secp_ctx: Secp256k1<secp256k1::All>,
|
||||
|
||||
channel_state: Mutex<ChannelHolder>,
|
||||
our_network_key: SecretKey,
|
||||
|
@ -461,9 +461,9 @@ impl ChannelManager {
|
|||
|
||||
// can only fail if an intermediary hop has an invalid public key or session_priv is invalid
|
||||
#[inline]
|
||||
fn construct_onion_keys_callback<FType: FnMut(SharedSecret, [u8; 32], PublicKey, &RouteHop)> (secp_ctx: &Secp256k1, route: &Route, session_priv: &SecretKey, mut callback: FType) -> Result<(), HandleError> {
|
||||
fn construct_onion_keys_callback<T: secp256k1::Signing, FType: FnMut(SharedSecret, [u8; 32], PublicKey, &RouteHop)> (secp_ctx: &Secp256k1<T>, route: &Route, session_priv: &SecretKey, mut callback: FType) -> Result<(), HandleError> {
|
||||
let mut blinded_priv = session_priv.clone();
|
||||
let mut blinded_pub = secp_call!(PublicKey::from_secret_key(secp_ctx, &blinded_priv));
|
||||
let mut blinded_pub = PublicKey::from_secret_key(secp_ctx, &blinded_priv);
|
||||
let mut first_iteration = true;
|
||||
|
||||
for hop in route.hops.iter() {
|
||||
|
@ -476,13 +476,13 @@ impl ChannelManager {
|
|||
sha.result(&mut blinding_factor);
|
||||
|
||||
if first_iteration {
|
||||
blinded_pub = secp_call!(PublicKey::from_secret_key(secp_ctx, &blinded_priv));
|
||||
blinded_pub = PublicKey::from_secret_key(secp_ctx, &blinded_priv);
|
||||
first_iteration = false;
|
||||
}
|
||||
let ephemeral_pubkey = blinded_pub;
|
||||
|
||||
secp_call!(blinded_priv.mul_assign(secp_ctx, &secp_call!(SecretKey::from_slice(secp_ctx, &blinding_factor))));
|
||||
blinded_pub = secp_call!(PublicKey::from_secret_key(secp_ctx, &blinded_priv));
|
||||
blinded_pub = PublicKey::from_secret_key(secp_ctx, &blinded_priv);
|
||||
|
||||
callback(shared_secret, blinding_factor, ephemeral_pubkey, hop);
|
||||
}
|
||||
|
@ -491,7 +491,7 @@ impl ChannelManager {
|
|||
}
|
||||
|
||||
// can only fail if an intermediary hop has an invalid public key or session_priv is invalid
|
||||
fn construct_onion_keys(secp_ctx: &Secp256k1, route: &Route, session_priv: &SecretKey) -> Result<Vec<OnionKeys>, HandleError> {
|
||||
fn construct_onion_keys<T: secp256k1::Signing>(secp_ctx: &Secp256k1<T>, route: &Route, session_priv: &SecretKey) -> Result<Vec<OnionKeys>, HandleError> {
|
||||
let mut res = Vec::with_capacity(route.hops.len());
|
||||
|
||||
Self::construct_onion_keys_callback(secp_ctx, route, session_priv, |shared_secret, _blinding_factor, ephemeral_pubkey, _| {
|
||||
|
@ -674,7 +674,7 @@ impl ChannelManager {
|
|||
Some(id) => id,
|
||||
};
|
||||
|
||||
let were_node_one = PublicKey::from_secret_key(&self.secp_ctx, &self.our_network_key).unwrap().serialize()[..] < chan.get_their_node_id().serialize()[..];
|
||||
let were_node_one = PublicKey::from_secret_key(&self.secp_ctx, &self.our_network_key).serialize()[..] < chan.get_their_node_id().serialize()[..];
|
||||
|
||||
let unsigned = msgs::UnsignedChannelUpdate {
|
||||
chain_hash: self.genesis_hash,
|
||||
|
@ -688,7 +688,7 @@ impl ChannelManager {
|
|||
};
|
||||
|
||||
let msg_hash = Sha256dHash::from_data(&unsigned.encode()[..]);
|
||||
let sig = self.secp_ctx.sign(&Message::from_slice(&msg_hash[..]).unwrap(), &self.our_network_key).unwrap(); //TODO Can we unwrap here?
|
||||
let sig = self.secp_ctx.sign(&Message::from_slice(&msg_hash[..]).unwrap(), &self.our_network_key); //TODO Can we unwrap here?
|
||||
|
||||
Ok(msgs::ChannelUpdate {
|
||||
signature: sig,
|
||||
|
@ -839,7 +839,7 @@ impl ChannelManager {
|
|||
|
||||
let (announcement, our_bitcoin_sig) = chan.get_channel_announcement(self.get_our_node_id(), self.genesis_hash.clone())?;
|
||||
let msghash = Message::from_slice(&Sha256dHash::from_data(&announcement.encode()[..])[..]).unwrap();
|
||||
let our_node_sig = secp_call!(self.secp_ctx.sign(&msghash, &self.our_network_key));
|
||||
let our_node_sig = self.secp_ctx.sign(&msghash, &self.our_network_key);
|
||||
|
||||
Ok(Some(msgs::AnnouncementSignatures {
|
||||
channel_id: chan.channel_id(),
|
||||
|
@ -1138,7 +1138,7 @@ impl ChannelManager {
|
|||
|
||||
/// Gets the node_id held by this ChannelManager
|
||||
pub fn get_our_node_id(&self) -> PublicKey {
|
||||
PublicKey::from_secret_key(&self.secp_ctx, &self.our_network_key).unwrap()
|
||||
PublicKey::from_secret_key(&self.secp_ctx, &self.our_network_key)
|
||||
}
|
||||
|
||||
/// Used to restore channels to normal operation after a
|
||||
|
@ -1195,7 +1195,7 @@ impl ChainListener for ChannelManager {
|
|||
if let Some(funding_txo) = channel.get_funding_txo() {
|
||||
for tx in txn_matched {
|
||||
for inp in tx.input.iter() {
|
||||
if inp.prev_hash == funding_txo.txid && inp.prev_index == funding_txo.index as u32 {
|
||||
if inp.previous_output == funding_txo.into_bitcoin_outpoint() {
|
||||
if let Some(short_id) = channel.get_short_channel_id() {
|
||||
short_to_id.remove(&short_id);
|
||||
}
|
||||
|
@ -1939,7 +1939,7 @@ impl ChannelMessageHandler for ChannelManager {
|
|||
secp_call!(self.secp_ctx.verify(&msghash, &msg.node_signature, if were_node_one { &announcement.node_id_2 } else { &announcement.node_id_1 }));
|
||||
secp_call!(self.secp_ctx.verify(&msghash, &msg.bitcoin_signature, if were_node_one { &announcement.bitcoin_key_2 } else { &announcement.bitcoin_key_1 }));
|
||||
|
||||
let our_node_sig = secp_call!(self.secp_ctx.sign(&msghash, &self.our_network_key));
|
||||
let our_node_sig = self.secp_ctx.sign(&msghash, &self.our_network_key);
|
||||
|
||||
(msgs::ChannelAnnouncement {
|
||||
node_signature_1: if were_node_one { our_node_sig } else { msg.node_signature },
|
||||
|
@ -2742,7 +2742,7 @@ mod tests {
|
|||
SecretKey::from_slice(&secp_ctx, &key_slice).unwrap()
|
||||
};
|
||||
let node = ChannelManager::new(node_id.clone(), 0, true, Network::Testnet, feeest.clone(), chan_monitor.clone(), chain_monitor.clone(), tx_broadcaster.clone(), Arc::clone(&logger)).unwrap();
|
||||
let router = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id).unwrap(), Arc::clone(&logger));
|
||||
let router = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id), Arc::clone(&logger));
|
||||
nodes.push(Node { feeest, chain_monitor, tx_broadcaster, chan_monitor, node_id, node, router });
|
||||
}
|
||||
|
||||
|
@ -2879,7 +2879,7 @@ mod tests {
|
|||
res.push(explicit_tx.clone());
|
||||
} else {
|
||||
for tx in node_txn.iter() {
|
||||
if tx.input.len() == 1 && tx.input[0].prev_hash == chan.3.txid() {
|
||||
if tx.input.len() == 1 && tx.input[0].previous_output.txid == chan.3.txid() {
|
||||
let mut funding_tx_map = HashMap::new();
|
||||
funding_tx_map.insert(chan.3.txid(), chan.3.clone());
|
||||
tx.verify(&funding_tx_map).unwrap();
|
||||
|
@ -2891,7 +2891,7 @@ mod tests {
|
|||
|
||||
if has_htlc_tx != HTLCType::NONE {
|
||||
for tx in node_txn.iter() {
|
||||
if tx.input.len() == 1 && tx.input[0].prev_hash == res[0].txid() {
|
||||
if tx.input.len() == 1 && tx.input[0].previous_output.txid == res[0].txid() {
|
||||
let mut funding_tx_map = HashMap::new();
|
||||
funding_tx_map.insert(res[0].txid(), res[0].clone());
|
||||
tx.verify(&funding_tx_map).unwrap();
|
||||
|
@ -2918,7 +2918,7 @@ mod tests {
|
|||
let mut found_prev = false;
|
||||
|
||||
for tx in prev_txn {
|
||||
if node_txn[0].input[0].prev_hash == tx.txid() {
|
||||
if node_txn[0].input[0].previous_output.txid == tx.txid() {
|
||||
let mut funding_tx_map = HashMap::new();
|
||||
funding_tx_map.insert(tx.txid(), tx.clone());
|
||||
node_txn[0].verify(&funding_tx_map).unwrap();
|
||||
|
|
|
@ -1,5 +1,6 @@
|
|||
use bitcoin::blockdata::block::BlockHeader;
|
||||
use bitcoin::blockdata::transaction::{TxIn,TxOut,SigHashType,Transaction};
|
||||
use bitcoin::blockdata::transaction::OutPoint as BitcoinOutPoint;
|
||||
use bitcoin::blockdata::script::Script;
|
||||
use bitcoin::network::serialize;
|
||||
use bitcoin::util::hash::Sha256dHash;
|
||||
|
@ -9,6 +10,7 @@ use crypto::digest::Digest;
|
|||
|
||||
use secp256k1::{Secp256k1,Message,Signature};
|
||||
use secp256k1::key::{SecretKey,PublicKey};
|
||||
use secp256k1;
|
||||
|
||||
use ln::msgs::HandleError;
|
||||
use ln::chan_utils;
|
||||
|
@ -186,7 +188,7 @@ pub struct ChannelMonitor {
|
|||
payment_preimages: HashMap<[u8; 32], [u8; 32]>,
|
||||
|
||||
destination_script: Script,
|
||||
secp_ctx: Secp256k1, //TODO: dedup this a bit...
|
||||
secp_ctx: Secp256k1<secp256k1::All>, //TODO: dedup this a bit...
|
||||
}
|
||||
impl Clone for ChannelMonitor {
|
||||
fn clone(&self) -> Self {
|
||||
|
@ -928,20 +930,20 @@ impl ChannelMonitor {
|
|||
let per_commitment_key = ignore_error!(SecretKey::from_slice(&self.secp_ctx, &secret));
|
||||
let (revocation_pubkey, b_htlc_key) = match self.key_storage {
|
||||
KeyStorage::PrivMode { ref revocation_base_key, ref htlc_base_key } => {
|
||||
let per_commitment_point = ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key));
|
||||
(ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, &per_commitment_point, &ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &revocation_base_key)))),
|
||||
ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &per_commitment_point, &ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &htlc_base_key)))))
|
||||
let per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key);
|
||||
(ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, &per_commitment_point, &PublicKey::from_secret_key(&self.secp_ctx, &revocation_base_key))),
|
||||
ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &per_commitment_point, &PublicKey::from_secret_key(&self.secp_ctx, &htlc_base_key))))
|
||||
},
|
||||
KeyStorage::SigsMode { ref revocation_base_key, ref htlc_base_key, .. } => {
|
||||
let per_commitment_point = ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key));
|
||||
let per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key);
|
||||
(ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, &per_commitment_point, &revocation_base_key)),
|
||||
ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &per_commitment_point, &htlc_base_key)))
|
||||
},
|
||||
};
|
||||
let delayed_key = ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key)), &self.delayed_payment_base_key));
|
||||
let delayed_key = ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key), &self.delayed_payment_base_key));
|
||||
let a_htlc_key = match self.their_htlc_base_key {
|
||||
None => return txn_to_broadcast,
|
||||
Some(their_htlc_base_key) => ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key)), &their_htlc_base_key)),
|
||||
Some(their_htlc_base_key) => ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key), &their_htlc_base_key)),
|
||||
};
|
||||
|
||||
let revokeable_redeemscript = chan_utils::get_revokeable_redeemscript(&revocation_pubkey, self.our_to_self_delay, &delayed_key);
|
||||
|
@ -955,8 +957,10 @@ impl ChannelMonitor {
|
|||
for (idx, outp) in tx.output.iter().enumerate() {
|
||||
if outp.script_pubkey == revokeable_p2wsh {
|
||||
inputs.push(TxIn {
|
||||
prev_hash: commitment_txid,
|
||||
prev_index: idx as u32,
|
||||
previous_output: BitcoinOutPoint {
|
||||
txid: commitment_txid,
|
||||
vout: idx as u32,
|
||||
},
|
||||
script_sig: Script::new(),
|
||||
sequence: 0xfffffffd,
|
||||
witness: Vec::new(),
|
||||
|
@ -979,7 +983,7 @@ impl ChannelMonitor {
|
|||
};
|
||||
let sighash = ignore_error!(Message::from_slice(&$sighash_parts.sighash_all(&$input, &redeemscript, $amount)[..]));
|
||||
let revocation_key = ignore_error!(chan_utils::derive_private_revocation_key(&self.secp_ctx, &per_commitment_key, &revocation_base_key));
|
||||
(ignore_error!(self.secp_ctx.sign(&sighash, &revocation_key)), redeemscript)
|
||||
(self.secp_ctx.sign(&sighash, &revocation_key), redeemscript)
|
||||
},
|
||||
KeyStorage::SigsMode { .. } => {
|
||||
unimplemented!();
|
||||
|
@ -992,7 +996,7 @@ impl ChannelMonitor {
|
|||
} else {
|
||||
$input.witness.push(revocation_pubkey.serialize().to_vec());
|
||||
}
|
||||
$input.witness.push(redeemscript.into_vec());
|
||||
$input.witness.push(redeemscript.into_bytes());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1008,8 +1012,10 @@ impl ChannelMonitor {
|
|||
return txn_to_broadcast; // Corrupted per_commitment_data, fuck this user
|
||||
}
|
||||
let input = TxIn {
|
||||
prev_hash: commitment_txid,
|
||||
prev_index: htlc.transaction_output_index,
|
||||
previous_output: BitcoinOutPoint {
|
||||
txid: commitment_txid,
|
||||
vout: htlc.transaction_output_index,
|
||||
},
|
||||
script_sig: Script::new(),
|
||||
sequence: 0xfffffffd,
|
||||
witness: Vec::new(),
|
||||
|
@ -1083,8 +1089,8 @@ impl ChannelMonitor {
|
|||
if let Some(revocation_point) = revocation_point_option {
|
||||
let (revocation_pubkey, b_htlc_key) = match self.key_storage {
|
||||
KeyStorage::PrivMode { ref revocation_base_key, ref htlc_base_key } => {
|
||||
(ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, revocation_point, &ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &revocation_base_key)))),
|
||||
ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, revocation_point, &ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &htlc_base_key)))))
|
||||
(ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, revocation_point, &PublicKey::from_secret_key(&self.secp_ctx, &revocation_base_key))),
|
||||
ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, revocation_point, &PublicKey::from_secret_key(&self.secp_ctx, &htlc_base_key))))
|
||||
},
|
||||
KeyStorage::SigsMode { ref revocation_base_key, ref htlc_base_key, .. } => {
|
||||
(ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, revocation_point, &revocation_base_key)),
|
||||
|
@ -1109,7 +1115,7 @@ impl ChannelMonitor {
|
|||
let redeemscript = chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &a_htlc_key, &b_htlc_key, &revocation_pubkey);
|
||||
let sighash = ignore_error!(Message::from_slice(&$sighash_parts.sighash_all(&$input, &redeemscript, $amount)[..]));
|
||||
let htlc_key = ignore_error!(chan_utils::derive_private_key(&self.secp_ctx, revocation_point, &htlc_base_key));
|
||||
(ignore_error!(self.secp_ctx.sign(&sighash, &htlc_key)), redeemscript)
|
||||
(self.secp_ctx.sign(&sighash, &htlc_key), redeemscript)
|
||||
},
|
||||
KeyStorage::SigsMode { .. } => {
|
||||
unimplemented!();
|
||||
|
@ -1118,7 +1124,7 @@ impl ChannelMonitor {
|
|||
$input.witness.push(sig.serialize_der(&self.secp_ctx).to_vec());
|
||||
$input.witness[0].push(SigHashType::All as u8);
|
||||
$input.witness.push($preimage);
|
||||
$input.witness.push(redeemscript.into_vec());
|
||||
$input.witness.push(redeemscript.into_bytes());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1126,8 +1132,10 @@ impl ChannelMonitor {
|
|||
for (idx, htlc) in per_commitment_data.iter().enumerate() {
|
||||
if let Some(payment_preimage) = self.payment_preimages.get(&htlc.payment_hash) {
|
||||
let input = TxIn {
|
||||
prev_hash: commitment_txid,
|
||||
prev_index: htlc.transaction_output_index,
|
||||
previous_output: BitcoinOutPoint {
|
||||
txid: commitment_txid,
|
||||
vout: htlc.transaction_output_index,
|
||||
},
|
||||
script_sig: Script::new(),
|
||||
sequence: idx as u32, // reset to 0xfffffffd in sign_input
|
||||
witness: Vec::new(),
|
||||
|
@ -1199,7 +1207,7 @@ impl ChannelMonitor {
|
|||
htlc_timeout_tx.input[0].witness[2].push(SigHashType::All as u8);
|
||||
|
||||
htlc_timeout_tx.input[0].witness.push(Vec::new());
|
||||
htlc_timeout_tx.input[0].witness.push(chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &local_tx.a_htlc_key, &local_tx.b_htlc_key, &local_tx.revocation_key).into_vec());
|
||||
htlc_timeout_tx.input[0].witness.push(chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &local_tx.a_htlc_key, &local_tx.b_htlc_key, &local_tx.revocation_key).into_bytes());
|
||||
|
||||
res.push(htlc_timeout_tx);
|
||||
} else {
|
||||
|
@ -1214,7 +1222,7 @@ impl ChannelMonitor {
|
|||
htlc_success_tx.input[0].witness[2].push(SigHashType::All as u8);
|
||||
|
||||
htlc_success_tx.input[0].witness.push(payment_preimage.to_vec());
|
||||
htlc_success_tx.input[0].witness.push(chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &local_tx.a_htlc_key, &local_tx.b_htlc_key, &local_tx.revocation_key).into_vec());
|
||||
htlc_success_tx.input[0].witness.push(chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &local_tx.a_htlc_key, &local_tx.b_htlc_key, &local_tx.revocation_key).into_bytes());
|
||||
|
||||
res.push(htlc_success_tx);
|
||||
}
|
||||
|
@ -1245,7 +1253,7 @@ impl ChannelMonitor {
|
|||
fn block_connected(&self, txn_matched: &[&Transaction], height: u32, broadcaster: &BroadcasterInterface) {
|
||||
for tx in txn_matched {
|
||||
for txin in tx.input.iter() {
|
||||
if self.funding_txo.is_none() || (txin.prev_hash == self.funding_txo.as_ref().unwrap().0.txid && txin.prev_index == self.funding_txo.as_ref().unwrap().0.index as u32) {
|
||||
if self.funding_txo.is_none() || (txin.previous_output.txid == self.funding_txo.as_ref().unwrap().0.txid && txin.previous_output.vout == self.funding_txo.as_ref().unwrap().0.index as u32) {
|
||||
let mut txn = self.check_spend_remote_transaction(tx, height);
|
||||
if txn.is_empty() {
|
||||
txn = self.check_spend_local_transaction(tx, height);
|
||||
|
@ -1321,9 +1329,11 @@ mod tests {
|
|||
};
|
||||
}
|
||||
|
||||
let delayed_payment_base_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap());
|
||||
|
||||
{
|
||||
// insert_secret correct sequence
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
secrets.clear();
|
||||
|
||||
secrets.push([0; 32]);
|
||||
|
@ -1369,7 +1379,7 @@ mod tests {
|
|||
|
||||
{
|
||||
// insert_secret #1 incorrect
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
secrets.clear();
|
||||
|
||||
secrets.push([0; 32]);
|
||||
|
@ -1385,7 +1395,7 @@ mod tests {
|
|||
|
||||
{
|
||||
// insert_secret #2 incorrect (#1 derived from incorrect)
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
secrets.clear();
|
||||
|
||||
secrets.push([0; 32]);
|
||||
|
@ -1411,7 +1421,7 @@ mod tests {
|
|||
|
||||
{
|
||||
// insert_secret #3 incorrect
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
secrets.clear();
|
||||
|
||||
secrets.push([0; 32]);
|
||||
|
@ -1437,7 +1447,7 @@ mod tests {
|
|||
|
||||
{
|
||||
// insert_secret #4 incorrect (1,2,3 derived from incorrect)
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
secrets.clear();
|
||||
|
||||
secrets.push([0; 32]);
|
||||
|
@ -1483,7 +1493,7 @@ mod tests {
|
|||
|
||||
{
|
||||
// insert_secret #5 incorrect
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
secrets.clear();
|
||||
|
||||
secrets.push([0; 32]);
|
||||
|
@ -1519,7 +1529,7 @@ mod tests {
|
|||
|
||||
{
|
||||
// insert_secret #6 incorrect (5 derived from incorrect)
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
secrets.clear();
|
||||
|
||||
secrets.push([0; 32]);
|
||||
|
@ -1565,7 +1575,7 @@ mod tests {
|
|||
|
||||
{
|
||||
// insert_secret #7 incorrect
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
secrets.clear();
|
||||
|
||||
secrets.push([0; 32]);
|
||||
|
@ -1611,7 +1621,7 @@ mod tests {
|
|||
|
||||
{
|
||||
// insert_secret #8 incorrect
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
secrets.clear();
|
||||
|
||||
secrets.push([0; 32]);
|
||||
|
@ -1663,13 +1673,16 @@ mod tests {
|
|||
|
||||
macro_rules! dummy_keys {
|
||||
() => {
|
||||
TxCreationKeys {
|
||||
per_commitment_point: PublicKey::new(),
|
||||
revocation_key: PublicKey::new(),
|
||||
a_htlc_key: PublicKey::new(),
|
||||
b_htlc_key: PublicKey::new(),
|
||||
a_delayed_payment_key: PublicKey::new(),
|
||||
b_payment_key: PublicKey::new(),
|
||||
{
|
||||
let dummy_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap());
|
||||
TxCreationKeys {
|
||||
per_commitment_point: dummy_key.clone(),
|
||||
revocation_key: dummy_key.clone(),
|
||||
a_htlc_key: dummy_key.clone(),
|
||||
b_htlc_key: dummy_key.clone(),
|
||||
a_delayed_payment_key: dummy_key.clone(),
|
||||
b_payment_key: dummy_key.clone(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1726,7 +1739,8 @@ mod tests {
|
|||
|
||||
// Prune with one old state and a local commitment tx holding a few overlaps with the
|
||||
// old state.
|
||||
let mut monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
let delayed_payment_base_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap());
|
||||
let mut monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new());
|
||||
monitor.set_their_to_self_delay(10);
|
||||
|
||||
monitor.provide_latest_local_commitment_tx_info(dummy_tx.clone(), dummy_keys!(), 0, preimages_to_local_htlcs!(preimages[0..10]));
|
||||
|
|
|
@ -1658,7 +1658,7 @@ mod tests {
|
|||
fn encoding_channel_reestablish_no_secret() {
|
||||
let public_key = {
|
||||
let secp_ctx = Secp256k1::new();
|
||||
PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()).unwrap()
|
||||
PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
|
||||
};
|
||||
|
||||
let cr = msgs::ChannelReestablish {
|
||||
|
@ -1680,7 +1680,7 @@ mod tests {
|
|||
fn encoding_channel_reestablish_with_secret() {
|
||||
let public_key = {
|
||||
let secp_ctx = Secp256k1::new();
|
||||
PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()).unwrap()
|
||||
PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
|
||||
};
|
||||
|
||||
let cr = msgs::ChannelReestablish {
|
||||
|
|
|
@ -4,6 +4,7 @@ use ln::msgs;
|
|||
use secp256k1::Secp256k1;
|
||||
use secp256k1::key::{PublicKey,SecretKey};
|
||||
use secp256k1::ecdh::SharedSecret;
|
||||
use secp256k1;
|
||||
|
||||
use crypto::digest::Digest;
|
||||
use crypto::hkdf::{hkdf_extract,hkdf_expand};
|
||||
|
@ -65,7 +66,7 @@ enum NoiseState {
|
|||
}
|
||||
|
||||
pub struct PeerChannelEncryptor {
|
||||
secp_ctx: Secp256k1,
|
||||
secp_ctx: Secp256k1<secp256k1::SignOnly>,
|
||||
their_node_id: Option<PublicKey>, // filled in for outbound, or inbound after noise_state is Finished
|
||||
|
||||
noise_state: NoiseState,
|
||||
|
@ -76,7 +77,7 @@ impl PeerChannelEncryptor {
|
|||
let mut key = [0u8; 32];
|
||||
rng::fill_bytes(&mut key);
|
||||
|
||||
let secp_ctx = Secp256k1::new();
|
||||
let secp_ctx = Secp256k1::signing_only();
|
||||
let sec_key = SecretKey::from_slice(&secp_ctx, &key).unwrap(); //TODO: nicer rng-is-bad error message
|
||||
|
||||
let mut sha = Sha256::new();
|
||||
|
@ -102,11 +103,11 @@ impl PeerChannelEncryptor {
|
|||
}
|
||||
|
||||
pub fn new_inbound(our_node_secret: &SecretKey) -> PeerChannelEncryptor {
|
||||
let secp_ctx = Secp256k1::new();
|
||||
let secp_ctx = Secp256k1::signing_only();
|
||||
|
||||
let mut sha = Sha256::new();
|
||||
sha.input(&NOISE_H);
|
||||
let our_node_id = PublicKey::from_secret_key(&secp_ctx, our_node_secret).unwrap(); //TODO: nicer bad-node_secret error message
|
||||
let our_node_id = PublicKey::from_secret_key(&secp_ctx, our_node_secret);
|
||||
sha.input(&our_node_id.serialize()[..]);
|
||||
let mut h = [0; 32];
|
||||
sha.result(&mut h);
|
||||
|
@ -167,8 +168,8 @@ impl PeerChannelEncryptor {
|
|||
}
|
||||
|
||||
#[inline]
|
||||
fn outbound_noise_act(secp_ctx: &Secp256k1, state: &mut BidirectionalNoiseState, our_key: &SecretKey, their_key: &PublicKey) -> ([u8; 50], [u8; 32]) {
|
||||
let our_pub = PublicKey::from_secret_key(secp_ctx, &our_key).unwrap(); //TODO: nicer rng-is-bad error message
|
||||
fn outbound_noise_act<T: secp256k1::Signing>(secp_ctx: &Secp256k1<T>, state: &mut BidirectionalNoiseState, our_key: &SecretKey, their_key: &PublicKey) -> ([u8; 50], [u8; 32]) {
|
||||
let our_pub = PublicKey::from_secret_key(secp_ctx, &our_key);
|
||||
|
||||
let mut sha = Sha256::new();
|
||||
sha.input(&state.h);
|
||||
|
@ -191,7 +192,7 @@ impl PeerChannelEncryptor {
|
|||
}
|
||||
|
||||
#[inline]
|
||||
fn inbound_noise_act(secp_ctx: &Secp256k1, state: &mut BidirectionalNoiseState, act: &[u8], our_key: &SecretKey) -> Result<(PublicKey, [u8; 32]), HandleError> {
|
||||
fn inbound_noise_act<T>(secp_ctx: &Secp256k1<T>, state: &mut BidirectionalNoiseState, act: &[u8], our_key: &SecretKey) -> Result<(PublicKey, [u8; 32]), HandleError> {
|
||||
assert_eq!(act.len(), 50);
|
||||
|
||||
if act[0] != 0 {
|
||||
|
@ -294,7 +295,7 @@ impl PeerChannelEncryptor {
|
|||
let (re, temp_k2) = PeerChannelEncryptor::inbound_noise_act(&self.secp_ctx, bidirectional_state, act_two, &ie)?;
|
||||
|
||||
let mut res = [0; 66];
|
||||
let our_node_id = PublicKey::from_secret_key(&self.secp_ctx, &our_node_secret).unwrap(); //TODO: nicer rng-is-bad error message
|
||||
let our_node_id = PublicKey::from_secret_key(&self.secp_ctx, &our_node_secret);
|
||||
|
||||
PeerChannelEncryptor::encrypt_with_ad(&mut res[1..50], 1, &temp_k2, &bidirectional_state.h, &our_node_id.serialize()[..]);
|
||||
|
||||
|
|
|
@ -920,7 +920,7 @@ mod tests {
|
|||
|
||||
fn establish_connection(peer_a: &PeerManager<FileDescriptor>, peer_b: &PeerManager<FileDescriptor>) {
|
||||
let secp_ctx = Secp256k1::new();
|
||||
let their_id = PublicKey::from_secret_key(&secp_ctx, &peer_b.our_node_secret).unwrap();
|
||||
let their_id = PublicKey::from_secret_key(&secp_ctx, &peer_b.our_node_secret);
|
||||
let fd = FileDescriptor { fd: 1};
|
||||
peer_a.new_inbound_connection(fd.clone()).unwrap();
|
||||
peer_a.peers.lock().unwrap().node_id_to_descriptor.insert(their_id, fd.clone());
|
||||
|
@ -935,7 +935,7 @@ mod tests {
|
|||
assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 1);
|
||||
|
||||
let secp_ctx = Secp256k1::new();
|
||||
let their_id = PublicKey::from_secret_key(&secp_ctx, &peers[1].our_node_secret).unwrap();
|
||||
let their_id = PublicKey::from_secret_key(&secp_ctx, &peers[1].our_node_secret);
|
||||
|
||||
let chan_handler = test_utils::TestChannelMessageHandler::new();
|
||||
chan_handler.pending_events.lock().unwrap().push(events::Event::HandleError {
|
||||
|
|
|
@ -1,5 +1,6 @@
|
|||
use secp256k1::key::PublicKey;
|
||||
use secp256k1::{Secp256k1,Message};
|
||||
use secp256k1;
|
||||
|
||||
use bitcoin::util::hash::Sha256dHash;
|
||||
|
||||
|
@ -152,7 +153,7 @@ pub struct RouteHint {
|
|||
/// Tracks a view of the network, receiving updates from peers and generating Routes to
|
||||
/// payment destinations.
|
||||
pub struct Router {
|
||||
secp_ctx: Secp256k1,
|
||||
secp_ctx: Secp256k1<secp256k1::VerifyOnly>,
|
||||
network_map: RwLock<NetworkMap>,
|
||||
logger: Arc<Logger>,
|
||||
}
|
||||
|
@ -396,7 +397,7 @@ impl Router {
|
|||
addresses: Vec::new(),
|
||||
});
|
||||
Router {
|
||||
secp_ctx: Secp256k1::new(),
|
||||
secp_ctx: Secp256k1::verification_only(),
|
||||
network_map: RwLock::new(NetworkMap {
|
||||
channels: HashMap::new(),
|
||||
our_node_id: our_pubkey,
|
||||
|
@ -645,7 +646,7 @@ mod tests {
|
|||
#[test]
|
||||
fn route_test() {
|
||||
let secp_ctx = Secp256k1::new();
|
||||
let our_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()).unwrap();
|
||||
let our_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap());
|
||||
let logger: Arc<Logger> = Arc::new(test_utils::TestLogger::new());
|
||||
let router = Router::new(our_id, Arc::clone(&logger));
|
||||
|
||||
|
@ -706,14 +707,14 @@ mod tests {
|
|||
// chan11 1-to-2: enabled, 0 fee
|
||||
// chan11 2-to-1: enabled, 0 fee
|
||||
|
||||
let node1 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap()[..]).unwrap()).unwrap();
|
||||
let node2 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0303030303030303030303030303030303030303030303030303030303030303").unwrap()[..]).unwrap()).unwrap();
|
||||
let node3 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0404040404040404040404040404040404040404040404040404040404040404").unwrap()[..]).unwrap()).unwrap();
|
||||
let node4 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0505050505050505050505050505050505050505050505050505050505050505").unwrap()[..]).unwrap()).unwrap();
|
||||
let node5 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0606060606060606060606060606060606060606060606060606060606060606").unwrap()[..]).unwrap()).unwrap();
|
||||
let node6 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0707070707070707070707070707070707070707070707070707070707070707").unwrap()[..]).unwrap()).unwrap();
|
||||
let node7 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0808080808080808080808080808080808080808080808080808080808080808").unwrap()[..]).unwrap()).unwrap();
|
||||
let node8 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0909090909090909090909090909090909090909090909090909090909090909").unwrap()[..]).unwrap()).unwrap();
|
||||
let node1 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap()[..]).unwrap());
|
||||
let node2 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0303030303030303030303030303030303030303030303030303030303030303").unwrap()[..]).unwrap());
|
||||
let node3 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0404040404040404040404040404040404040404040404040404040404040404").unwrap()[..]).unwrap());
|
||||
let node4 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0505050505050505050505050505050505050505050505050505050505050505").unwrap()[..]).unwrap());
|
||||
let node5 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0606060606060606060606060606060606060606060606060606060606060606").unwrap()[..]).unwrap());
|
||||
let node6 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0707070707070707070707070707070707070707070707070707070707070707").unwrap()[..]).unwrap());
|
||||
let node7 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0808080808080808080808080808080808080808080808080808080808080808").unwrap()[..]).unwrap());
|
||||
let node8 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0909090909090909090909090909090909090909090909090909090909090909").unwrap()[..]).unwrap());
|
||||
|
||||
let zero_hash = Sha256dHash::from_data(&[0; 32]);
|
||||
|
||||
|
|
|
@ -20,13 +20,13 @@ pub fn sort_outputs<T>(outputs: &mut Vec<(TxOut, T)>) {
|
|||
|
||||
pub fn sort_inputs<T>(inputs: &mut Vec<(TxIn, T)>) {
|
||||
inputs.sort_unstable_by(|a, b| {
|
||||
if a.0.prev_hash.into_le() < b.0.prev_hash.into_le() {
|
||||
Ordering::Less
|
||||
} else if b.0.prev_hash.into_le() < a.0.prev_hash.into_le() {
|
||||
Ordering::Greater
|
||||
} else if a.0.prev_index < b.0.prev_index {
|
||||
if a.0.previous_output.txid.into_le() < b.0.previous_output.txid.into_le() {
|
||||
Ordering::Less
|
||||
} else if b.0.prev_index < a.0.prev_index {
|
||||
} else if b.0.previous_output.txid.into_le() < a.0.previous_output.txid.into_le() {
|
||||
Ordering::Greater
|
||||
} else if a.0.previous_output.vout < b.0.previous_output.vout {
|
||||
Ordering::Less
|
||||
} else if b.0.previous_output.vout < a.0.previous_output.vout {
|
||||
Ordering::Greater
|
||||
} else {
|
||||
Ordering::Equal
|
||||
|
@ -39,7 +39,7 @@ mod tests {
|
|||
use super::*;
|
||||
|
||||
use bitcoin::blockdata::script::{Script, Builder};
|
||||
use bitcoin::blockdata::transaction::TxOut;
|
||||
use bitcoin::blockdata::transaction::{TxOut, OutPoint};
|
||||
use bitcoin::util::hash::Sha256dHash;
|
||||
|
||||
use hex::decode;
|
||||
|
@ -161,8 +161,10 @@ mod tests {
|
|||
let expected_raw: Vec<(&str, u32)> = $value;
|
||||
let expected: Vec<(TxIn, &str)> = expected_raw.iter().map(
|
||||
|txin_raw| TxIn {
|
||||
prev_hash: Sha256dHash::from_hex(txin_raw.0).unwrap(),
|
||||
prev_index: txin_raw.1,
|
||||
previous_output: OutPoint {
|
||||
txid: Sha256dHash::from_hex(txin_raw.0).unwrap(),
|
||||
vout: txin_raw.1,
|
||||
},
|
||||
script_sig: Script::new(),
|
||||
sequence: 0,
|
||||
witness: vec![]
|
||||
|
|
Loading…
Add table
Reference in a new issue