Skip to content

Commit f7211fb

Browse files
TheBlueMattTheBlueMatt
authored
Merge pull request #1910 from arik-so/2022-12-keys-interface-name-split
Split KeysInterface into EntropySource, NodeSigner, and SignerProvider
2 parents e64ebe8 + 9d7bb73 commit f7211fb

27 files changed

+391
-284
lines changed

‎fuzz/src/chanmon_consistency.rs

+35-23
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,13 +160,26 @@ 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

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
170+
}
171+
}
172+
173+
impl NodeSigner for KeyProvider {
166174
fn get_node_secret(&self, _recipient: Recipient) -> Result<SecretKey, ()> {
167175
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())
168176
}
169177

178+
fn get_node_id(&self, recipient: Recipient) -> Result<PublicKey, ()> {
179+
let secp_ctx = Secp256k1::signing_only();
180+
Ok(PublicKey::from_secret_key(&secp_ctx, &self.get_node_secret(recipient)?))
181+
}
182+
170183
fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> Result<SharedSecret, ()> {
171184
let mut node_secret = self.get_node_secret(recipient)?;
172185
if let Some(tweak) = tweak {
@@ -179,19 +192,13 @@ impl KeysInterface for KeyProvider {
179192
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])
180193
}
181194

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()
195+
fn sign_invoice(&self, _hrp_bytes: &[u8], _invoice_data: &[u5], _recipient: Recipient) -> Result<RecoverableSignature, ()> {
196+
unreachable!()
187197
}
198+
}
188199

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-
}
200+
impl SignerProvider for KeyProvider {
201+
type Signer = EnforcingSigner;
195202

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

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-
227227
fn read_chan_signer(&self, buffer: &[u8]) -> Result<Self::Signer, DecodeError> {
228228
let mut reader = std::io::Cursor::new(buffer);
229229

@@ -237,11 +237,23 @@ impl KeysInterface for KeyProvider {
237237
})
238238
}
239239

240-
fn sign_invoice(&self, _hrp_bytes: &[u8], _invoice_data: &[u5], _recipient: Recipient) -> Result<RecoverableSignature, ()> {
241-
unreachable!()
240+
fn get_destination_script(&self) -> Script {
241+
let secp_ctx = Secp256k1::signing_only();
242+
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();
243+
let our_channel_monitor_claim_key_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &channel_monitor_claim_key).serialize());
244+
Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0).push_slice(&our_channel_monitor_claim_key_hash[..]).into_script()
245+
}
246+
247+
fn get_shutdown_scriptpubkey(&self) -> ShutdownScript {
248+
let secp_ctx = Secp256k1::signing_only();
249+
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();
250+
let pubkey_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &secret_key).serialize());
251+
ShutdownScript::new_p2wpkh(&pubkey_hash)
242252
}
243253
}
244254

255+
impl KeysInterface for KeyProvider {}
256+
245257
impl KeyProvider {
246258
fn make_enforcement_state_cell(&self, commitment_seed: [u8; 32]) -> Arc<Mutex<EnforcementState>> {
247259
let mut revoked_commitments = self.enforcement_states.lock().unwrap();

‎fuzz/src/full_stack.rs

+34-22
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,13 +265,25 @@ 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

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]
274+
}
275+
}
276+
277+
impl NodeSigner for KeyProvider {
271278
fn get_node_secret(&self, _recipient: Recipient) -> Result<SecretKey, ()> {
272279
Ok(self.node_secret.clone())
273280
}
274281

282+
fn get_node_id(&self, recipient: Recipient) -> Result<PublicKey, ()> {
283+
let secp_ctx = Secp256k1::signing_only();
284+
Ok(PublicKey::from_secret_key(&secp_ctx, &self.get_node_secret(recipient)?))
285+
}
286+
275287
fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> Result<SharedSecret, ()> {
276288
let mut node_secret = self.get_node_secret(recipient)?;
277289
if let Some(tweak) = tweak {
@@ -284,19 +296,13 @@ impl KeysInterface for KeyProvider {
284296
self.inbound_payment_key.clone()
285297
}
286298

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()
299+
fn sign_invoice(&self, _hrp_bytes: &[u8], _invoice_data: &[u5], _recipient: Recipient) -> Result<RecoverableSignature, ()> {
300+
unreachable!()
292301
}
302+
}
293303

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-
}
304+
impl SignerProvider for KeyProvider {
305+
type Signer = EnforcingSigner;
300306

301307
fn generate_channel_keys_id(&self, inbound: bool, _channel_value_satoshis: u64, _user_channel_id: u128) -> [u8; 32] {
302308
let ctr = self.counter.fetch_add(1, Ordering::Relaxed) as u8;
@@ -337,12 +343,6 @@ impl KeysInterface for KeyProvider {
337343
}, state, false)
338344
}
339345

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-
346346
fn read_chan_signer(&self, mut data: &[u8]) -> Result<EnforcingSigner, DecodeError> {
347347
let inner: InMemorySigner = ReadableArgs::read(&mut data, self.node_secret.clone())?;
348348
let state = Arc::new(Mutex::new(EnforcementState::new()));
@@ -354,11 +354,23 @@ impl KeysInterface for KeyProvider {
354354
))
355355
}
356356

357-
fn sign_invoice(&self, _hrp_bytes: &[u8], _invoice_data: &[u5], _recipient: Recipient) -> Result<RecoverableSignature, ()> {
358-
unreachable!()
357+
fn get_destination_script(&self) -> Script {
358+
let secp_ctx = Secp256k1::signing_only();
359+
let channel_monitor_claim_key = SecretKey::from_slice(&hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap();
360+
let our_channel_monitor_claim_key_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &channel_monitor_claim_key).serialize());
361+
Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0).push_slice(&our_channel_monitor_claim_key_hash[..]).into_script()
362+
}
363+
364+
fn get_shutdown_scriptpubkey(&self) -> ShutdownScript {
365+
let secp_ctx = Secp256k1::signing_only();
366+
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();
367+
let pubkey_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &secret_key).serialize());
368+
ShutdownScript::new_p2wpkh(&pubkey_hash)
359369
}
360370
}
361371

372+
impl KeysInterface for KeyProvider {}
373+
362374
#[inline]
363375
pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
364376
let input = Arc::new(InputData {

‎fuzz/src/onion_message.rs

+27-15
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@
11
// Imports that need to be added manually
22
use bitcoin::bech32::u5;
33
use bitcoin::blockdata::script::Script;
4-
use bitcoin::secp256k1::{PublicKey, Scalar, SecretKey};
4+
use bitcoin::secp256k1::{PublicKey, Scalar, Secp256k1, 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,13 +90,25 @@ struct KeyProvider {
9090
node_secret: SecretKey,
9191
counter: AtomicU64,
9292
}
93-
impl KeysInterface for KeyProvider {
94-
type Signer = EnforcingSigner;
9593

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]
99+
}
100+
}
101+
102+
impl NodeSigner for KeyProvider {
96103
fn get_node_secret(&self, _recipient: Recipient) -> Result<SecretKey, ()> {
97104
Ok(self.node_secret.clone())
98105
}
99106

107+
fn get_node_id(&self, recipient: Recipient) -> Result<PublicKey, ()> {
108+
let secp_ctx = Secp256k1::signing_only();
109+
Ok(PublicKey::from_secret_key(&secp_ctx, &self.get_node_secret(recipient)?))
110+
}
111+
100112
fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> Result<SharedSecret, ()> {
101113
let mut node_secret = self.get_node_secret(recipient)?;
102114
if let Some(tweak) = tweak {
@@ -107,29 +119,29 @@ impl KeysInterface for KeyProvider {
107119

108120
fn get_inbound_payment_key_material(&self) -> KeyMaterial { unreachable!() }
109121

110-
fn get_destination_script(&self) -> Script { unreachable!() }
122+
fn sign_invoice(&self, _hrp_bytes: &[u8], _invoice_data: &[u5], _recipient: Recipient) -> Result<RecoverableSignature, ()> {
123+
unreachable!()
124+
}
125+
}
111126

112-
fn get_shutdown_scriptpubkey(&self) -> ShutdownScript { unreachable!() }
127+
impl SignerProvider for KeyProvider {
128+
type Signer = EnforcingSigner;
113129

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

116132
fn derive_channel_signer(&self, _channel_value_satoshis: u64, _channel_keys_id: [u8; 32]) -> Self::Signer {
117133
unreachable!()
118134
}
119135

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-
126136
fn read_chan_signer(&self, _data: &[u8]) -> Result<EnforcingSigner, DecodeError> { unreachable!() }
127137

128-
fn sign_invoice(&self, _hrp_bytes: &[u8], _invoice_data: &[u5], _recipient: Recipient) -> Result<RecoverableSignature, ()> {
129-
unreachable!()
130-
}
138+
fn get_destination_script(&self) -> Script { unreachable!() }
139+
140+
fn get_shutdown_scriptpubkey(&self) -> ShutdownScript { unreachable!() }
131141
}
132142

143+
impl KeysInterface for KeyProvider {}
144+
133145
#[cfg(test)]
134146
mod tests {
135147
use lightning::util::logger::{Logger, Record};

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

+8-8
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};

0 commit comments

Comments
 (0)