Add tests for defaulting to creating tlv onions

[rust-lightning] / lightning / src / routing / mod.rs

diff --git a/lightning/src/routing/mod.rs b/lightning/src/routing/mod.rs
index a2454f6a3fec0da3dc2e960420750af904dff215..a3ab6c0c1b30ff04e50ab5892b91ef358a1980f2 100644 (file)
--- a/lightning/src/routing/mod.rs
+++ b/lightning/src/routing/mod.rs
@@ -11,66 +11,4 @@
 
 pub mod network_graph;
 pub mod router;
-pub mod scorer;
-
-use routing::network_graph::NodeId;
-use routing::router::RouteHop;
-
-use prelude::*;
-use core::cell::{RefCell, RefMut};
-use core::ops::DerefMut;
-use sync::{Mutex, MutexGuard};
-
-/// An interface used to score payment channels for path finding.
-///
-///    Scoring is in terms of fees willing to be paid in order to avoid routing through a channel.
-pub trait Score {
-       /// Returns the fee in msats willing to be paid to avoid routing through the given channel
-       /// in the direction from `source` to `target`.
-       fn channel_penalty_msat(&self, short_channel_id: u64, source: &NodeId, target: &NodeId) -> u64;
-
-       /// Handles updating channel penalties after failing to route through a channel.
-       fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64);
-}
-
-/// A scorer that is accessed under a lock.
-///
-/// Needed so that calls to [`Score::channel_penalty_msat`] in [`find_route`] can be made while
-/// having shared ownership of a scorer but without requiring internal locking in [`Score`]
-/// implementations. Internal locking would be detrimental to route finding performance and could
-/// result in [`Score::channel_penalty_msat`] returning a different value for the same channel.
-///
-/// [`find_route`]: crate::routing::router::find_route
-pub trait LockableScore<'a> {
-       /// The locked [`Score`] type.
-       type Locked: 'a + Score;
-
-       /// Returns the locked scorer.
-       fn lock(&'a self) -> Self::Locked;
-}
-
-impl<'a, T: 'a + Score> LockableScore<'a> for Mutex<T> {
-       type Locked = MutexGuard<'a, T>;
-
-       fn lock(&'a self) -> MutexGuard<'a, T> {
-               Mutex::lock(self).unwrap()
-       }
-}
-
-impl<'a, T: 'a + Score> LockableScore<'a> for RefCell<T> {
-       type Locked = RefMut<'a, T>;
-
-       fn lock(&'a self) -> RefMut<'a, T> {
-               self.borrow_mut()
-       }
-}
-
-impl<S: Score, T: DerefMut<Target=S>> Score for T {
-       fn channel_penalty_msat(&self, short_channel_id: u64, source: &NodeId, target: &NodeId) -> u64 {
-               self.deref().channel_penalty_msat(short_channel_id, source, target)
-       }
-
-       fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) {
-               self.deref_mut().payment_path_failed(path, short_channel_id)
-       }
-}
+pub mod scoring;