use chain::transaction::OutPoint;
use chain::keysinterface;
use ln::features::{ChannelFeatures, InitFeatures};
-use ln::msgs;
-use ln::msgs::OptionalField;
+use ln::{msgs, wire};
use ln::script::ShutdownScript;
use routing::scoring::FixedPenaltyScorer;
use util::enforcing_trait_impls::{EnforcingSigner, EnforcementState};
use bitcoin::blockdata::transaction::{Transaction, TxOut};
use bitcoin::blockdata::script::{Builder, Script};
use bitcoin::blockdata::opcodes;
-use bitcoin::blockdata::block::BlockHeader;
+use bitcoin::blockdata::block::Block;
use bitcoin::network::constants::Network;
use bitcoin::hash_types::{BlockHash, Txid};
-use bitcoin::secp256k1::{SecretKey, PublicKey, Secp256k1, Signature};
-use bitcoin::secp256k1::recovery::RecoverableSignature;
+use bitcoin::secp256k1::{SecretKey, PublicKey, Secp256k1, ecdsa::Signature};
+use bitcoin::secp256k1::ecdh::SharedSecret;
+use bitcoin::secp256k1::ecdsa::RecoverableSignature;
use regex;
type Signer = EnforcingSigner;
fn get_node_secret(&self, _recipient: Recipient) -> Result<SecretKey, ()> { unreachable!(); }
+ fn ecdh(&self, _recipient: Recipient, _other_key: &PublicKey, _tweak: Option<&[u8; 32]>) -> Result<SharedSecret, ()> { unreachable!(); }
fn get_inbound_payment_key_material(&self) -> KeyMaterial { unreachable!(); }
fn get_destination_script(&self) -> Script { unreachable!(); }
fn get_shutdown_scriptpubkey(&self) -> ShutdownScript { unreachable!(); }
expect_channel_force_closed: Mutex::new(None),
}
}
+
+ pub fn complete_sole_pending_chan_update(&self, channel_id: &[u8; 32]) {
+ let (outpoint, _, latest_update) = self.latest_monitor_update_id.lock().unwrap().get(channel_id).unwrap().clone();
+ 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>) -> Result<(), chain::ChannelMonitorUpdateErr> {
update_res
}
- fn release_pending_monitor_events(&self) -> Vec<MonitorEvent> {
+ fn release_pending_monitor_events(&self) -> Vec<(OutPoint, Vec<MonitorEvent>, Option<PublicKey>)> {
return self.chain_monitor.release_pending_monitor_events();
}
}
pub struct TestBroadcaster {
pub txn_broadcasted: Mutex<Vec<Transaction>>,
- pub blocks: Arc<Mutex<Vec<(BlockHeader, u32)>>>,
+ pub blocks: Arc<Mutex<Vec<(Block, u32)>>>,
}
impl TestBroadcaster {
- pub fn new(blocks: Arc<Mutex<Vec<(BlockHeader, u32)>>>) -> TestBroadcaster {
+ pub fn new(blocks: Arc<Mutex<Vec<(Block, u32)>>>) -> TestBroadcaster {
TestBroadcaster { txn_broadcasted: Mutex::new(Vec::new()), blocks }
}
}
pub struct TestChannelMessageHandler {
pub pending_events: Mutex<Vec<events::MessageSendEvent>>,
+ expected_recv_msgs: Mutex<Option<Vec<wire::Message<()>>>>,
}
impl TestChannelMessageHandler {
pub fn new() -> Self {
TestChannelMessageHandler {
pending_events: Mutex::new(Vec::new()),
+ expected_recv_msgs: Mutex::new(None),
+ }
+ }
+
+ #[cfg(test)]
+ pub(crate) fn expect_receive_msg(&self, ev: wire::Message<()>) {
+ let mut expected_msgs = self.expected_recv_msgs.lock().unwrap();
+ if expected_msgs.is_none() { *expected_msgs = Some(Vec::new()); }
+ expected_msgs.as_mut().unwrap().push(ev);
+ }
+
+ fn received_msg(&self, _ev: wire::Message<()>) {
+ let mut msgs = self.expected_recv_msgs.lock().unwrap();
+ if msgs.is_none() { return; }
+ assert!(!msgs.as_ref().unwrap().is_empty(), "Received message when we weren't expecting one");
+ #[cfg(test)]
+ assert_eq!(msgs.as_ref().unwrap()[0], _ev);
+ msgs.as_mut().unwrap().remove(0);
+ }
+}
+
+impl Drop for TestChannelMessageHandler {
+ fn drop(&mut self) {
+ let l = self.expected_recv_msgs.lock().unwrap();
+ #[cfg(feature = "std")]
+ {
+ if !std::thread::panicking() {
+ assert!(l.is_none() || l.as_ref().unwrap().is_empty());
+ }
}
}
}
impl msgs::ChannelMessageHandler for TestChannelMessageHandler {
- fn handle_open_channel(&self, _their_node_id: &PublicKey, _their_features: InitFeatures, _msg: &msgs::OpenChannel) {}
- fn handle_accept_channel(&self, _their_node_id: &PublicKey, _their_features: InitFeatures, _msg: &msgs::AcceptChannel) {}
- fn handle_funding_created(&self, _their_node_id: &PublicKey, _msg: &msgs::FundingCreated) {}
- fn handle_funding_signed(&self, _their_node_id: &PublicKey, _msg: &msgs::FundingSigned) {}
- fn handle_funding_locked(&self, _their_node_id: &PublicKey, _msg: &msgs::FundingLocked) {}
- fn handle_shutdown(&self, _their_node_id: &PublicKey, _their_features: &InitFeatures, _msg: &msgs::Shutdown) {}
- fn handle_closing_signed(&self, _their_node_id: &PublicKey, _msg: &msgs::ClosingSigned) {}
- fn handle_update_add_htlc(&self, _their_node_id: &PublicKey, _msg: &msgs::UpdateAddHTLC) {}
- fn handle_update_fulfill_htlc(&self, _their_node_id: &PublicKey, _msg: &msgs::UpdateFulfillHTLC) {}
- fn handle_update_fail_htlc(&self, _their_node_id: &PublicKey, _msg: &msgs::UpdateFailHTLC) {}
- fn handle_update_fail_malformed_htlc(&self, _their_node_id: &PublicKey, _msg: &msgs::UpdateFailMalformedHTLC) {}
- fn handle_commitment_signed(&self, _their_node_id: &PublicKey, _msg: &msgs::CommitmentSigned) {}
- fn handle_revoke_and_ack(&self, _their_node_id: &PublicKey, _msg: &msgs::RevokeAndACK) {}
- fn handle_update_fee(&self, _their_node_id: &PublicKey, _msg: &msgs::UpdateFee) {}
- fn handle_channel_update(&self, _their_node_id: &PublicKey, _msg: &msgs::ChannelUpdate) {}
- fn handle_announcement_signatures(&self, _their_node_id: &PublicKey, _msg: &msgs::AnnouncementSignatures) {}
- fn handle_channel_reestablish(&self, _their_node_id: &PublicKey, _msg: &msgs::ChannelReestablish) {}
+ fn handle_open_channel(&self, _their_node_id: &PublicKey, _their_features: InitFeatures, msg: &msgs::OpenChannel) {
+ self.received_msg(wire::Message::OpenChannel(msg.clone()));
+ }
+ fn handle_accept_channel(&self, _their_node_id: &PublicKey, _their_features: InitFeatures, msg: &msgs::AcceptChannel) {
+ self.received_msg(wire::Message::AcceptChannel(msg.clone()));
+ }
+ fn handle_funding_created(&self, _their_node_id: &PublicKey, msg: &msgs::FundingCreated) {
+ self.received_msg(wire::Message::FundingCreated(msg.clone()));
+ }
+ fn handle_funding_signed(&self, _their_node_id: &PublicKey, msg: &msgs::FundingSigned) {
+ self.received_msg(wire::Message::FundingSigned(msg.clone()));
+ }
+ fn handle_channel_ready(&self, _their_node_id: &PublicKey, msg: &msgs::ChannelReady) {
+ self.received_msg(wire::Message::ChannelReady(msg.clone()));
+ }
+ fn handle_shutdown(&self, _their_node_id: &PublicKey, _their_features: &InitFeatures, msg: &msgs::Shutdown) {
+ self.received_msg(wire::Message::Shutdown(msg.clone()));
+ }
+ fn handle_closing_signed(&self, _their_node_id: &PublicKey, msg: &msgs::ClosingSigned) {
+ self.received_msg(wire::Message::ClosingSigned(msg.clone()));
+ }
+ fn handle_update_add_htlc(&self, _their_node_id: &PublicKey, msg: &msgs::UpdateAddHTLC) {
+ self.received_msg(wire::Message::UpdateAddHTLC(msg.clone()));
+ }
+ fn handle_update_fulfill_htlc(&self, _their_node_id: &PublicKey, msg: &msgs::UpdateFulfillHTLC) {
+ self.received_msg(wire::Message::UpdateFulfillHTLC(msg.clone()));
+ }
+ fn handle_update_fail_htlc(&self, _their_node_id: &PublicKey, msg: &msgs::UpdateFailHTLC) {
+ self.received_msg(wire::Message::UpdateFailHTLC(msg.clone()));
+ }
+ fn handle_update_fail_malformed_htlc(&self, _their_node_id: &PublicKey, msg: &msgs::UpdateFailMalformedHTLC) {
+ self.received_msg(wire::Message::UpdateFailMalformedHTLC(msg.clone()));
+ }
+ fn handle_commitment_signed(&self, _their_node_id: &PublicKey, msg: &msgs::CommitmentSigned) {
+ self.received_msg(wire::Message::CommitmentSigned(msg.clone()));
+ }
+ fn handle_revoke_and_ack(&self, _their_node_id: &PublicKey, msg: &msgs::RevokeAndACK) {
+ self.received_msg(wire::Message::RevokeAndACK(msg.clone()));
+ }
+ fn handle_update_fee(&self, _their_node_id: &PublicKey, msg: &msgs::UpdateFee) {
+ self.received_msg(wire::Message::UpdateFee(msg.clone()));
+ }
+ fn handle_channel_update(&self, _their_node_id: &PublicKey, _msg: &msgs::ChannelUpdate) {
+ // Don't call `received_msg` here as `TestRoutingMessageHandler` generates these sometimes
+ }
+ fn handle_announcement_signatures(&self, _their_node_id: &PublicKey, msg: &msgs::AnnouncementSignatures) {
+ self.received_msg(wire::Message::AnnouncementSignatures(msg.clone()));
+ }
+ fn handle_channel_reestablish(&self, _their_node_id: &PublicKey, msg: &msgs::ChannelReestablish) {
+ self.received_msg(wire::Message::ChannelReestablish(msg.clone()));
+ }
fn peer_disconnected(&self, _their_node_id: &PublicKey, _no_connection_possible: bool) {}
- fn peer_connected(&self, _their_node_id: &PublicKey, _msg: &msgs::Init) {}
- fn handle_error(&self, _their_node_id: &PublicKey, _msg: &msgs::ErrorMessage) {}
+ fn peer_connected(&self, _their_node_id: &PublicKey, _msg: &msgs::Init) {
+ // Don't bother with `received_msg` for Init as its auto-generated and we don't want to
+ // bother re-generating the expected Init message in all tests.
+ }
+ fn handle_error(&self, _their_node_id: &PublicKey, msg: &msgs::ErrorMessage) {
+ self.received_msg(wire::Message::Error(msg.clone()));
+ }
}
impl events::MessageSendEventsProvider for TestChannelMessageHandler {
flags: 0,
cltv_expiry_delta: 0,
htlc_minimum_msat: 0,
- htlc_maximum_msat: OptionalField::Absent,
+ htlc_maximum_msat: msgs::MAX_VALUE_MSAT,
fee_base_msat: 0,
fee_proportional_millionths: 0,
excess_data: vec![],
fn get_node_secret(&self, recipient: Recipient) -> Result<SecretKey, ()> {
self.backing.get_node_secret(recipient)
}
+ fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&[u8; 32]>) -> Result<SharedSecret, ()> {
+ self.backing.ecdh(recipient, other_key, tweak)
+ }
fn get_inbound_payment_key_material(&self) -> keysinterface::KeyMaterial {
self.backing.get_inbound_payment_key_material()
}
projects / rust-lightning / blobdiff