Skip to content

Commit 37535c1

Browse files
arik-soarik-so
committed
WIP: Split out KeysInterface into EntropySource, NodeSigner, and SignerProvider.
1 parent 40b78ea commit 37535c1

28 files changed

+462
-415
lines changed

‎fuzz/src/chanmon_consistency.rs‎

Lines changed: 28 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -36,7 +36,7 @@ use lightning::chain::{BestBlock, ChannelMonitorUpdateStatus, chainmonitor, chan
3636
use lightning::chain::channelmonitor::{ChannelMonitor, MonitorEvent};
3737
use lightning::chain::transaction::OutPoint;
3838
use lightning::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator};
39-
use lightning::chain::keysinterface::{KeyMaterial, KeysInterface, InMemorySigner, Recipient};
39+
use lightning::chain::keysinterface::{KeyMaterial, KeysInterface, InMemorySigner, Recipient, EntropySource, NodeSigner, SignerProvider};
4040
use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
4141
use lightning::ln::channelmanager::{self, ChainParameters, ChannelManager, PaymentSendFailure, ChannelManagerReadArgs, PaymentId};
4242
use lightning::ln::channel::FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE;
@@ -160,38 +160,28 @@ struct KeyProvider {
160160
rand_bytes_id: atomic::AtomicU32,
161161
enforcement_states: Mutex<HashMap<[u8;32], Arc<Mutex<EnforcementState>>>>,
162162
}
163-
impl KeysInterface for KeyProvider {
164-
type Signer = EnforcingSigner;
165163

166-
fn get_node_secret(&self, _recipient: Recipient) -> Result<SecretKey, ()> {
167-
Ok(SecretKey::from_slice(&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, self.node_id]).unwrap())
164+
impl EntropySource for KeyProvider {
165+
fn get_secure_random_bytes(&self) -> [u8; 32] {
166+
let id = self.rand_bytes_id.fetch_add(1, atomic::Ordering::Relaxed);
167+
let mut res = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, self.node_id];
168+
res[30-4..30].copy_from_slice(&id.to_le_bytes());
169+
res
168170
}
171+
}
169172

170-
fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> Result<SharedSecret, ()> {
171-
let mut node_secret = self.get_node_secret(recipient)?;
172-
if let Some(tweak) = tweak {
173-
node_secret = node_secret.mul_tweak(tweak).unwrap();
174-
}
175-
Ok(SharedSecret::new(other_key, &node_secret))
173+
impl NodeSigner for KeyProvider {
174+
fn get_node_secret(&self, _recipient: Recipient) -> Result<SecretKey, ()> {
175+
Ok(SecretKey::from_slice(&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, self.node_id]).unwrap())
176176
}
177177

178178
fn get_inbound_payment_key_material(&self) -> KeyMaterial {
179179
KeyMaterial([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, self.node_id])
180180
}
181+
}
181182

182-
fn get_destination_script(&self) -> Script {
183-
let secp_ctx = Secp256k1::signing_only();
184-
let channel_monitor_claim_key = SecretKey::from_slice(&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, self.node_id]).unwrap();
185-
let our_channel_monitor_claim_key_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &channel_monitor_claim_key).serialize());
186-
Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0).push_slice(&our_channel_monitor_claim_key_hash[..]).into_script()
187-
}
188-
189-
fn get_shutdown_scriptpubkey(&self) -> ShutdownScript {
190-
let secp_ctx = Secp256k1::signing_only();
191-
let secret_key = SecretKey::from_slice(&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, self.node_id]).unwrap();
192-
let pubkey_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &secret_key).serialize());
193-
ShutdownScript::new_p2wpkh(&pubkey_hash)
194-
}
183+
impl SignerProvider for KeyProvider {
184+
type Signer = EnforcingSigner;
195185

196186
fn generate_channel_keys_id(&self, _inbound: bool, _channel_value_satoshis: u64, _user_channel_id: u128) -> [u8; 32] {
197187
let id = self.rand_bytes_id.fetch_add(1, atomic::Ordering::Relaxed) as u8;
@@ -217,13 +207,6 @@ impl KeysInterface for KeyProvider {
217207
EnforcingSigner::new_with_revoked(keys, revoked_commitment, false)
218208
}
219209

220-
fn get_secure_random_bytes(&self) -> [u8; 32] {
221-
let id = self.rand_bytes_id.fetch_add(1, atomic::Ordering::Relaxed);
222-
let mut res = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, self.node_id];
223-
res[30-4..30].copy_from_slice(&id.to_le_bytes());
224-
res
225-
}
226-
227210
fn read_chan_signer(&self, buffer: &[u8]) -> Result<Self::Signer, DecodeError> {
228211
let mut reader = std::io::Cursor::new(buffer);
229212

@@ -237,11 +220,23 @@ impl KeysInterface for KeyProvider {
237220
})
238221
}
239222

240-
fn sign_invoice(&self, _hrp_bytes: &[u8], _invoice_data: &[u5], _recipient: Recipient) -> Result<RecoverableSignature, ()> {
241-
unreachable!()
223+
fn get_destination_script(&self) -> Script {
224+
let secp_ctx = Secp256k1::signing_only();
225+
let channel_monitor_claim_key = SecretKey::from_slice(&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, self.node_id]).unwrap();
226+
let our_channel_monitor_claim_key_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &channel_monitor_claim_key).serialize());
227+
Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0).push_slice(&our_channel_monitor_claim_key_hash[..]).into_script()
228+
}
229+
230+
fn get_shutdown_scriptpubkey(&self) -> ShutdownScript {
231+
let secp_ctx = Secp256k1::signing_only();
232+
let secret_key = SecretKey::from_slice(&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, self.node_id]).unwrap();
233+
let pubkey_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &secret_key).serialize());
234+
ShutdownScript::new_p2wpkh(&pubkey_hash)
242235
}
243236
}
244237

238+
impl KeysInterface for KeyProvider {}
239+
245240
impl KeyProvider {
246241
fn make_enforcement_state_cell(&self, commitment_seed: [u8; 32]) -> Arc<Mutex<EnforcementState>> {
247242
let mut revoked_commitments = self.enforcement_states.lock().unwrap();

‎fuzz/src/full_stack.rs‎

Lines changed: 27 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@ use lightning::chain::{BestBlock, ChannelMonitorUpdateStatus, Confirm, Listen};
3333
use lightning::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator};
3434
use lightning::chain::chainmonitor;
3535
use lightning::chain::transaction::OutPoint;
36-
use lightning::chain::keysinterface::{InMemorySigner, Recipient, KeyMaterial, KeysInterface};
36+
use lightning::chain::keysinterface::{InMemorySigner, Recipient, KeyMaterial, KeysInterface, EntropySource, NodeSigner, SignerProvider};
3737
use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
3838
use lightning::ln::channelmanager::{ChainParameters, ChannelManager, PaymentId};
3939
use lightning::ln::peer_handler::{MessageHandler,PeerManager,SocketDescriptor,IgnoringMessageHandler};
@@ -265,38 +265,27 @@ struct KeyProvider {
265265
counter: AtomicU64,
266266
signer_state: RefCell<HashMap<u8, (bool, Arc<Mutex<EnforcementState>>)>>
267267
}
268-
impl KeysInterface for KeyProvider {
269-
type Signer = EnforcingSigner;
270268

271-
fn get_node_secret(&self, _recipient: Recipient) -> Result<SecretKey, ()> {
272-
Ok(self.node_secret.clone())
269+
impl EntropySource for KeyProvider {
270+
fn get_secure_random_bytes(&self) -> [u8; 32] {
271+
let ctr = self.counter.fetch_add(1, Ordering::Relaxed);
272+
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
273+
(ctr >> 8*7) as u8, (ctr >> 8*6) as u8, (ctr >> 8*5) as u8, (ctr >> 8*4) as u8, (ctr >> 8*3) as u8, (ctr >> 8*2) as u8, (ctr >> 8*1) as u8, 14, (ctr >> 8*0) as u8]
273274
}
275+
}
274276

275-
fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> Result<SharedSecret, ()> {
276-
let mut node_secret = self.get_node_secret(recipient)?;
277-
if let Some(tweak) = tweak {
278-
node_secret = node_secret.mul_tweak(tweak).unwrap();
279-
}
280-
Ok(SharedSecret::new(other_key, &node_secret))
277+
impl NodeSigner for KeyProvider {
278+
fn get_node_secret(&self, _recipient: Recipient) -> Result<SecretKey, ()> {
279+
Ok(self.node_secret.clone())
281280
}
282281

283282
fn get_inbound_payment_key_material(&self) -> KeyMaterial {
284283
self.inbound_payment_key.clone()
285284
}
285+
}
286286

287-
fn get_destination_script(&self) -> Script {
288-
let secp_ctx = Secp256k1::signing_only();
289-
let channel_monitor_claim_key = SecretKey::from_slice(&hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap();
290-
let our_channel_monitor_claim_key_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &channel_monitor_claim_key).serialize());
291-
Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0).push_slice(&our_channel_monitor_claim_key_hash[..]).into_script()
292-
}
293-
294-
fn get_shutdown_scriptpubkey(&self) -> ShutdownScript {
295-
let secp_ctx = Secp256k1::signing_only();
296-
let secret_key = SecretKey::from_slice(&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]).unwrap();
297-
let pubkey_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &secret_key).serialize());
298-
ShutdownScript::new_p2wpkh(&pubkey_hash)
299-
}
287+
impl SignerProvider for KeyProvider {
288+
type Signer = EnforcingSigner;
300289

301290
fn generate_channel_keys_id(&self, inbound: bool, _channel_value_satoshis: u64, _user_channel_id: u128) -> [u8; 32] {
302291
let ctr = self.counter.fetch_add(1, Ordering::Relaxed) as u8;
@@ -337,12 +326,6 @@ impl KeysInterface for KeyProvider {
337326
}, state, false)
338327
}
339328

340-
fn get_secure_random_bytes(&self) -> [u8; 32] {
341-
let ctr = self.counter.fetch_add(1, Ordering::Relaxed);
342-
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
343-
(ctr >> 8*7) as u8, (ctr >> 8*6) as u8, (ctr >> 8*5) as u8, (ctr >> 8*4) as u8, (ctr >> 8*3) as u8, (ctr >> 8*2) as u8, (ctr >> 8*1) as u8, 14, (ctr >> 8*0) as u8]
344-
}
345-
346329
fn read_chan_signer(&self, mut data: &[u8]) -> Result<EnforcingSigner, DecodeError> {
347330
let inner: InMemorySigner = ReadableArgs::read(&mut data, self.node_secret.clone())?;
348331
let state = Arc::new(Mutex::new(EnforcementState::new()));
@@ -354,11 +337,23 @@ impl KeysInterface for KeyProvider {
354337
))
355338
}
356339

357-
fn sign_invoice(&self, _hrp_bytes: &[u8], _invoice_data: &[u5], _recipient: Recipient) -> Result<RecoverableSignature, ()> {
358-
unreachable!()
340+
fn get_destination_script(&self) -> Script {
341+
let secp_ctx = Secp256k1::signing_only();
342+
let channel_monitor_claim_key = SecretKey::from_slice(&hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap();
343+
let our_channel_monitor_claim_key_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &channel_monitor_claim_key).serialize());
344+
Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0).push_slice(&our_channel_monitor_claim_key_hash[..]).into_script()
345+
}
346+
347+
fn get_shutdown_scriptpubkey(&self) -> ShutdownScript {
348+
let secp_ctx = Secp256k1::signing_only();
349+
let secret_key = SecretKey::from_slice(&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]).unwrap();
350+
let pubkey_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &secret_key).serialize());
351+
ShutdownScript::new_p2wpkh(&pubkey_hash)
359352
}
360353
}
361354

355+
impl KeysInterface for KeyProvider {}
356+
362357
#[inline]
363358
pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
364359
let input = Arc::new(InputData {

‎fuzz/src/onion_message.rs‎

Lines changed: 18 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ use bitcoin::secp256k1::{PublicKey, Scalar, SecretKey};
55
use bitcoin::secp256k1::ecdh::SharedSecret;
66
use bitcoin::secp256k1::ecdsa::RecoverableSignature;
77

8-
use lightning::chain::keysinterface::{Recipient, KeyMaterial, KeysInterface};
8+
use lightning::chain::keysinterface::{Recipient, KeyMaterial, KeysInterface, EntropySource, NodeSigner, SignerProvider};
99
use lightning::ln::msgs::{self, DecodeError, OnionMessageHandler};
1010
use lightning::ln::script::ShutdownScript;
1111
use lightning::util::enforcing_trait_impls::EnforcingSigner;
@@ -90,46 +90,41 @@ struct KeyProvider {
9090
node_secret: SecretKey,
9191
counter: AtomicU64,
9292
}
93-
impl KeysInterface for KeyProvider {
94-
type Signer = EnforcingSigner;
9593

96-
fn get_node_secret(&self, _recipient: Recipient) -> Result<SecretKey, ()> {
97-
Ok(self.node_secret.clone())
94+
impl EntropySource for KeyProvider {
95+
fn get_secure_random_bytes(&self) -> [u8; 32] {
96+
let ctr = self.counter.fetch_add(1, Ordering::Relaxed);
97+
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
98+
(ctr >> 8*7) as u8, (ctr >> 8*6) as u8, (ctr >> 8*5) as u8, (ctr >> 8*4) as u8, (ctr >> 8*3) as u8, (ctr >> 8*2) as u8, (ctr >> 8*1) as u8, 14, (ctr >> 8*0) as u8]
9899
}
100+
}
99101

100-
fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> Result<SharedSecret, ()> {
101-
let mut node_secret = self.get_node_secret(recipient)?;
102-
if let Some(tweak) = tweak {
103-
node_secret = node_secret.mul_tweak(tweak).map_err(|_| ())?;
104-
}
105-
Ok(SharedSecret::new(other_key, &node_secret))
102+
impl NodeSigner for KeyProvider {
103+
fn get_node_secret(&self, _recipient: Recipient) -> Result<SecretKey, ()> {
104+
Ok(self.node_secret.clone())
106105
}
107106

108107
fn get_inbound_payment_key_material(&self) -> KeyMaterial { unreachable!() }
108+
}
109109

110-
fn get_destination_script(&self) -> Script { unreachable!() }
111-
112-
fn get_shutdown_scriptpubkey(&self) -> ShutdownScript { unreachable!() }
110+
impl SignerProvider for KeyProvider {
111+
type Signer = EnforcingSigner;
113112

114113
fn generate_channel_keys_id(&self, _inbound: bool, _channel_value_satoshis: u64, _user_channel_id: u128) -> [u8; 32] { unreachable!() }
115114

116115
fn derive_channel_signer(&self, _channel_value_satoshis: u64, _channel_keys_id: [u8; 32]) -> Self::Signer {
117116
unreachable!()
118117
}
119118

120-
fn get_secure_random_bytes(&self) -> [u8; 32] {
121-
let ctr = self.counter.fetch_add(1, Ordering::Relaxed);
122-
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
123-
(ctr >> 8*7) as u8, (ctr >> 8*6) as u8, (ctr >> 8*5) as u8, (ctr >> 8*4) as u8, (ctr >> 8*3) as u8, (ctr >> 8*2) as u8, (ctr >> 8*1) as u8, 14, (ctr >> 8*0) as u8]
124-
}
125-
126119
fn read_chan_signer(&self, _data: &[u8]) -> Result<EnforcingSigner, DecodeError> { unreachable!() }
127120

128-
fn sign_invoice(&self, _hrp_bytes: &[u8], _invoice_data: &[u5], _recipient: Recipient) -> Result<RecoverableSignature, ()> {
129-
unreachable!()
130-
}
121+
fn get_destination_script(&self) -> Script { unreachable!() }
122+
123+
fn get_shutdown_scriptpubkey(&self) -> ShutdownScript { unreachable!() }
131124
}
132125

126+
impl KeysInterface for KeyProvider {}
127+
133128
#[cfg(test)]
134129
mod tests {
135130
use lightning::util::logger::{Logger, Record};

‎lightning-background-processor/src/lib.rs‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ extern crate lightning_rapid_gossip_sync;
1717
use lightning::chain;
1818
use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator};
1919
use lightning::chain::chainmonitor::{ChainMonitor, Persist};
20-
use lightning::chain::keysinterface::KeysInterface;
20+
use lightning::chain::keysinterface::{KeysInterface, SignerProvider};
2121
use lightning::ln::channelmanager::ChannelManager;
2222
use lightning::ln::msgs::{ChannelMessageHandler, OnionMessageHandler, RoutingMessageHandler};
2323
use lightning::ln::peer_handler::{CustomMessageHandler, PeerManager, SocketDescriptor};
@@ -352,7 +352,7 @@ pub async fn process_events_async<
352352
EventHandlerFuture: core::future::Future<Output = ()>,
353353
EventHandler: Fn(Event) -> EventHandlerFuture,
354354
PS: 'static + Deref + Send,
355-
M: 'static + Deref<Target = ChainMonitor<<K::Target as KeysInterface>::Signer, CF, T, F, L, P>> + Send + Sync,
355+
M: 'static + Deref<Target = ChainMonitor<<K::Target as SignerProvider>::Signer, CF, T, F, L, P>> + Send + Sync,
356356
CM: 'static + Deref<Target = ChannelManager<CW, T, K, F, L>> + Send + Sync,
357357
PGS: 'static + Deref<Target = P2PGossipSync<G, CA, L>> + Send + Sync,
358358
RGS: 'static + Deref<Target = RapidGossipSync<G, L>> + Send,
@@ -370,12 +370,12 @@ pub async fn process_events_async<
370370
where
371371
CA::Target: 'static + chain::Access,
372372
CF::Target: 'static + chain::Filter,
373-
CW::Target: 'static + chain::Watch<<K::Target as KeysInterface>::Signer>,
373+
CW::Target: 'static + chain::Watch<<K::Target as SignerProvider>::Signer>,
374374
T::Target: 'static + BroadcasterInterface,
375375
K::Target: 'static + KeysInterface,
376376
F::Target: 'static + FeeEstimator,
377377
L::Target: 'static + Logger,
378-
P::Target: 'static + Persist<<K::Target as KeysInterface>::Signer>,
378+
P::Target: 'static + Persist<<K::Target as SignerProvider>::Signer>,
379379
CMH::Target: 'static + ChannelMessageHandler,
380380
OMH::Target: 'static + OnionMessageHandler,
381381
RMH::Target: 'static + RoutingMessageHandler,
@@ -469,7 +469,7 @@ impl BackgroundProcessor {
469469
RMH: 'static + Deref + Send + Sync,
470470
EH: 'static + EventHandler + Send,
471471
PS: 'static + Deref + Send,
472-
M: 'static + Deref<Target = ChainMonitor<<K::Target as KeysInterface>::Signer, CF, T, F, L, P>> + Send + Sync,
472+
M: 'static + Deref<Target = ChainMonitor<<K::Target as SignerProvider>::Signer, CF, T, F, L, P>> + Send + Sync,
473473
CM: 'static + Deref<Target = ChannelManager<CW, T, K, F, L>> + Send + Sync,
474474
PGS: 'static + Deref<Target = P2PGossipSync<G, CA, L>> + Send + Sync,
475475
RGS: 'static + Deref<Target = RapidGossipSync<G, L>> + Send,
@@ -484,12 +484,12 @@ impl BackgroundProcessor {
484484
where
485485
CA::Target: 'static + chain::Access,
486486
CF::Target: 'static + chain::Filter,
487-
CW::Target: 'static + chain::Watch<<K::Target as KeysInterface>::Signer>,
487+
CW::Target: 'static + chain::Watch<<K::Target as SignerProvider>::Signer>,
488488
T::Target: 'static + BroadcasterInterface,
489489
K::Target: 'static + KeysInterface,
490490
F::Target: 'static + FeeEstimator,
491491
L::Target: 'static + Logger,
492-
P::Target: 'static + Persist<<K::Target as KeysInterface>::Signer>,
492+
P::Target: 'static + Persist<<K::Target as SignerProvider>::Signer>,
493493
CMH::Target: 'static + ChannelMessageHandler,
494494
OMH::Target: 'static + OnionMessageHandler,
495495
RMH::Target: 'static + RoutingMessageHandler,
@@ -570,7 +570,7 @@ mod tests {
570570
use bitcoin::network::constants::Network;
571571
use lightning::chain::{BestBlock, Confirm, chainmonitor};
572572
use lightning::chain::channelmonitor::ANTI_REORG_DELAY;
573-
use lightning::chain::keysinterface::{InMemorySigner, Recipient, KeysInterface, KeysManager};
573+
use lightning::chain::keysinterface::{InMemorySigner, Recipient, EntropySource, KeysInterface, KeysManager, NodeSigner};
574574
use lightning::chain::transaction::OutPoint;
575575
use lightning::get_event_msg;
576576
use lightning::ln::channelmanager::{self, BREAKDOWN_TIMEOUT, ChainParameters, ChannelManager, SimpleArcChannelManager};

‎lightning-invoice/src/payment.rs‎

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2079,10 +2079,11 @@ mod tests {
20792079

20802080
let event_handler = |_: Event| { panic!(); };
20812081
let invoice_payer = InvoicePayer::new(nodes[0].node, router, nodes[0].logger, event_handler, Retry::Attempts(1));
2082+
let secp_context = Secp256k1::signing_only();
20822083

20832084
assert!(invoice_payer.pay_invoice(&create_invoice_from_channelmanager_and_duration_since_epoch(
20842085
&nodes[1].node, nodes[1].keys_manager, nodes[1].logger, Currency::Bitcoin,
2085-
Some(100_010_000), "Invoice".to_string(), duration_since_epoch(), 3600).unwrap())
2086+
Some(100_010_000), "Invoice".to_string(), duration_since_epoch(), 3600, &secp_context).unwrap())
20862087
.is_ok());
20872088
let htlc_msgs = nodes[0].node.get_and_clear_pending_msg_events();
20882089
assert_eq!(htlc_msgs.len(), 2);
@@ -2124,10 +2125,11 @@ mod tests {
21242125

21252126
let event_handler = |_: Event| { panic!(); };
21262127
let invoice_payer = InvoicePayer::new(nodes[0].node, router, nodes[0].logger, event_handler, Retry::Attempts(1));
2128+
let secp_context = Secp256k1::signing_only();
21272129

21282130
assert!(invoice_payer.pay_invoice(&create_invoice_from_channelmanager_and_duration_since_epoch(
21292131
&nodes[1].node, nodes[1].keys_manager, nodes[1].logger, Currency::Bitcoin,
2130-
Some(100_010_000), "Invoice".to_string(), duration_since_epoch(), 3600).unwrap())
2132+
Some(100_010_000), "Invoice".to_string(), duration_since_epoch(), 3600, &secp_context).unwrap())
21312133
.is_ok());
21322134
let htlc_msgs = nodes[0].node.get_and_clear_pending_msg_events();
21332135
assert_eq!(htlc_msgs.len(), 2);
@@ -2205,10 +2207,11 @@ mod tests {
22052207
event_checker(event);
22062208
};
22072209
let invoice_payer = InvoicePayer::new(nodes[0].node, router, nodes[0].logger, event_handler, Retry::Attempts(1));
2210+
let secp_context = Secp256k1::signing_only();
22082211

22092212
assert!(invoice_payer.pay_invoice(&create_invoice_from_channelmanager_and_duration_since_epoch(
22102213
&nodes[1].node, nodes[1].keys_manager, nodes[1].logger, Currency::Bitcoin,
2211-
Some(100_010_000), "Invoice".to_string(), duration_since_epoch(), 3600).unwrap())
2214+
Some(100_010_000), "Invoice".to_string(), duration_since_epoch(), 3600, &secp_context).unwrap())
22122215
.is_ok());
22132216
let htlc_updates = SendEvent::from_node(&nodes[0]);
22142217
check_added_monitors!(nodes[0], 1);

0 commit comments

Comments
 (0)