You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
412 lines
18 KiB
412 lines
18 KiB
# -*- coding: utf-8 -*-
|
|
#
|
|
# Electrum - lightweight Bitcoin client
|
|
# Copyright (C) 2018 The Electrum developers
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person
|
|
# obtaining a copy of this software and associated documentation files
|
|
# (the "Software"), to deal in the Software without restriction,
|
|
# including without limitation the rights to use, copy, modify, merge,
|
|
# publish, distribute, sublicense, and/or sell copies of the Software,
|
|
# and to permit persons to whom the Software is furnished to do so,
|
|
# subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be
|
|
# included in all copies or substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
# SOFTWARE.
|
|
|
|
import queue
|
|
from collections import defaultdict
|
|
from typing import Sequence, List, Tuple, Optional, Dict, NamedTuple, TYPE_CHECKING, Set
|
|
import time
|
|
import attr
|
|
|
|
from .util import bh2u, profiler
|
|
from .logging import Logger
|
|
from .lnutil import (NUM_MAX_EDGES_IN_PAYMENT_PATH, ShortChannelID, LnFeatures,
|
|
NBLOCK_CLTV_EXPIRY_TOO_FAR_INTO_FUTURE)
|
|
from .channel_db import ChannelDB, Policy, NodeInfo
|
|
|
|
if TYPE_CHECKING:
|
|
from .lnchannel import Channel
|
|
|
|
|
|
class NoChannelPolicy(Exception):
|
|
def __init__(self, short_channel_id: bytes):
|
|
short_channel_id = ShortChannelID.normalize(short_channel_id)
|
|
super().__init__(f'cannot find channel policy for short_channel_id: {short_channel_id}')
|
|
|
|
|
|
class LNPathInconsistent(Exception): pass
|
|
|
|
|
|
def fee_for_edge_msat(forwarded_amount_msat: int, fee_base_msat: int, fee_proportional_millionths: int) -> int:
|
|
return fee_base_msat \
|
|
+ (forwarded_amount_msat * fee_proportional_millionths // 1_000_000)
|
|
|
|
|
|
@attr.s(slots=True)
|
|
class PathEdge:
|
|
start_node = attr.ib(type=bytes, kw_only=True, repr=lambda val: val.hex())
|
|
end_node = attr.ib(type=bytes, kw_only=True, repr=lambda val: val.hex())
|
|
short_channel_id = attr.ib(type=ShortChannelID, kw_only=True, repr=lambda val: str(val))
|
|
|
|
@property
|
|
def node_id(self) -> bytes:
|
|
# legacy compat # TODO rm
|
|
return self.end_node
|
|
|
|
@attr.s
|
|
class RouteEdge(PathEdge):
|
|
fee_base_msat = attr.ib(type=int, kw_only=True)
|
|
fee_proportional_millionths = attr.ib(type=int, kw_only=True)
|
|
cltv_expiry_delta = attr.ib(type=int, kw_only=True)
|
|
node_features = attr.ib(type=int, kw_only=True, repr=lambda val: str(int(val))) # note: for end node!
|
|
|
|
def fee_for_edge(self, amount_msat: int) -> int:
|
|
return fee_for_edge_msat(forwarded_amount_msat=amount_msat,
|
|
fee_base_msat=self.fee_base_msat,
|
|
fee_proportional_millionths=self.fee_proportional_millionths)
|
|
|
|
@classmethod
|
|
def from_channel_policy(
|
|
cls,
|
|
*,
|
|
channel_policy: 'Policy',
|
|
short_channel_id: bytes,
|
|
start_node: bytes,
|
|
end_node: bytes,
|
|
node_info: Optional[NodeInfo], # for end_node
|
|
) -> 'RouteEdge':
|
|
assert isinstance(short_channel_id, bytes)
|
|
assert type(start_node) is bytes
|
|
assert type(end_node) is bytes
|
|
return RouteEdge(
|
|
start_node=start_node,
|
|
end_node=end_node,
|
|
short_channel_id=ShortChannelID.normalize(short_channel_id),
|
|
fee_base_msat=channel_policy.fee_base_msat,
|
|
fee_proportional_millionths=channel_policy.fee_proportional_millionths,
|
|
cltv_expiry_delta=channel_policy.cltv_expiry_delta,
|
|
node_features=node_info.features if node_info else 0)
|
|
|
|
def is_sane_to_use(self, amount_msat: int) -> bool:
|
|
# TODO revise ad-hoc heuristics
|
|
# cltv cannot be more than 2 weeks
|
|
if self.cltv_expiry_delta > 14 * 144:
|
|
return False
|
|
total_fee = self.fee_for_edge(amount_msat)
|
|
if not is_fee_sane(total_fee, payment_amount_msat=amount_msat):
|
|
return False
|
|
return True
|
|
|
|
def has_feature_varonion(self) -> bool:
|
|
features = LnFeatures(self.node_features)
|
|
return features.supports(LnFeatures.VAR_ONION_OPT)
|
|
|
|
def is_trampoline(self) -> bool:
|
|
return False
|
|
|
|
@attr.s
|
|
class TrampolineEdge(RouteEdge):
|
|
invoice_routing_info = attr.ib(type=bytes, default=None)
|
|
invoice_features = attr.ib(type=int, default=None)
|
|
# this is re-defined from parent just to specify a default value:
|
|
short_channel_id = attr.ib(default=ShortChannelID(8), repr=lambda val: str(val))
|
|
|
|
def is_trampoline(self):
|
|
return True
|
|
|
|
|
|
LNPaymentPath = Sequence[PathEdge]
|
|
LNPaymentRoute = Sequence[RouteEdge]
|
|
|
|
|
|
def is_route_sane_to_use(route: LNPaymentRoute, invoice_amount_msat: int, min_final_cltv_expiry: int) -> bool:
|
|
"""Run some sanity checks on the whole route, before attempting to use it.
|
|
called when we are paying; so e.g. lower cltv is better
|
|
"""
|
|
if len(route) > NUM_MAX_EDGES_IN_PAYMENT_PATH:
|
|
return False
|
|
amt = invoice_amount_msat
|
|
cltv = min_final_cltv_expiry
|
|
for route_edge in reversed(route[1:]):
|
|
if not route_edge.is_sane_to_use(amt): return False
|
|
amt += route_edge.fee_for_edge(amt)
|
|
cltv += route_edge.cltv_expiry_delta
|
|
total_fee = amt - invoice_amount_msat
|
|
# TODO revise ad-hoc heuristics
|
|
if cltv > NBLOCK_CLTV_EXPIRY_TOO_FAR_INTO_FUTURE:
|
|
return False
|
|
if not is_fee_sane(total_fee, payment_amount_msat=invoice_amount_msat):
|
|
return False
|
|
return True
|
|
|
|
|
|
def is_fee_sane(fee_msat: int, *, payment_amount_msat: int) -> bool:
|
|
# fees <= 5 sat are fine
|
|
if fee_msat <= 5_000:
|
|
return True
|
|
# fees <= 1 % of payment are fine
|
|
if 100 * fee_msat <= payment_amount_msat:
|
|
return True
|
|
return False
|
|
|
|
|
|
|
|
class LNPathFinder(Logger):
|
|
|
|
def __init__(self, channel_db: ChannelDB):
|
|
Logger.__init__(self)
|
|
self.channel_db = channel_db
|
|
|
|
def _edge_cost(
|
|
self,
|
|
*,
|
|
short_channel_id: bytes,
|
|
start_node: bytes,
|
|
end_node: bytes,
|
|
payment_amt_msat: int,
|
|
ignore_costs=False,
|
|
is_mine=False,
|
|
my_channels: Dict[ShortChannelID, 'Channel'] = None,
|
|
private_route_edges: Dict[ShortChannelID, RouteEdge] = None,
|
|
) -> Tuple[float, int]:
|
|
"""Heuristic cost (distance metric) of going through a channel.
|
|
Returns (heuristic_cost, fee_for_edge_msat).
|
|
"""
|
|
if private_route_edges is None:
|
|
private_route_edges = {}
|
|
channel_info = self.channel_db.get_channel_info(
|
|
short_channel_id, my_channels=my_channels, private_route_edges=private_route_edges)
|
|
if channel_info is None:
|
|
return float('inf'), 0
|
|
channel_policy = self.channel_db.get_policy_for_node(
|
|
short_channel_id, start_node, my_channels=my_channels, private_route_edges=private_route_edges)
|
|
if channel_policy is None:
|
|
return float('inf'), 0
|
|
# channels that did not publish both policies often return temporary channel failure
|
|
channel_policy_backwards = self.channel_db.get_policy_for_node(
|
|
short_channel_id, end_node, my_channels=my_channels, private_route_edges=private_route_edges)
|
|
if (channel_policy_backwards is None
|
|
and not is_mine
|
|
and short_channel_id not in private_route_edges):
|
|
return float('inf'), 0
|
|
if channel_policy.is_disabled():
|
|
return float('inf'), 0
|
|
if payment_amt_msat < channel_policy.htlc_minimum_msat:
|
|
return float('inf'), 0 # payment amount too little
|
|
if channel_info.capacity_sat is not None and \
|
|
payment_amt_msat // 1000 > channel_info.capacity_sat:
|
|
return float('inf'), 0 # payment amount too large
|
|
if channel_policy.htlc_maximum_msat is not None and \
|
|
payment_amt_msat > channel_policy.htlc_maximum_msat:
|
|
return float('inf'), 0 # payment amount too large
|
|
route_edge = private_route_edges.get(short_channel_id, None)
|
|
if route_edge is None:
|
|
node_info = self.channel_db.get_node_info_for_node_id(node_id=end_node)
|
|
route_edge = RouteEdge.from_channel_policy(
|
|
channel_policy=channel_policy,
|
|
short_channel_id=short_channel_id,
|
|
start_node=start_node,
|
|
end_node=end_node,
|
|
node_info=node_info)
|
|
if not route_edge.is_sane_to_use(payment_amt_msat):
|
|
return float('inf'), 0 # thanks but no thanks
|
|
|
|
# Distance metric notes: # TODO constants are ad-hoc
|
|
# ( somewhat based on https://github.com/lightningnetwork/lnd/pull/1358 )
|
|
# - Edges have a base cost. (more edges -> less likely none will fail)
|
|
# - The larger the payment amount, and the longer the CLTV,
|
|
# the more irritating it is if the HTLC gets stuck.
|
|
# - Paying lower fees is better. :)
|
|
base_cost = 500 # one more edge ~ paying 500 msat more fees
|
|
if ignore_costs:
|
|
return base_cost, 0
|
|
fee_msat = route_edge.fee_for_edge(payment_amt_msat)
|
|
cltv_cost = route_edge.cltv_expiry_delta * payment_amt_msat * 15 / 1_000_000_000
|
|
overall_cost = base_cost + fee_msat + cltv_cost
|
|
return overall_cost, fee_msat
|
|
|
|
def get_distances(
|
|
self,
|
|
*,
|
|
nodeA: bytes,
|
|
nodeB: bytes,
|
|
invoice_amount_msat: int,
|
|
my_channels: Dict[ShortChannelID, 'Channel'] = None,
|
|
blacklist: Set[ShortChannelID] = None,
|
|
private_route_edges: Dict[ShortChannelID, RouteEdge] = None,
|
|
) -> Dict[bytes, PathEdge]:
|
|
# note: we don't lock self.channel_db, so while the path finding runs,
|
|
# the underlying graph could potentially change... (not good but maybe ~OK?)
|
|
|
|
# run Dijkstra
|
|
# The search is run in the REVERSE direction, from nodeB to nodeA,
|
|
# to properly calculate compound routing fees.
|
|
distance_from_start = defaultdict(lambda: float('inf'))
|
|
distance_from_start[nodeB] = 0
|
|
prev_node = {} # type: Dict[bytes, PathEdge]
|
|
nodes_to_explore = queue.PriorityQueue()
|
|
nodes_to_explore.put((0, invoice_amount_msat, nodeB)) # order of fields (in tuple) matters!
|
|
|
|
# main loop of search
|
|
while nodes_to_explore.qsize() > 0:
|
|
dist_to_edge_endnode, amount_msat, edge_endnode = nodes_to_explore.get()
|
|
if edge_endnode == nodeA:
|
|
break
|
|
if dist_to_edge_endnode != distance_from_start[edge_endnode]:
|
|
# queue.PriorityQueue does not implement decrease_priority,
|
|
# so instead of decreasing priorities, we add items again into the queue.
|
|
# so there are duplicates in the queue, that we discard now:
|
|
continue
|
|
for edge_channel_id in self.channel_db.get_channels_for_node(
|
|
edge_endnode, my_channels=my_channels, private_route_edges=private_route_edges):
|
|
assert isinstance(edge_channel_id, bytes)
|
|
if blacklist and edge_channel_id in blacklist:
|
|
continue
|
|
channel_info = self.channel_db.get_channel_info(
|
|
edge_channel_id, my_channels=my_channels, private_route_edges=private_route_edges)
|
|
if channel_info is None:
|
|
continue
|
|
edge_startnode = channel_info.node2_id if channel_info.node1_id == edge_endnode else channel_info.node1_id
|
|
is_mine = edge_channel_id in my_channels
|
|
if is_mine:
|
|
if edge_startnode == nodeA: # payment outgoing, on our channel
|
|
if not my_channels[edge_channel_id].can_pay(amount_msat, check_frozen=True):
|
|
continue
|
|
else: # payment incoming, on our channel. (funny business, cycle weirdness)
|
|
assert edge_endnode == nodeA, (bh2u(edge_startnode), bh2u(edge_endnode))
|
|
if not my_channels[edge_channel_id].can_receive(amount_msat, check_frozen=True):
|
|
continue
|
|
edge_cost, fee_for_edge_msat = self._edge_cost(
|
|
short_channel_id=edge_channel_id,
|
|
start_node=edge_startnode,
|
|
end_node=edge_endnode,
|
|
payment_amt_msat=amount_msat,
|
|
ignore_costs=(edge_startnode == nodeA),
|
|
is_mine=is_mine,
|
|
my_channels=my_channels,
|
|
private_route_edges=private_route_edges)
|
|
alt_dist_to_neighbour = distance_from_start[edge_endnode] + edge_cost
|
|
if alt_dist_to_neighbour < distance_from_start[edge_startnode]:
|
|
distance_from_start[edge_startnode] = alt_dist_to_neighbour
|
|
prev_node[edge_startnode] = PathEdge(
|
|
start_node=edge_startnode,
|
|
end_node=edge_endnode,
|
|
short_channel_id=ShortChannelID(edge_channel_id))
|
|
amount_to_forward_msat = amount_msat + fee_for_edge_msat
|
|
nodes_to_explore.put((alt_dist_to_neighbour, amount_to_forward_msat, edge_startnode))
|
|
|
|
return prev_node
|
|
|
|
@profiler
|
|
def find_path_for_payment(
|
|
self,
|
|
*,
|
|
nodeA: bytes,
|
|
nodeB: bytes,
|
|
invoice_amount_msat: int,
|
|
my_channels: Dict[ShortChannelID, 'Channel'] = None,
|
|
blacklist: Set[ShortChannelID] = None,
|
|
private_route_edges: Dict[ShortChannelID, RouteEdge] = None,
|
|
) -> Optional[LNPaymentPath]:
|
|
"""Return a path from nodeA to nodeB."""
|
|
assert type(nodeA) is bytes
|
|
assert type(nodeB) is bytes
|
|
assert type(invoice_amount_msat) is int
|
|
if my_channels is None:
|
|
my_channels = {}
|
|
|
|
prev_node = self.get_distances(
|
|
nodeA=nodeA,
|
|
nodeB=nodeB,
|
|
invoice_amount_msat=invoice_amount_msat,
|
|
my_channels=my_channels,
|
|
blacklist=blacklist,
|
|
private_route_edges=private_route_edges)
|
|
|
|
if nodeA not in prev_node:
|
|
return None # no path found
|
|
|
|
# backtrack from search_end (nodeA) to search_start (nodeB)
|
|
# FIXME paths cannot be longer than 20 edges (onion packet)...
|
|
edge_startnode = nodeA
|
|
path = []
|
|
while edge_startnode != nodeB:
|
|
edge = prev_node[edge_startnode]
|
|
path += [edge]
|
|
edge_startnode = edge.node_id
|
|
return path
|
|
|
|
def create_route_from_path(
|
|
self,
|
|
path: Optional[LNPaymentPath],
|
|
*,
|
|
my_channels: Dict[ShortChannelID, 'Channel'] = None,
|
|
private_route_edges: Dict[ShortChannelID, RouteEdge] = None,
|
|
) -> LNPaymentRoute:
|
|
if path is None:
|
|
raise Exception('cannot create route from None path')
|
|
if private_route_edges is None:
|
|
private_route_edges = {}
|
|
route = []
|
|
prev_end_node = path[0].start_node
|
|
for path_edge in path:
|
|
short_channel_id = path_edge.short_channel_id
|
|
_endnodes = self.channel_db.get_endnodes_for_chan(short_channel_id, my_channels=my_channels)
|
|
if _endnodes and sorted(_endnodes) != sorted([path_edge.start_node, path_edge.end_node]):
|
|
raise LNPathInconsistent("endpoints of edge inconsistent with short_channel_id")
|
|
if path_edge.start_node != prev_end_node:
|
|
raise LNPathInconsistent("edges do not chain together")
|
|
route_edge = private_route_edges.get(short_channel_id, None)
|
|
if route_edge is None:
|
|
channel_policy = self.channel_db.get_policy_for_node(
|
|
short_channel_id=short_channel_id,
|
|
node_id=path_edge.start_node,
|
|
my_channels=my_channels)
|
|
if channel_policy is None:
|
|
raise NoChannelPolicy(short_channel_id)
|
|
node_info = self.channel_db.get_node_info_for_node_id(node_id=path_edge.end_node)
|
|
route_edge = RouteEdge.from_channel_policy(
|
|
channel_policy=channel_policy,
|
|
short_channel_id=short_channel_id,
|
|
start_node=path_edge.start_node,
|
|
end_node=path_edge.end_node,
|
|
node_info=node_info)
|
|
route.append(route_edge)
|
|
prev_end_node = path_edge.end_node
|
|
return route
|
|
|
|
def find_route(
|
|
self,
|
|
*,
|
|
nodeA: bytes,
|
|
nodeB: bytes,
|
|
invoice_amount_msat: int,
|
|
path = None,
|
|
my_channels: Dict[ShortChannelID, 'Channel'] = None,
|
|
blacklist: Set[ShortChannelID] = None,
|
|
private_route_edges: Dict[ShortChannelID, RouteEdge] = None,
|
|
) -> Optional[LNPaymentRoute]:
|
|
route = None
|
|
if not path:
|
|
path = self.find_path_for_payment(
|
|
nodeA=nodeA,
|
|
nodeB=nodeB,
|
|
invoice_amount_msat=invoice_amount_msat,
|
|
my_channels=my_channels,
|
|
blacklist=blacklist,
|
|
private_route_edges=private_route_edges)
|
|
if path:
|
|
route = self.create_route_from_path(
|
|
path, my_channels=my_channels, private_route_edges=private_route_edges)
|
|
return route
|
|
|