mirror of
https://github.com/lightningdevkit/rust-lightning.git
synced 2025-03-15 15:39:09 +01:00
Rename EnforcingSigner to TestChannelSigner
Since the advent of VLS, EnforcingSigner is only used now for testing.
This commit is contained in:
parent
61d896d519
commit
e38916d838
12 changed files with 72 additions and 72 deletions
|
@ -46,7 +46,7 @@ use lightning::ln::script::ShutdownScript;
|
|||
use lightning::ln::functional_test_utils::*;
|
||||
use lightning::offers::invoice::UnsignedBolt12Invoice;
|
||||
use lightning::offers::invoice_request::UnsignedInvoiceRequest;
|
||||
use lightning::util::enforcing_trait_impls::{EnforcingSigner, EnforcementState};
|
||||
use lightning::util::test_channel_signer::{TestChannelSigner, EnforcementState};
|
||||
use lightning::util::errors::APIError;
|
||||
use lightning::util::logger::Logger;
|
||||
use lightning::util::config::UserConfig;
|
||||
|
@ -118,7 +118,7 @@ struct TestChainMonitor {
|
|||
pub logger: Arc<dyn Logger>,
|
||||
pub keys: Arc<KeyProvider>,
|
||||
pub persister: Arc<TestPersister>,
|
||||
pub chain_monitor: Arc<chainmonitor::ChainMonitor<EnforcingSigner, Arc<dyn chain::Filter>, Arc<TestBroadcaster>, Arc<FuzzEstimator>, Arc<dyn Logger>, Arc<TestPersister>>>,
|
||||
pub chain_monitor: Arc<chainmonitor::ChainMonitor<TestChannelSigner, Arc<dyn chain::Filter>, Arc<TestBroadcaster>, Arc<FuzzEstimator>, Arc<dyn Logger>, Arc<TestPersister>>>,
|
||||
// If we reload a node with an old copy of ChannelMonitors, the ChannelManager deserialization
|
||||
// logic will automatically force-close our channels for us (as we don't have an up-to-date
|
||||
// monitor implying we are not able to punish misbehaving counterparties). Because this test
|
||||
|
@ -139,8 +139,8 @@ impl TestChainMonitor {
|
|||
}
|
||||
}
|
||||
}
|
||||
impl chain::Watch<EnforcingSigner> for TestChainMonitor {
|
||||
fn watch_channel(&self, funding_txo: OutPoint, monitor: channelmonitor::ChannelMonitor<EnforcingSigner>) -> chain::ChannelMonitorUpdateStatus {
|
||||
impl chain::Watch<TestChannelSigner> for TestChainMonitor {
|
||||
fn watch_channel(&self, funding_txo: OutPoint, monitor: channelmonitor::ChannelMonitor<TestChannelSigner>) -> chain::ChannelMonitorUpdateStatus {
|
||||
let mut ser = VecWriter(Vec::new());
|
||||
monitor.write(&mut ser).unwrap();
|
||||
if let Some(_) = self.latest_monitors.lock().unwrap().insert(funding_txo, (monitor.get_latest_update_id(), ser.0)) {
|
||||
|
@ -156,7 +156,7 @@ impl chain::Watch<EnforcingSigner> for TestChainMonitor {
|
|||
hash_map::Entry::Occupied(entry) => entry,
|
||||
hash_map::Entry::Vacant(_) => panic!("Didn't have monitor on update call"),
|
||||
};
|
||||
let deserialized_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingSigner>)>::
|
||||
let deserialized_monitor = <(BlockHash, channelmonitor::ChannelMonitor<TestChannelSigner>)>::
|
||||
read(&mut Cursor::new(&map_entry.get().1), (&*self.keys, &*self.keys)).unwrap().1;
|
||||
deserialized_monitor.update_monitor(update, &&TestBroadcaster{}, &FuzzEstimator { ret_val: atomic::AtomicU32::new(253) }, &self.logger).unwrap();
|
||||
let mut ser = VecWriter(Vec::new());
|
||||
|
@ -234,7 +234,7 @@ impl NodeSigner for KeyProvider {
|
|||
}
|
||||
|
||||
impl SignerProvider for KeyProvider {
|
||||
type Signer = EnforcingSigner;
|
||||
type Signer = TestChannelSigner;
|
||||
|
||||
fn generate_channel_keys_id(&self, _inbound: bool, _channel_value_satoshis: u64, _user_channel_id: u128) -> [u8; 32] {
|
||||
let id = self.rand_bytes_id.fetch_add(1, atomic::Ordering::Relaxed) as u8;
|
||||
|
@ -257,7 +257,7 @@ impl SignerProvider for KeyProvider {
|
|||
channel_keys_id,
|
||||
);
|
||||
let revoked_commitment = self.make_enforcement_state_cell(keys.commitment_seed);
|
||||
EnforcingSigner::new_with_revoked(keys, revoked_commitment, false)
|
||||
TestChannelSigner::new_with_revoked(keys, revoked_commitment, false)
|
||||
}
|
||||
|
||||
fn read_chan_signer(&self, buffer: &[u8]) -> Result<Self::Signer, DecodeError> {
|
||||
|
@ -266,7 +266,7 @@ impl SignerProvider for KeyProvider {
|
|||
let inner: InMemorySigner = ReadableArgs::read(&mut reader, self)?;
|
||||
let state = self.make_enforcement_state_cell(inner.commitment_seed);
|
||||
|
||||
Ok(EnforcingSigner {
|
||||
Ok(TestChannelSigner {
|
||||
inner,
|
||||
state,
|
||||
disable_revocation_policy_check: false,
|
||||
|
@ -477,7 +477,7 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out) {
|
|||
let mut monitors = HashMap::new();
|
||||
let mut old_monitors = $old_monitors.latest_monitors.lock().unwrap();
|
||||
for (outpoint, (update_id, monitor_ser)) in old_monitors.drain() {
|
||||
monitors.insert(outpoint, <(BlockHash, ChannelMonitor<EnforcingSigner>)>::read(&mut Cursor::new(&monitor_ser), (&*$keys_manager, &*$keys_manager)).expect("Failed to read monitor").1);
|
||||
monitors.insert(outpoint, <(BlockHash, ChannelMonitor<TestChannelSigner>)>::read(&mut Cursor::new(&monitor_ser), (&*$keys_manager, &*$keys_manager)).expect("Failed to read monitor").1);
|
||||
chain_monitor.latest_monitors.lock().unwrap().insert(outpoint, (update_id, monitor_ser));
|
||||
}
|
||||
let mut monitor_refs = HashMap::new();
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
use bitcoin::hash_types::BlockHash;
|
||||
|
||||
use lightning::chain::channelmonitor;
|
||||
use lightning::util::enforcing_trait_impls::EnforcingSigner;
|
||||
use lightning::util::test_channel_signer::TestChannelSigner;
|
||||
use lightning::util::ser::{ReadableArgs, Writer, Writeable};
|
||||
use lightning::util::test_utils::OnlyReadsKeysInterface;
|
||||
|
||||
|
@ -22,10 +22,10 @@ impl Writer for VecWriter {
|
|||
|
||||
#[inline]
|
||||
pub fn do_test<Out: test_logger::Output>(data: &[u8], _out: Out) {
|
||||
if let Ok((latest_block_hash, monitor)) = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingSigner>)>::read(&mut Cursor::new(data), (&OnlyReadsKeysInterface {}, &OnlyReadsKeysInterface {})) {
|
||||
if let Ok((latest_block_hash, monitor)) = <(BlockHash, channelmonitor::ChannelMonitor<TestChannelSigner>)>::read(&mut Cursor::new(data), (&OnlyReadsKeysInterface {}, &OnlyReadsKeysInterface {})) {
|
||||
let mut w = VecWriter(Vec::new());
|
||||
monitor.write(&mut w).unwrap();
|
||||
let deserialized_copy = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingSigner>)>::read(&mut Cursor::new(&w.0), (&OnlyReadsKeysInterface {}, &OnlyReadsKeysInterface {})).unwrap();
|
||||
let deserialized_copy = <(BlockHash, channelmonitor::ChannelMonitor<TestChannelSigner>)>::read(&mut Cursor::new(&w.0), (&OnlyReadsKeysInterface {}, &OnlyReadsKeysInterface {})).unwrap();
|
||||
assert!(latest_block_hash == deserialized_copy.0);
|
||||
assert!(monitor == deserialized_copy.1);
|
||||
}
|
||||
|
|
|
@ -47,7 +47,7 @@ use lightning::routing::utxo::UtxoLookup;
|
|||
use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteParameters, Router};
|
||||
use lightning::util::config::{UserConfig, MaxDustHTLCExposure};
|
||||
use lightning::util::errors::APIError;
|
||||
use lightning::util::enforcing_trait_impls::{EnforcingSigner, EnforcementState};
|
||||
use lightning::util::test_channel_signer::{TestChannelSigner, EnforcementState};
|
||||
use lightning::util::logger::Logger;
|
||||
use lightning::util::ser::{ReadableArgs, Writeable};
|
||||
|
||||
|
@ -180,13 +180,13 @@ impl<'a> std::hash::Hash for Peer<'a> {
|
|||
}
|
||||
|
||||
type ChannelMan<'a> = ChannelManager<
|
||||
Arc<chainmonitor::ChainMonitor<EnforcingSigner, Arc<dyn chain::Filter>, Arc<TestBroadcaster>, Arc<FuzzEstimator>, Arc<dyn Logger>, Arc<TestPersister>>>,
|
||||
Arc<chainmonitor::ChainMonitor<TestChannelSigner, Arc<dyn chain::Filter>, Arc<TestBroadcaster>, Arc<FuzzEstimator>, Arc<dyn Logger>, Arc<TestPersister>>>,
|
||||
Arc<TestBroadcaster>, Arc<KeyProvider>, Arc<KeyProvider>, Arc<KeyProvider>, Arc<FuzzEstimator>, &'a FuzzRouter, Arc<dyn Logger>>;
|
||||
type PeerMan<'a> = PeerManager<Peer<'a>, Arc<ChannelMan<'a>>, Arc<P2PGossipSync<Arc<NetworkGraph<Arc<dyn Logger>>>, Arc<dyn UtxoLookup>, Arc<dyn Logger>>>, IgnoringMessageHandler, Arc<dyn Logger>, IgnoringMessageHandler, Arc<KeyProvider>>;
|
||||
|
||||
struct MoneyLossDetector<'a> {
|
||||
manager: Arc<ChannelMan<'a>>,
|
||||
monitor: Arc<chainmonitor::ChainMonitor<EnforcingSigner, Arc<dyn chain::Filter>, Arc<TestBroadcaster>, Arc<FuzzEstimator>, Arc<dyn Logger>, Arc<TestPersister>>>,
|
||||
monitor: Arc<chainmonitor::ChainMonitor<TestChannelSigner, Arc<dyn chain::Filter>, Arc<TestBroadcaster>, Arc<FuzzEstimator>, Arc<dyn Logger>, Arc<TestPersister>>>,
|
||||
handler: PeerMan<'a>,
|
||||
|
||||
peers: &'a RefCell<[bool; 256]>,
|
||||
|
@ -200,7 +200,7 @@ struct MoneyLossDetector<'a> {
|
|||
impl<'a> MoneyLossDetector<'a> {
|
||||
pub fn new(peers: &'a RefCell<[bool; 256]>,
|
||||
manager: Arc<ChannelMan<'a>>,
|
||||
monitor: Arc<chainmonitor::ChainMonitor<EnforcingSigner, Arc<dyn chain::Filter>, Arc<TestBroadcaster>, Arc<FuzzEstimator>, Arc<dyn Logger>, Arc<TestPersister>>>,
|
||||
monitor: Arc<chainmonitor::ChainMonitor<TestChannelSigner, Arc<dyn chain::Filter>, Arc<TestBroadcaster>, Arc<FuzzEstimator>, Arc<dyn Logger>, Arc<TestPersister>>>,
|
||||
handler: PeerMan<'a>) -> Self {
|
||||
MoneyLossDetector {
|
||||
manager,
|
||||
|
@ -339,7 +339,7 @@ impl NodeSigner for KeyProvider {
|
|||
}
|
||||
|
||||
impl SignerProvider for KeyProvider {
|
||||
type Signer = EnforcingSigner;
|
||||
type Signer = TestChannelSigner;
|
||||
|
||||
fn generate_channel_keys_id(&self, inbound: bool, _channel_value_satoshis: u64, _user_channel_id: u128) -> [u8; 32] {
|
||||
let ctr = self.counter.fetch_add(1, Ordering::Relaxed) as u8;
|
||||
|
@ -351,7 +351,7 @@ impl SignerProvider for KeyProvider {
|
|||
let secp_ctx = Secp256k1::signing_only();
|
||||
let ctr = channel_keys_id[0];
|
||||
let (inbound, state) = self.signer_state.borrow().get(&ctr).unwrap().clone();
|
||||
EnforcingSigner::new_with_revoked(if inbound {
|
||||
TestChannelSigner::new_with_revoked(if inbound {
|
||||
InMemorySigner::new(
|
||||
&secp_ctx,
|
||||
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, ctr]).unwrap(),
|
||||
|
@ -380,11 +380,11 @@ impl SignerProvider for KeyProvider {
|
|||
}, state, false)
|
||||
}
|
||||
|
||||
fn read_chan_signer(&self, mut data: &[u8]) -> Result<EnforcingSigner, DecodeError> {
|
||||
fn read_chan_signer(&self, mut data: &[u8]) -> Result<TestChannelSigner, DecodeError> {
|
||||
let inner: InMemorySigner = ReadableArgs::read(&mut data, self)?;
|
||||
let state = Arc::new(Mutex::new(EnforcementState::new()));
|
||||
|
||||
Ok(EnforcingSigner::new_with_revoked(
|
||||
Ok(TestChannelSigner::new_with_revoked(
|
||||
inner,
|
||||
state,
|
||||
false
|
||||
|
|
|
@ -11,7 +11,7 @@ use lightning::ln::msgs::{self, DecodeError, OnionMessageHandler};
|
|||
use lightning::ln::script::ShutdownScript;
|
||||
use lightning::offers::invoice::UnsignedBolt12Invoice;
|
||||
use lightning::offers::invoice_request::UnsignedInvoiceRequest;
|
||||
use lightning::util::enforcing_trait_impls::EnforcingSigner;
|
||||
use lightning::util::test_channel_signer::TestChannelSigner;
|
||||
use lightning::util::logger::Logger;
|
||||
use lightning::util::ser::{Readable, Writeable, Writer};
|
||||
use lightning::onion_message::{CustomOnionMessageContents, CustomOnionMessageHandler, Destination, MessageRouter, OffersMessage, OffersMessageHandler, OnionMessagePath, OnionMessenger};
|
||||
|
@ -174,7 +174,7 @@ impl NodeSigner for KeyProvider {
|
|||
}
|
||||
|
||||
impl SignerProvider for KeyProvider {
|
||||
type Signer = EnforcingSigner;
|
||||
type Signer = TestChannelSigner;
|
||||
|
||||
fn generate_channel_keys_id(&self, _inbound: bool, _channel_value_satoshis: u64, _user_channel_id: u128) -> [u8; 32] { unreachable!() }
|
||||
|
||||
|
@ -182,7 +182,7 @@ impl SignerProvider for KeyProvider {
|
|||
unreachable!()
|
||||
}
|
||||
|
||||
fn read_chan_signer(&self, _data: &[u8]) -> Result<EnforcingSigner, DecodeError> { unreachable!() }
|
||||
fn read_chan_signer(&self, _data: &[u8]) -> Result<TestChannelSigner, DecodeError> { unreachable!() }
|
||||
|
||||
fn get_destination_script(&self) -> Result<Script, ()> { unreachable!() }
|
||||
|
||||
|
|
|
@ -2,19 +2,19 @@ use lightning::chain;
|
|||
use lightning::chain::{chainmonitor, channelmonitor};
|
||||
use lightning::chain::chainmonitor::MonitorUpdateId;
|
||||
use lightning::chain::transaction::OutPoint;
|
||||
use lightning::util::enforcing_trait_impls::EnforcingSigner;
|
||||
use lightning::util::test_channel_signer::TestChannelSigner;
|
||||
|
||||
use std::sync::Mutex;
|
||||
|
||||
pub struct TestPersister {
|
||||
pub update_ret: Mutex<chain::ChannelMonitorUpdateStatus>,
|
||||
}
|
||||
impl chainmonitor::Persist<EnforcingSigner> for TestPersister {
|
||||
fn persist_new_channel(&self, _funding_txo: OutPoint, _data: &channelmonitor::ChannelMonitor<EnforcingSigner>, _update_id: MonitorUpdateId) -> chain::ChannelMonitorUpdateStatus {
|
||||
impl chainmonitor::Persist<TestChannelSigner> for TestPersister {
|
||||
fn persist_new_channel(&self, _funding_txo: OutPoint, _data: &channelmonitor::ChannelMonitor<TestChannelSigner>, _update_id: MonitorUpdateId) -> chain::ChannelMonitorUpdateStatus {
|
||||
self.update_ret.lock().unwrap().clone()
|
||||
}
|
||||
|
||||
fn update_persisted_channel(&self, _funding_txo: OutPoint, _update: Option<&channelmonitor::ChannelMonitorUpdate>, _data: &channelmonitor::ChannelMonitor<EnforcingSigner>, _update_id: MonitorUpdateId) -> chain::ChannelMonitorUpdateStatus {
|
||||
fn update_persisted_channel(&self, _funding_txo: OutPoint, _update: Option<&channelmonitor::ChannelMonitorUpdate>, _data: &channelmonitor::ChannelMonitor<TestChannelSigner>, _update_id: MonitorUpdateId) -> chain::ChannelMonitorUpdateStatus {
|
||||
self.update_ret.lock().unwrap().clone()
|
||||
}
|
||||
}
|
||||
|
|
|
@ -23,7 +23,7 @@ use crate::ln::channelmanager::{RAACommitmentOrder, PaymentSendFailure, PaymentI
|
|||
use crate::ln::channel::AnnouncementSigsState;
|
||||
use crate::ln::msgs;
|
||||
use crate::ln::msgs::{ChannelMessageHandler, RoutingMessageHandler};
|
||||
use crate::util::enforcing_trait_impls::EnforcingSigner;
|
||||
use crate::util::test_channel_signer::TestChannelSigner;
|
||||
use crate::util::errors::APIError;
|
||||
use crate::util::ser::{ReadableArgs, Writeable};
|
||||
use crate::util::test_utils::TestBroadcaster;
|
||||
|
@ -111,7 +111,7 @@ fn test_monitor_and_persister_update_fail() {
|
|||
let chain_mon = {
|
||||
let new_monitor = {
|
||||
let monitor = nodes[0].chain_monitor.chain_monitor.get_monitor(outpoint).unwrap();
|
||||
let new_monitor = <(BlockHash, ChannelMonitor<EnforcingSigner>)>::read(
|
||||
let new_monitor = <(BlockHash, ChannelMonitor<TestChannelSigner>)>::read(
|
||||
&mut io::Cursor::new(&monitor.encode()), (nodes[0].keys_manager, nodes[0].keys_manager)).unwrap().1;
|
||||
assert!(new_monitor == *monitor);
|
||||
new_monitor
|
||||
|
|
|
@ -23,7 +23,7 @@ use crate::routing::router::{self, PaymentParameters, Route};
|
|||
use crate::ln::features::InitFeatures;
|
||||
use crate::ln::msgs;
|
||||
use crate::ln::msgs::{ChannelMessageHandler,RoutingMessageHandler};
|
||||
use crate::util::enforcing_trait_impls::EnforcingSigner;
|
||||
use crate::util::test_channel_signer::TestChannelSigner;
|
||||
use crate::util::scid_utils;
|
||||
use crate::util::test_utils;
|
||||
use crate::util::test_utils::{panicking, TestChainMonitor, TestScorer, TestKeysInterface};
|
||||
|
@ -520,7 +520,7 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
|
|||
for outpoint in self.chain_monitor.chain_monitor.list_monitors() {
|
||||
let mut w = test_utils::TestVecWriter(Vec::new());
|
||||
self.chain_monitor.chain_monitor.get_monitor(outpoint).unwrap().write(&mut w).unwrap();
|
||||
let (_, deserialized_monitor) = <(BlockHash, ChannelMonitor<EnforcingSigner>)>::read(
|
||||
let (_, deserialized_monitor) = <(BlockHash, ChannelMonitor<TestChannelSigner>)>::read(
|
||||
&mut io::Cursor::new(&w.0), (self.keys_manager, self.keys_manager)).unwrap();
|
||||
deserialized_monitors.push(deserialized_monitor);
|
||||
}
|
||||
|
@ -952,7 +952,7 @@ pub fn _reload_node<'a, 'b, 'c>(node: &'a Node<'a, 'b, 'c>, default_config: User
|
|||
let mut monitors_read = Vec::with_capacity(monitors_encoded.len());
|
||||
for encoded in monitors_encoded {
|
||||
let mut monitor_read = &encoded[..];
|
||||
let (_, monitor) = <(BlockHash, ChannelMonitor<EnforcingSigner>)>
|
||||
let (_, monitor) = <(BlockHash, ChannelMonitor<TestChannelSigner>)>
|
||||
::read(&mut monitor_read, (node.keys_manager, node.keys_manager)).unwrap();
|
||||
assert!(monitor_read.is_empty());
|
||||
monitors_read.push(monitor);
|
||||
|
@ -2646,7 +2646,7 @@ pub fn create_node_cfgs<'a>(node_count: usize, chanmon_cfgs: &'a Vec<TestChanMon
|
|||
create_node_cfgs_with_persisters(node_count, chanmon_cfgs, chanmon_cfgs.iter().map(|c| &c.persister).collect())
|
||||
}
|
||||
|
||||
pub fn create_node_cfgs_with_persisters<'a>(node_count: usize, chanmon_cfgs: &'a Vec<TestChanMonCfg>, persisters: Vec<&'a impl Persist<EnforcingSigner>>) -> Vec<NodeCfg<'a>> {
|
||||
pub fn create_node_cfgs_with_persisters<'a>(node_count: usize, chanmon_cfgs: &'a Vec<TestChanMonCfg>, persisters: Vec<&'a impl Persist<TestChannelSigner>>) -> Vec<NodeCfg<'a>> {
|
||||
let mut nodes = Vec::new();
|
||||
|
||||
for i in 0..node_count {
|
||||
|
|
|
@ -30,7 +30,7 @@ use crate::routing::router::{Path, PaymentParameters, Route, RouteHop, get_route
|
|||
use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, NodeFeatures};
|
||||
use crate::ln::msgs;
|
||||
use crate::ln::msgs::{ChannelMessageHandler, RoutingMessageHandler, ErrorAction};
|
||||
use crate::util::enforcing_trait_impls::EnforcingSigner;
|
||||
use crate::util::test_channel_signer::TestChannelSigner;
|
||||
use crate::util::test_utils::{self, WatchtowerPersister};
|
||||
use crate::util::errors::APIError;
|
||||
use crate::util::ser::{Writeable, ReadableArgs};
|
||||
|
@ -696,7 +696,7 @@ fn test_update_fee_that_funder_cannot_afford() {
|
|||
|
||||
const INITIAL_COMMITMENT_NUMBER: u64 = 281474976710654;
|
||||
|
||||
// Get the EnforcingSigner for each channel, which will be used to (1) get the keys
|
||||
// Get the TestChannelSigner for each channel, which will be used to (1) get the keys
|
||||
// needed to sign the new commitment tx and (2) sign the new commitment tx.
|
||||
let (local_revocation_basepoint, local_htlc_basepoint, local_funding) = {
|
||||
let per_peer_state = nodes[0].node.per_peer_state.read().unwrap();
|
||||
|
@ -1409,7 +1409,7 @@ fn test_fee_spike_violation_fails_htlc() {
|
|||
|
||||
const INITIAL_COMMITMENT_NUMBER: u64 = (1 << 48) - 1;
|
||||
|
||||
// Get the EnforcingSigner for each channel, which will be used to (1) get the keys
|
||||
// Get the TestChannelSigner for each channel, which will be used to (1) get the keys
|
||||
// needed to sign the new commitment tx and (2) sign the new commitment tx.
|
||||
let (local_revocation_basepoint, local_htlc_basepoint, local_secret, next_local_point, local_funding) = {
|
||||
let per_peer_state = nodes[0].node.per_peer_state.read().unwrap();
|
||||
|
@ -7639,7 +7639,7 @@ fn test_counterparty_raa_skip_no_crash() {
|
|||
// commitment transaction, we would have happily carried on and provided them the next
|
||||
// commitment transaction based on one RAA forward. This would probably eventually have led to
|
||||
// channel closure, but it would not have resulted in funds loss. Still, our
|
||||
// EnforcingSigner would have panicked as it doesn't like jumps into the future. Here, we
|
||||
// TestChannelSigner would have panicked as it doesn't like jumps into the future. Here, we
|
||||
// check simply that the channel is closed in response to such an RAA, but don't check whether
|
||||
// we decide to punish our counterparty for revoking their funds (as we don't currently
|
||||
// implement that).
|
||||
|
@ -8350,7 +8350,7 @@ fn test_update_err_monitor_lockdown() {
|
|||
let watchtower = {
|
||||
let new_monitor = {
|
||||
let monitor = nodes[0].chain_monitor.chain_monitor.get_monitor(outpoint).unwrap();
|
||||
let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingSigner>)>::read(
|
||||
let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<TestChannelSigner>)>::read(
|
||||
&mut io::Cursor::new(&monitor.encode()), (nodes[0].keys_manager, nodes[0].keys_manager)).unwrap().1;
|
||||
assert!(new_monitor == *monitor);
|
||||
new_monitor
|
||||
|
@ -8420,7 +8420,7 @@ fn test_concurrent_monitor_claim() {
|
|||
let watchtower_alice = {
|
||||
let new_monitor = {
|
||||
let monitor = nodes[0].chain_monitor.chain_monitor.get_monitor(outpoint).unwrap();
|
||||
let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingSigner>)>::read(
|
||||
let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<TestChannelSigner>)>::read(
|
||||
&mut io::Cursor::new(&monitor.encode()), (nodes[0].keys_manager, nodes[0].keys_manager)).unwrap().1;
|
||||
assert!(new_monitor == *monitor);
|
||||
new_monitor
|
||||
|
@ -8451,7 +8451,7 @@ fn test_concurrent_monitor_claim() {
|
|||
let watchtower_bob = {
|
||||
let new_monitor = {
|
||||
let monitor = nodes[0].chain_monitor.chain_monitor.get_monitor(outpoint).unwrap();
|
||||
let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingSigner>)>::read(
|
||||
let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<TestChannelSigner>)>::read(
|
||||
&mut io::Cursor::new(&monitor.encode()), (nodes[0].keys_manager, nodes[0].keys_manager)).unwrap().1;
|
||||
assert!(new_monitor == *monitor);
|
||||
new_monitor
|
||||
|
|
|
@ -18,7 +18,7 @@ use crate::events::{ClosureReason, Event, HTLCDestination, MessageSendEvent, Mes
|
|||
use crate::ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, PaymentId, RecipientOnionFields};
|
||||
use crate::ln::msgs;
|
||||
use crate::ln::msgs::{ChannelMessageHandler, RoutingMessageHandler, ErrorAction};
|
||||
use crate::util::enforcing_trait_impls::EnforcingSigner;
|
||||
use crate::util::test_channel_signer::TestChannelSigner;
|
||||
use crate::util::test_utils;
|
||||
use crate::util::errors::APIError;
|
||||
use crate::util::ser::{Writeable, ReadableArgs};
|
||||
|
@ -399,7 +399,7 @@ fn test_manager_serialize_deserialize_inconsistent_monitor() {
|
|||
let mut node_0_stale_monitors = Vec::new();
|
||||
for serialized in node_0_stale_monitors_serialized.iter() {
|
||||
let mut read = &serialized[..];
|
||||
let (_, monitor) = <(BlockHash, ChannelMonitor<EnforcingSigner>)>::read(&mut read, (keys_manager, keys_manager)).unwrap();
|
||||
let (_, monitor) = <(BlockHash, ChannelMonitor<TestChannelSigner>)>::read(&mut read, (keys_manager, keys_manager)).unwrap();
|
||||
assert!(read.is_empty());
|
||||
node_0_stale_monitors.push(monitor);
|
||||
}
|
||||
|
@ -407,7 +407,7 @@ fn test_manager_serialize_deserialize_inconsistent_monitor() {
|
|||
let mut node_0_monitors = Vec::new();
|
||||
for serialized in node_0_monitors_serialized.iter() {
|
||||
let mut read = &serialized[..];
|
||||
let (_, monitor) = <(BlockHash, ChannelMonitor<EnforcingSigner>)>::read(&mut read, (keys_manager, keys_manager)).unwrap();
|
||||
let (_, monitor) = <(BlockHash, ChannelMonitor<TestChannelSigner>)>::read(&mut read, (keys_manager, keys_manager)).unwrap();
|
||||
assert!(read.is_empty());
|
||||
node_0_monitors.push(monitor);
|
||||
}
|
||||
|
|
|
@ -56,5 +56,5 @@ pub mod test_utils;
|
|||
/// impls of traits that add exra enforcement on the way they're called. Useful for detecting state
|
||||
/// machine errors and used in fuzz targets and tests.
|
||||
#[cfg(any(test, feature = "_test_utils"))]
|
||||
pub mod enforcing_trait_impls;
|
||||
pub mod test_channel_signer;
|
||||
|
||||
|
|
|
@ -51,21 +51,21 @@ pub const INITIAL_REVOKED_COMMITMENT_NUMBER: u64 = 1 << 48;
|
|||
/// Note that before we do so we should ensure its serialization format has backwards- and
|
||||
/// forwards-compatibility prefix/suffixes!
|
||||
#[derive(Clone)]
|
||||
pub struct EnforcingSigner {
|
||||
pub struct TestChannelSigner {
|
||||
pub inner: InMemorySigner,
|
||||
/// Channel state used for policy enforcement
|
||||
pub state: Arc<Mutex<EnforcementState>>,
|
||||
pub disable_revocation_policy_check: bool,
|
||||
}
|
||||
|
||||
impl PartialEq for EnforcingSigner {
|
||||
impl PartialEq for TestChannelSigner {
|
||||
fn eq(&self, o: &Self) -> bool {
|
||||
Arc::ptr_eq(&self.state, &o.state)
|
||||
}
|
||||
}
|
||||
|
||||
impl EnforcingSigner {
|
||||
/// Construct an EnforcingSigner
|
||||
impl TestChannelSigner {
|
||||
/// Construct an TestChannelSigner
|
||||
pub fn new(inner: InMemorySigner) -> Self {
|
||||
let state = Arc::new(Mutex::new(EnforcementState::new()));
|
||||
Self {
|
||||
|
@ -75,7 +75,7 @@ impl EnforcingSigner {
|
|||
}
|
||||
}
|
||||
|
||||
/// Construct an EnforcingSigner with externally managed storage
|
||||
/// Construct an TestChannelSigner with externally managed storage
|
||||
///
|
||||
/// Since there are multiple copies of this struct for each channel, some coordination is needed
|
||||
/// so that all copies are aware of enforcement state. A pointer to this state is provided
|
||||
|
@ -96,7 +96,7 @@ impl EnforcingSigner {
|
|||
}
|
||||
}
|
||||
|
||||
impl ChannelSigner for EnforcingSigner {
|
||||
impl ChannelSigner for TestChannelSigner {
|
||||
fn get_per_commitment_point(&self, idx: u64, secp_ctx: &Secp256k1<secp256k1::All>) -> PublicKey {
|
||||
self.inner.get_per_commitment_point(idx, secp_ctx)
|
||||
}
|
||||
|
@ -128,7 +128,7 @@ impl ChannelSigner for EnforcingSigner {
|
|||
}
|
||||
}
|
||||
|
||||
impl EcdsaChannelSigner for EnforcingSigner {
|
||||
impl EcdsaChannelSigner for TestChannelSigner {
|
||||
fn sign_counterparty_commitment(&self, commitment_tx: &CommitmentTransaction, preimages: Vec<PaymentPreimage>, secp_ctx: &Secp256k1<secp256k1::All>) -> Result<(Signature, Vec<Signature>), ()> {
|
||||
self.verify_counterparty_commitment_tx(commitment_tx, secp_ctx);
|
||||
|
||||
|
@ -241,11 +241,11 @@ impl EcdsaChannelSigner for EnforcingSigner {
|
|||
}
|
||||
}
|
||||
|
||||
impl WriteableEcdsaChannelSigner for EnforcingSigner {}
|
||||
impl WriteableEcdsaChannelSigner for TestChannelSigner {}
|
||||
|
||||
impl Writeable for EnforcingSigner {
|
||||
impl Writeable for TestChannelSigner {
|
||||
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
|
||||
// EnforcingSigner has two fields - `inner` ([`InMemorySigner`]) and `state`
|
||||
// TestChannelSigner has two fields - `inner` ([`InMemorySigner`]) and `state`
|
||||
// ([`EnforcementState`]). `inner` is serialized here and deserialized by
|
||||
// [`SignerProvider::read_chan_signer`]. `state` is managed by [`SignerProvider`]
|
||||
// and will be serialized as needed by the implementation of that trait.
|
||||
|
@ -254,7 +254,7 @@ impl Writeable for EnforcingSigner {
|
|||
}
|
||||
}
|
||||
|
||||
impl EnforcingSigner {
|
||||
impl TestChannelSigner {
|
||||
fn verify_counterparty_commitment_tx<'a, T: secp256k1::Signing + secp256k1::Verification>(&self, commitment_tx: &'a CommitmentTransaction, secp_ctx: &Secp256k1<T>) -> TrustedCommitmentTransaction<'a> {
|
||||
commitment_tx.verify(&self.inner.get_channel_parameters().as_counterparty_broadcastable(),
|
||||
self.inner.counterparty_pubkeys(), self.inner.pubkeys(), secp_ctx)
|
||||
|
@ -268,7 +268,7 @@ impl EnforcingSigner {
|
|||
}
|
||||
}
|
||||
|
||||
/// The state used by [`EnforcingSigner`] in order to enforce policy checks
|
||||
/// The state used by [`TestChannelSigner`] in order to enforce policy checks
|
||||
///
|
||||
/// This structure is maintained by KeysInterface since we may have multiple copies of
|
||||
/// the signer and they must coordinate their state.
|
|
@ -35,7 +35,7 @@ use crate::routing::router::{find_route, InFlightHtlcs, Path, Route, RouteParame
|
|||
use crate::routing::scoring::{ChannelUsage, ScoreUpdate, ScoreLookUp};
|
||||
use crate::sync::RwLock;
|
||||
use crate::util::config::UserConfig;
|
||||
use crate::util::enforcing_trait_impls::{EnforcingSigner, EnforcementState};
|
||||
use crate::util::test_channel_signer::{TestChannelSigner, EnforcementState};
|
||||
use crate::util::logger::{Logger, Level, Record};
|
||||
use crate::util::ser::{Readable, ReadableArgs, Writer, Writeable};
|
||||
|
||||
|
@ -175,7 +175,7 @@ impl EntropySource for OnlyReadsKeysInterface {
|
|||
fn get_secure_random_bytes(&self) -> [u8; 32] { [0; 32] }}
|
||||
|
||||
impl SignerProvider for OnlyReadsKeysInterface {
|
||||
type Signer = EnforcingSigner;
|
||||
type Signer = TestChannelSigner;
|
||||
|
||||
fn generate_channel_keys_id(&self, _inbound: bool, _channel_value_satoshis: u64, _user_channel_id: u128) -> [u8; 32] { unreachable!(); }
|
||||
|
||||
|
@ -185,7 +185,7 @@ impl SignerProvider for OnlyReadsKeysInterface {
|
|||
let inner: InMemorySigner = ReadableArgs::read(&mut reader, self)?;
|
||||
let state = Arc::new(Mutex::new(EnforcementState::new()));
|
||||
|
||||
Ok(EnforcingSigner::new_with_revoked(
|
||||
Ok(TestChannelSigner::new_with_revoked(
|
||||
inner,
|
||||
state,
|
||||
false
|
||||
|
@ -197,10 +197,10 @@ impl SignerProvider for OnlyReadsKeysInterface {
|
|||
}
|
||||
|
||||
pub struct TestChainMonitor<'a> {
|
||||
pub added_monitors: Mutex<Vec<(OutPoint, channelmonitor::ChannelMonitor<EnforcingSigner>)>>,
|
||||
pub added_monitors: Mutex<Vec<(OutPoint, channelmonitor::ChannelMonitor<TestChannelSigner>)>>,
|
||||
pub monitor_updates: Mutex<HashMap<ChannelId, Vec<channelmonitor::ChannelMonitorUpdate>>>,
|
||||
pub latest_monitor_update_id: Mutex<HashMap<ChannelId, (OutPoint, u64, MonitorUpdateId)>>,
|
||||
pub chain_monitor: chainmonitor::ChainMonitor<EnforcingSigner, &'a TestChainSource, &'a chaininterface::BroadcasterInterface, &'a TestFeeEstimator, &'a TestLogger, &'a chainmonitor::Persist<EnforcingSigner>>,
|
||||
pub chain_monitor: chainmonitor::ChainMonitor<TestChannelSigner, &'a TestChainSource, &'a chaininterface::BroadcasterInterface, &'a TestFeeEstimator, &'a TestLogger, &'a chainmonitor::Persist<TestChannelSigner>>,
|
||||
pub keys_manager: &'a TestKeysInterface,
|
||||
/// If this is set to Some(), the next update_channel call (not watch_channel) must be a
|
||||
/// ChannelForceClosed event for the given channel_id with should_broadcast set to the given
|
||||
|
@ -208,7 +208,7 @@ pub struct TestChainMonitor<'a> {
|
|||
pub expect_channel_force_closed: Mutex<Option<(ChannelId, bool)>>,
|
||||
}
|
||||
impl<'a> TestChainMonitor<'a> {
|
||||
pub fn new(chain_source: Option<&'a TestChainSource>, broadcaster: &'a chaininterface::BroadcasterInterface, logger: &'a TestLogger, fee_estimator: &'a TestFeeEstimator, persister: &'a chainmonitor::Persist<EnforcingSigner>, keys_manager: &'a TestKeysInterface) -> Self {
|
||||
pub fn new(chain_source: Option<&'a TestChainSource>, broadcaster: &'a chaininterface::BroadcasterInterface, logger: &'a TestLogger, fee_estimator: &'a TestFeeEstimator, persister: &'a chainmonitor::Persist<TestChannelSigner>, keys_manager: &'a TestKeysInterface) -> Self {
|
||||
Self {
|
||||
added_monitors: Mutex::new(Vec::new()),
|
||||
monitor_updates: Mutex::new(HashMap::new()),
|
||||
|
@ -224,13 +224,13 @@ impl<'a> TestChainMonitor<'a> {
|
|||
self.chain_monitor.channel_monitor_updated(outpoint, latest_update).unwrap();
|
||||
}
|
||||
}
|
||||
impl<'a> chain::Watch<EnforcingSigner> for TestChainMonitor<'a> {
|
||||
fn watch_channel(&self, funding_txo: OutPoint, monitor: channelmonitor::ChannelMonitor<EnforcingSigner>) -> chain::ChannelMonitorUpdateStatus {
|
||||
impl<'a> chain::Watch<TestChannelSigner> for TestChainMonitor<'a> {
|
||||
fn watch_channel(&self, funding_txo: OutPoint, monitor: channelmonitor::ChannelMonitor<TestChannelSigner>) -> chain::ChannelMonitorUpdateStatus {
|
||||
// At every point where we get a monitor update, we should be able to send a useful monitor
|
||||
// to a watchtower and disk...
|
||||
let mut w = TestVecWriter(Vec::new());
|
||||
monitor.write(&mut w).unwrap();
|
||||
let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingSigner>)>::read(
|
||||
let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<TestChannelSigner>)>::read(
|
||||
&mut io::Cursor::new(&w.0), (self.keys_manager, self.keys_manager)).unwrap().1;
|
||||
assert!(new_monitor == monitor);
|
||||
self.latest_monitor_update_id.lock().unwrap().insert(funding_txo.to_channel_id(),
|
||||
|
@ -264,7 +264,7 @@ impl<'a> chain::Watch<EnforcingSigner> for TestChainMonitor<'a> {
|
|||
let monitor = self.chain_monitor.get_monitor(funding_txo).unwrap();
|
||||
w.0.clear();
|
||||
monitor.write(&mut w).unwrap();
|
||||
let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingSigner>)>::read(
|
||||
let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<TestChannelSigner>)>::read(
|
||||
&mut io::Cursor::new(&w.0), (self.keys_manager, self.keys_manager)).unwrap().1;
|
||||
assert!(new_monitor == *monitor);
|
||||
self.added_monitors.lock().unwrap().push((funding_txo, new_monitor));
|
||||
|
@ -979,16 +979,16 @@ impl NodeSigner for TestKeysInterface {
|
|||
}
|
||||
|
||||
impl SignerProvider for TestKeysInterface {
|
||||
type Signer = EnforcingSigner;
|
||||
type Signer = TestChannelSigner;
|
||||
|
||||
fn generate_channel_keys_id(&self, inbound: bool, channel_value_satoshis: u64, user_channel_id: u128) -> [u8; 32] {
|
||||
self.backing.generate_channel_keys_id(inbound, channel_value_satoshis, user_channel_id)
|
||||
}
|
||||
|
||||
fn derive_channel_signer(&self, channel_value_satoshis: u64, channel_keys_id: [u8; 32]) -> EnforcingSigner {
|
||||
fn derive_channel_signer(&self, channel_value_satoshis: u64, channel_keys_id: [u8; 32]) -> TestChannelSigner {
|
||||
let keys = self.backing.derive_channel_signer(channel_value_satoshis, channel_keys_id);
|
||||
let state = self.make_enforcement_state_cell(keys.commitment_seed);
|
||||
EnforcingSigner::new_with_revoked(keys, state, self.disable_revocation_policy_check)
|
||||
TestChannelSigner::new_with_revoked(keys, state, self.disable_revocation_policy_check)
|
||||
}
|
||||
|
||||
fn read_chan_signer(&self, buffer: &[u8]) -> Result<Self::Signer, msgs::DecodeError> {
|
||||
|
@ -997,7 +997,7 @@ impl SignerProvider for TestKeysInterface {
|
|||
let inner: InMemorySigner = ReadableArgs::read(&mut reader, self)?;
|
||||
let state = self.make_enforcement_state_cell(inner.commitment_seed);
|
||||
|
||||
Ok(EnforcingSigner::new_with_revoked(
|
||||
Ok(TestChannelSigner::new_with_revoked(
|
||||
inner,
|
||||
state,
|
||||
self.disable_revocation_policy_check
|
||||
|
@ -1038,10 +1038,10 @@ impl TestKeysInterface {
|
|||
self
|
||||
}
|
||||
|
||||
pub fn derive_channel_keys(&self, channel_value_satoshis: u64, id: &[u8; 32]) -> EnforcingSigner {
|
||||
pub fn derive_channel_keys(&self, channel_value_satoshis: u64, id: &[u8; 32]) -> TestChannelSigner {
|
||||
let keys = self.backing.derive_channel_keys(channel_value_satoshis, id);
|
||||
let state = self.make_enforcement_state_cell(keys.commitment_seed);
|
||||
EnforcingSigner::new_with_revoked(keys, state, self.disable_revocation_policy_check)
|
||||
TestChannelSigner::new_with_revoked(keys, state, self.disable_revocation_policy_check)
|
||||
}
|
||||
|
||||
fn make_enforcement_state_cell(&self, commitment_seed: [u8; 32]) -> Arc<Mutex<EnforcementState>> {
|
||||
|
|
Loading…
Add table
Reference in a new issue