Struct lightning::routing::scoring::ProbabilisticScorerUsingTime

pub struct ProbabilisticScorerUsingTime<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> where
    L::Target: Logger, { /* private fields */ }

Probabilistic Score implementation.

(C-not exported) generally all users should use the ProbabilisticScorer type alias.

Implementations

impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> ProbabilisticScorerUsingTime<G, L, T> where
    L::Target: Logger, 

pub fn new(
    params: ProbabilisticScoringParameters,
    network_graph: G,
    logger: L
) -> Self

Creates a new scorer using the given scoring parameters for sending payments from a node through a network graph.

pub fn debug_log_liquidity_stats(&self)

Dump the contents of this scorer into the configured logger.

Note that this writes roughly one line per channel for which we have a liquidity estimate, which may be a substantial amount of log output.

pub fn estimated_channel_liquidity_range(
    &self,
    scid: u64,
    target: &NodeId
) -> Option<(u64, u64)>

Query the estimated minimum and maximum liquidity available for sending a payment over the channel with scid towards the given target node.

pub fn add_banned(&mut self, node_id: &NodeId)

Marks the node with the given node_id as banned, i.e., it will be avoided during path finding.

pub fn remove_banned(&mut self, node_id: &NodeId)

Removes the node with the given node_id from the list of nodes to avoid.

pub fn set_manual_penalty(&mut self, node_id: &NodeId, penalty: u64)

Sets a manual penalty for the given node.

pub fn remove_manual_penalty(&mut self, node_id: &NodeId)

Removes the node with the given node_id from the list of manual penalties.

pub fn clear_manual_penalties(&mut self)

Clears the list of manual penalties that are applied during path finding.

Trait Implementations

impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> ReadableArgs<(ProbabilisticScoringParameters, G, L)> for ProbabilisticScorerUsingTime<G, L, T> where
    L::Target: Logger, 

fn read<R: Read>(
    r: &mut R,
    args: (ProbabilisticScoringParameters, G, L)
) -> Result<Self, DecodeError>

Reads a Self in from the given Read

impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> Score for ProbabilisticScorerUsingTime<G, L, T> where
    L::Target: Logger, 

fn channel_penalty_msat(
    &self,
    short_channel_id: u64,
    source: &NodeId,
    target: &NodeId,
    usage: ChannelUsage
) -> u64

Returns the fee in msats willing to be paid to avoid routing send_amt_msat through the given channel in the direction from source to target.

fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64)

Handles updating channel penalties after failing to route through a channel.

fn payment_path_successful(&mut self, path: &[&RouteHop])

Handles updating channel penalties after successfully routing along a path.

fn probe_failed(&mut self, path: &[&RouteHop], short_channel_id: u64)

Handles updating channel penalties after a probe over the given path failed.

fn probe_successful(&mut self, path: &[&RouteHop])

Handles updating channel penalties after a probe over the given path succeeded.

impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> Writeable for ProbabilisticScorerUsingTime<G, L, T> where
    L::Target: Logger, 

fn write<W: Writer>(&self, w: &mut W) -> Result<(), Error>

Writes self out to the given Writer

fn encode(&self) -> Vec<u8>

Writes self out to a Vec

fn serialized_length(&self) -> usize

Gets the length of this object after it has been serialized. This can be overridden to optimize cases where we prepend an object with its length.