// You may not use this file except in accordance with one or both of these
// licenses.
-use chain;
-use chain::WatchedOutput;
-use chain::chaininterface;
-use chain::chaininterface::ConfirmationTarget;
-use chain::chainmonitor;
-use chain::chainmonitor::MonitorUpdateId;
-use chain::channelmonitor;
-use chain::channelmonitor::MonitorEvent;
-use chain::transaction::OutPoint;
-use chain::keysinterface;
-use ln::channelmanager;
-use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
-use ln::{msgs, wire};
-use ln::script::ShutdownScript;
-use routing::scoring::FixedPenaltyScorer;
-use util::enforcing_trait_impls::{EnforcingSigner, EnforcementState};
-use util::events;
-use util::logger::{Logger, Level, Record};
-use util::ser::{Readable, ReadableArgs, Writer, Writeable};
+use crate::chain;
+use crate::chain::WatchedOutput;
+use crate::chain::chaininterface;
+use crate::chain::chaininterface::ConfirmationTarget;
+use crate::chain::chainmonitor;
+use crate::chain::chainmonitor::MonitorUpdateId;
+use crate::chain::channelmonitor;
+use crate::chain::channelmonitor::MonitorEvent;
+use crate::chain::transaction::OutPoint;
+use crate::chain::keysinterface;
+use crate::ln::channelmanager;
+use crate::ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
+use crate::ln::{msgs, wire};
+use crate::ln::script::ShutdownScript;
+use crate::routing::gossip::NetworkGraph;
+use crate::routing::router::{find_route, InFlightHtlcs, Route, RouteHop, RouteParameters, Router, ScorerAccountingForInFlightHtlcs};
+use crate::routing::scoring::FixedPenaltyScorer;
+use crate::util::enforcing_trait_impls::{EnforcingSigner, EnforcementState};
+use crate::util::events;
+use crate::util::logger::{Logger, Level, Record};
+use crate::util::ser::{Readable, ReadableArgs, Writer, Writeable};
use bitcoin::blockdata::constants::genesis_block;
use bitcoin::blockdata::transaction::{Transaction, TxOut};
use regex;
-use io;
-use prelude::*;
+use crate::io;
+use crate::prelude::*;
use core::time::Duration;
-use sync::{Mutex, Arc};
+use crate::sync::{Mutex, Arc};
use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use core::mem;
use bitcoin::bech32::u5;
-use chain::keysinterface::{InMemorySigner, Recipient, KeyMaterial};
+use crate::chain::keysinterface::{InMemorySigner, Recipient, KeyMaterial, EntropySource, NodeSigner, SignerProvider};
#[cfg(feature = "std")]
use std::time::{SystemTime, UNIX_EPOCH};
}
}
+pub struct TestRouter<'a> {
+ pub network_graph: Arc<NetworkGraph<&'a TestLogger>>,
+}
+
+impl<'a> TestRouter<'a> {
+ pub fn new(network_graph: Arc<NetworkGraph<&'a TestLogger>>) -> Self {
+ Self { network_graph }
+ }
+}
+
+impl<'a> Router for TestRouter<'a> {
+ fn find_route(
+ &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&channelmanager::ChannelDetails]>,
+ inflight_htlcs: &InFlightHtlcs
+ ) -> Result<Route, msgs::LightningError> {
+ let logger = TestLogger::new();
+ find_route(
+ payer, params, &self.network_graph, first_hops, &logger,
+ &ScorerAccountingForInFlightHtlcs::new(TestScorer::with_penalty(0), &inflight_htlcs),
+ &[42; 32]
+ )
+ }
+ fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
+ fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}
+ fn notify_payment_probe_successful(&self, _path: &[&RouteHop]) {}
+ fn notify_payment_probe_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
+}
+
pub struct OnlyReadsKeysInterface {}
-impl keysinterface::KeysInterface for OnlyReadsKeysInterface {
- type Signer = EnforcingSigner;
+impl EntropySource for OnlyReadsKeysInterface {
+ fn get_secure_random_bytes(&self) -> [u8; 32] { [0; 32] }}
+
+impl NodeSigner for OnlyReadsKeysInterface {
fn get_node_secret(&self, _recipient: Recipient) -> Result<SecretKey, ()> { unreachable!(); }
+ fn get_node_id(&self, recipient: Recipient) -> Result<PublicKey, ()> {
+ let secp_ctx = Secp256k1::signing_only();
+ Ok(PublicKey::from_secret_key(&secp_ctx, &self.get_node_secret(recipient)?))
+ }
fn ecdh(&self, _recipient: Recipient, _other_key: &PublicKey, _tweak: Option<&Scalar>) -> 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!(); }
- fn get_channel_signer(&self, _inbound: bool, _channel_value_satoshis: u64) -> EnforcingSigner { unreachable!(); }
- fn get_secure_random_bytes(&self) -> [u8; 32] { [0; 32] }
+ fn sign_invoice(&self, _hrp_bytes: &[u8], _invoice_data: &[u5], _recipient: Recipient) -> Result<RecoverableSignature, ()> { unreachable!(); }
+}
+
+impl SignerProvider for OnlyReadsKeysInterface {
+ type Signer = EnforcingSigner;
+
+ fn generate_channel_keys_id(&self, _inbound: bool, _channel_value_satoshis: u64, _user_channel_id: u128) -> [u8; 32] { unreachable!(); }
+
+ fn derive_channel_signer(&self, _channel_value_satoshis: u64, _channel_keys_id: [u8; 32]) -> Self::Signer { unreachable!(); }
fn read_chan_signer(&self, mut reader: &[u8]) -> Result<Self::Signer, msgs::DecodeError> {
let dummy_sk = SecretKey::from_slice(&[42; 32]).unwrap();
false
))
}
- fn sign_invoice(&self, _hrp_bytes: &[u8], _invoice_data: &[u5], _recipient: Recipient) -> Result<RecoverableSignature, ()> { unreachable!(); }
+
+ fn get_destination_script(&self) -> Script { unreachable!(); }
+ fn get_shutdown_scriptpubkey(&self) -> ShutdownScript { unreachable!(); }
+}
+
+impl keysinterface::KeysInterface for OnlyReadsKeysInterface {
}
pub struct TestChainMonitor<'a> {
}
pub struct TestPersister {
- pub update_ret: Mutex<chain::ChannelMonitorUpdateStatus>,
- /// If this is set to Some(), after the next return, we'll always return this until update_ret
- /// is changed:
- pub next_update_ret: Mutex<Option<chain::ChannelMonitorUpdateStatus>>,
+ /// The queue of update statuses we'll return. If none are queued, ::Completed will always be
+ /// returned.
+ pub update_rets: Mutex<VecDeque<chain::ChannelMonitorUpdateStatus>>,
/// When we get an update_persisted_channel call with no ChannelMonitorUpdate, we insert the
/// MonitorUpdateId here.
pub chain_sync_monitor_persistences: Mutex<HashMap<OutPoint, HashSet<MonitorUpdateId>>>,
impl TestPersister {
pub fn new() -> Self {
Self {
- update_ret: Mutex::new(chain::ChannelMonitorUpdateStatus::Completed),
- next_update_ret: Mutex::new(None),
+ update_rets: Mutex::new(VecDeque::new()),
chain_sync_monitor_persistences: Mutex::new(HashMap::new()),
offchain_monitor_updates: Mutex::new(HashMap::new()),
}
}
- pub fn set_update_ret(&self, ret: chain::ChannelMonitorUpdateStatus) {
- *self.update_ret.lock().unwrap() = ret;
- }
-
- pub fn set_next_update_ret(&self, next_ret: Option<chain::ChannelMonitorUpdateStatus>) {
- *self.next_update_ret.lock().unwrap() = next_ret;
+ /// Queue an update status to return.
+ pub fn set_update_ret(&self, next_ret: chain::ChannelMonitorUpdateStatus) {
+ self.update_rets.lock().unwrap().push_back(next_ret);
}
}
impl<Signer: keysinterface::Sign> chainmonitor::Persist<Signer> for TestPersister {
fn persist_new_channel(&self, _funding_txo: OutPoint, _data: &channelmonitor::ChannelMonitor<Signer>, _id: MonitorUpdateId) -> chain::ChannelMonitorUpdateStatus {
- let ret = self.update_ret.lock().unwrap().clone();
- if let Some(next_ret) = self.next_update_ret.lock().unwrap().take() {
- *self.update_ret.lock().unwrap() = next_ret;
+ if let Some(update_ret) = self.update_rets.lock().unwrap().pop_front() {
+ return update_ret
}
- ret
+ chain::ChannelMonitorUpdateStatus::Completed
}
fn update_persisted_channel(&self, funding_txo: OutPoint, update: &Option<channelmonitor::ChannelMonitorUpdate>, _data: &channelmonitor::ChannelMonitor<Signer>, update_id: MonitorUpdateId) -> chain::ChannelMonitorUpdateStatus {
- let ret = self.update_ret.lock().unwrap().clone();
- if let Some(next_ret) = self.next_update_ret.lock().unwrap().take() {
- *self.update_ret.lock().unwrap() = next_ret;
+ let mut ret = chain::ChannelMonitorUpdateStatus::Completed;
+ if let Some(update_ret) = self.update_rets.lock().unwrap().pop_front() {
+ ret = update_ret;
}
if update.is_none() {
self.chain_sync_monitor_persistences.lock().unwrap().entry(funding_txo).or_insert(HashSet::new()).insert(update_id);
expectations: Mutex<Option<VecDeque<OnGetShutdownScriptpubkey>>>,
}
-impl keysinterface::KeysInterface for TestKeysInterface {
- type Signer = EnforcingSigner;
+impl EntropySource for TestKeysInterface {
+ fn get_secure_random_bytes(&self) -> [u8; 32] {
+ let override_random_bytes = self.override_random_bytes.lock().unwrap();
+ if let Some(bytes) = &*override_random_bytes {
+ return *bytes;
+ }
+ self.backing.get_secure_random_bytes()
+ }
+}
+impl NodeSigner for TestKeysInterface {
fn get_node_secret(&self, recipient: Recipient) -> Result<SecretKey, ()> {
self.backing.get_node_secret(recipient)
}
+
+ fn get_node_id(&self, recipient: Recipient) -> Result<PublicKey, ()> {
+ self.backing.get_node_id(recipient)
+ }
+
fn ecdh(&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>) -> 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()
}
- fn get_destination_script(&self) -> Script { self.backing.get_destination_script() }
- fn get_shutdown_scriptpubkey(&self) -> ShutdownScript {
- match &mut *self.expectations.lock().unwrap() {
- None => self.backing.get_shutdown_scriptpubkey(),
- Some(expectations) => match expectations.pop_front() {
- None => panic!("Unexpected get_shutdown_scriptpubkey"),
- Some(expectation) => expectation.returns,
- },
- }
+ fn sign_invoice(&self, hrp_bytes: &[u8], invoice_data: &[u5], recipient: Recipient) -> Result<RecoverableSignature, ()> {
+ self.backing.sign_invoice(hrp_bytes, invoice_data, recipient)
}
+}
- fn get_channel_signer(&self, inbound: bool, channel_value_satoshis: u64) -> EnforcingSigner {
- let keys = self.backing.get_channel_signer(inbound, channel_value_satoshis);
- let state = self.make_enforcement_state_cell(keys.commitment_seed);
- EnforcingSigner::new_with_revoked(keys, state, self.disable_revocation_policy_check)
+impl SignerProvider for TestKeysInterface {
+ type Signer = EnforcingSigner;
+
+ 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 get_secure_random_bytes(&self) -> [u8; 32] {
- let override_random_bytes = self.override_random_bytes.lock().unwrap();
- if let Some(bytes) = &*override_random_bytes {
- return *bytes;
- }
- self.backing.get_secure_random_bytes()
+ fn derive_channel_signer(&self, channel_value_satoshis: u64, channel_keys_id: [u8; 32]) -> EnforcingSigner {
+ 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)
}
fn read_chan_signer(&self, buffer: &[u8]) -> Result<Self::Signer, msgs::DecodeError> {
))
}
- fn sign_invoice(&self, hrp_bytes: &[u8], invoice_data: &[u5], recipient: Recipient) -> Result<RecoverableSignature, ()> {
- self.backing.sign_invoice(hrp_bytes, invoice_data, recipient)
+ fn get_destination_script(&self) -> Script { self.backing.get_destination_script() }
+
+ fn get_shutdown_scriptpubkey(&self) -> ShutdownScript {
+ match &mut *self.expectations.lock().unwrap() {
+ None => self.backing.get_shutdown_scriptpubkey(),
+ Some(expectations) => match expectations.pop_front() {
+ None => panic!("Unexpected get_shutdown_scriptpubkey"),
+ Some(expectation) => expectation.returns,
+ },
+ }
}
}
+impl keysinterface::KeysInterface for TestKeysInterface {}
+
impl TestKeysInterface {
pub fn new(seed: &[u8; 32], network: Network) -> Self {
let now = Duration::from_secs(genesis_block(network).header.time as u64);
}
}
- /// Sets an expectation that [`keysinterface::KeysInterface::get_shutdown_scriptpubkey`] is
+ /// Sets an expectation that [`keysinterface::SignerProvider::get_shutdown_scriptpubkey`] is
/// called.
pub fn expect(&self, expectation: OnGetShutdownScriptpubkey) -> &Self {
self.expectations.lock().unwrap()
}
}
-/// An expectation that [`keysinterface::KeysInterface::get_shutdown_scriptpubkey`] was called and
+/// An expectation that [`keysinterface::SignerProvider::get_shutdown_scriptpubkey`] was called and
/// returns a [`ShutdownScript`].
pub struct OnGetShutdownScriptpubkey {
/// A shutdown script used to close a channel.
projects / rust-lightning / blobdiff