vincenzopalazzo
/
rgb-cln
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity
rgb-cln/plugins/renepay/flow.c

1395 lines
40 KiB
C
Raw Blame History

#include "config.h"
#include <assert.h>
#include <ccan/tal/str/str.h>
#include <ccan/tal/tal.h>
#include <common/fp16.h>
#include <common/overflows.h>
#include <common/type_to_string.h>
#include <math.h>
#include <plugins/renepay/flow.h>
#include <stdio.h>
#ifndef SUPERVERBOSE
#define SUPERVERBOSE(...)
#else
#define SUPERVERBOSE_ENABLED 1
#endif
#define MAX(x, y) (((x) > (y)) ? (x) : (y))
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
static char *chan_extra_not_found_error(const tal_t *ctx,
const struct short_channel_id *scid)
{
return tal_fmt(ctx,
"chan_extra for scid=%s not found in chan_extra_map",
type_to_string(ctx, struct short_channel_id, scid));
}
bool chan_extra_is_busy(const struct chan_extra *const ce)
{
if(ce==NULL)return false;
return ce->half[0].num_htlcs || ce->half[1].num_htlcs;
}
const char *fmt_chan_extra_map(const tal_t *ctx,
struct chan_extra_map *chan_extra_map)
{
tal_t *this_ctx = tal(ctx,tal_t);
char *buff = tal_fmt(ctx,"Uncertainty network:\n");
struct chan_extra_map_iter it;
for(struct chan_extra *ch = chan_extra_map_first(chan_extra_map,&it);
ch;
ch=chan_extra_map_next(chan_extra_map,&it))
{
const char *scid_str =
type_to_string(this_ctx,struct short_channel_id,&ch->scid);
for(int dir=0;dir<2;++dir)
{
tal_append_fmt(&buff,"%s[%d]:(%s,%s)\n",scid_str,dir,
type_to_string(this_ctx,struct amount_msat,&ch->half[dir].known_min),
type_to_string(this_ctx,struct amount_msat,&ch->half[dir].known_max));
}
}
tal_free(this_ctx);
return buff;
}
const char *fmt_chan_extra_details(const tal_t *ctx,
const struct chan_extra_map* chan_extra_map,
const struct short_channel_id_dir *scidd)
{
const tal_t *this_ctx = tal(ctx,tal_t);
const struct chan_extra *ce = chan_extra_map_get(chan_extra_map,
scidd->scid);
const struct chan_extra_half *ch;
char *str = tal_strdup(ctx, "");
char sep = '(';
if (!ce) {
// we have no information on this channel
tal_append_fmt(&str, "()");
goto finished;
}
ch = &ce->half[scidd->dir];
if (ch->num_htlcs != 0) {
tal_append_fmt(&str, "%c%s in %zu htlcs",
sep,
fmt_amount_msat(this_ctx, ch->htlc_total),
ch->num_htlcs);
sep = ',';
}
/* Happens with local channels, where we're certain. */
if (amount_msat_eq(ch->known_min, ch->known_max)) {
tal_append_fmt(&str, "%cmin=max=%s",
sep,
fmt_amount_msat(this_ctx, ch->known_min));
sep = ',';
} else {
if (amount_msat_greater(ch->known_min, AMOUNT_MSAT(0))) {
tal_append_fmt(&str, "%cmin=%s",
sep,
fmt_amount_msat(this_ctx, ch->known_min));
sep = ',';
}
if (!amount_msat_eq(ch->known_max, ce->capacity)) {
tal_append_fmt(&str, "%cmax=%s",
sep,
fmt_amount_msat(this_ctx, ch->known_max));
sep = ',';
}
}
if (!streq(str, ""))
tal_append_fmt(&str, ")");
finished:
tal_free(this_ctx);
return str;
}
struct chan_extra *new_chan_extra(struct chan_extra_map *chan_extra_map,
const struct short_channel_id scid,
struct amount_msat capacity)
{
assert(chan_extra_map);
struct chan_extra *ce = tal(chan_extra_map, struct chan_extra);
if (!ce)
return ce;
ce->scid = scid;
ce->capacity=capacity;
for (size_t i = 0; i <= 1; i++) {
ce->half[i].num_htlcs = 0;
ce->half[i].htlc_total = AMOUNT_MSAT(0);
ce->half[i].known_min = AMOUNT_MSAT(0);
ce->half[i].known_max = capacity;
}
if (!chan_extra_map_add(chan_extra_map, ce)) {
return tal_free(ce);
}
/* Remove self from map when done */
// TODO(eduardo):
// Is this desctructor really necessary? the chan_extra will deallocated
// when the chan_extra_map is freed. Anyways valgrind complains that the
// hash table is removing the element with a freed pointer.
// tal_add_destructor2(ce, destroy_chan_extra, chan_extra_map);
return ce;
}
static struct amount_msat channel_max_htlc(const struct gossmap_chan *chan,
const int dir)
{
return amount_msat(fp16_to_u64(chan->half[dir].htlc_max));
}
/* Based on the knowledge that we have and HTLCs, returns the greatest
* amount that we can send through this channel. */
static bool channel_liquidity(struct amount_msat *liquidity,
const struct gossmap *gossmap,
struct chan_extra_map *chan_extra_map,
const struct gossmap_chan *chan, const int dir)
{
const struct chan_extra_half *h =
get_chan_extra_half_by_chan(gossmap, chan_extra_map, chan, dir);
if (!h)
return false;
struct amount_msat value_liquidity = h->known_max;
if (!amount_msat_sub(&value_liquidity, value_liquidity, h->htlc_total))
return false;
*liquidity = value_liquidity;
return true;
}
/* Checks BOLT 7 HTLC fee condition:
* recv >= base_fee + (send*proportional_fee)/1000000 */
static bool check_fee_inequality(struct amount_msat recv,
struct amount_msat send, u64 base_fee,
u64 proportional_fee)
{
// nothing to forward, any incoming amount is good
if (amount_msat_zero(send))
return true;
// FIXME If this addition fails we return false. The caller will not be
// able to know that there was an addition overflow, he will just assume
// that the fee inequality was not satisfied.
if (!amount_msat_add_fee(&send, base_fee, proportional_fee))
return false;
return amount_msat_greater_eq(recv, send);
}
/* Let `recv` be the maximum amount this channel can receive, this function
* computes the maximum amount this channel can forward `send`.
* From BOLT7 specification wee need to satisfy the following inequality:
*
* recv-send >= base_fee + floor(send*proportional_fee/1000000)
*
* That is equivalent to have
*
* send <= Bound(recv,send)
*
* where
*
* Bound(recv, send) = ((recv - base_fee)*1000000 + (send*proportional_fee)
*% 1000000)/(proportional_fee+1000000)
*
* However the quantity we want to determine, `send`, appears on both sides of
* the equation. However the term `send*proportional_fee) % 1000000` only
* contributes by increasing the bound by at most one so that we can neglect
* the extra term and use instead
*
* Bound_simple(recv) = ((recv -
*base_fee)*1000000)/(proportional_fee+1000000)
*
* as the upper bound for `send`. Formally one can check that
*
* Bound_simple(recv) <= Bound(recv, send) < Bound_simple(recv) + 2
*
* So that if one wishes to find the very highest value of `send` that
* satisfies
*
* send <= Bound(recv, send)
*
* it is enough to compute
*
* send = Bound_simple(recv)
*
* which already satisfies the fee equation and then try to go higher
* with send+1, send+2, etc. But we know that it is enough to try up to
* send+1 because Bound(recv, send) < Bound_simple(recv) + 2.
* */
static bool channel_maximum_forward(struct amount_msat *max_forward,
const struct gossmap_chan *chan,
const int dir, struct amount_msat recv)
{
const u64 b = chan->half[dir].base_fee,
p = chan->half[dir].proportional_fee;
const u64 one_million = 1000000;
u64 x_msat =
recv.millisatoshis; /* Raw: need to invert the fee equation */
// special case, when recv - base_fee <= 0, we cannot forward anything
if (x_msat <= b) {
*max_forward = amount_msat(0);
return true;
}
x_msat -= b;
if (mul_overflows_u64(one_million, x_msat))
return false;
struct amount_msat best_send =
AMOUNT_MSAT_INIT((one_million * x_msat) / (one_million + p));
/* Try to increase the value we send (up tp the last millisat) until we
* fail to fulfill the fee inequality. It takes only one iteration
* though. */
for (size_t i = 0; i < 10; ++i) {
struct amount_msat next_send;
if (!amount_msat_add(&next_send, best_send, amount_msat(1)))
return false;
if (check_fee_inequality(recv, next_send, b, p))
best_send = next_send;
else
break;
}
*max_forward = best_send;
return true;
}
/* Returns the greatest amount we can deliver to the destination using this
* route. It takes into account the current knowledge, pending HTLC,
* htlc_max and fees. */
static bool flow_maximum_deliverable(struct amount_msat *max_deliverable,
const struct flow *flow,
const struct gossmap *gossmap,
struct chan_extra_map *chan_extra_map)
{
assert(tal_count(flow->path) > 0);
assert(tal_count(flow->dirs) > 0);
assert(tal_count(flow->path) == tal_count(flow->dirs));
struct amount_msat x;
if (!channel_liquidity(&x, gossmap, chan_extra_map, flow->path[0],
flow->dirs[0]))
return false;
x = amount_msat_min(x, channel_max_htlc(flow->path[0], flow->dirs[0]));
for (size_t i = 1; i < tal_count(flow->path); ++i) {
// ith node can forward up to 'liquidity_cap' because of the ith
// channel liquidity bound
struct amount_msat liquidity_cap;
if (!channel_liquidity(&liquidity_cap, gossmap, chan_extra_map,
flow->path[i], flow->dirs[i]))
return false;
/* ith node can receive up to 'x', therefore he will not forward
* more than 'forward_cap' that we compute below inverting the
* fee equation. */
struct amount_msat forward_cap;
if (!channel_maximum_forward(&forward_cap, flow->path[i],
flow->dirs[i], x))
return false;
struct amount_msat x_new =
amount_msat_min(forward_cap, liquidity_cap);
x_new = amount_msat_min(
x_new, channel_max_htlc(flow->path[i], flow->dirs[i]));
if (!amount_msat_less_eq(x_new, x))
return false;
// safety check: amounts decrease along the route
assert(amount_msat_less_eq(x_new, x));
struct amount_msat x_check = x_new;
if (!amount_msat_zero(x_new) &&
!amount_msat_add_fee(&x_check, flow_edge(flow, i)->base_fee,
flow_edge(flow, i)->proportional_fee))
return false;
// safety check: the max liquidity in the next hop + fees cannot
// be greater than then max liquidity in the current hop, IF the
// next hop is non-zero.
assert(amount_msat_less_eq(x_check, x));
x = x_new;
}
*max_deliverable = x;
return true;
}
/* How much do we deliver to destination using this set of routes */
static bool flow_set_delivers(struct amount_msat *delivers, struct flow **flows)
{
struct amount_msat final = AMOUNT_MSAT(0);
for (size_t i = 0; i < tal_count(flows); i++) {
size_t n = tal_count(flows[i]->amounts);
struct amount_msat this_final = flows[i]->amounts[n - 1];
if (!amount_msat_add(&final, this_final, final))
return false;
}
*delivers = final;
return true;
}
/* How much this flow (route with amounts) is delivering to the destination
* node. */
static inline struct amount_msat flow_delivers(const struct flow *flow)
{
return flow->amounts[tal_count(flow->amounts) - 1];
}
/* Checks if the flows satisfy the liquidity bounds imposed by the known maximum
* liquidity and pending HTLCs.
*
* FIXME The function returns false even in the case of failure. The caller has
* no way of knowing the difference between a failure of evaluation and a
* negative answer. */
static bool check_liquidity_bounds(struct flow **flows,
const struct gossmap *gossmap,
struct chan_extra_map *chan_extra_map)
{
bool check = true;
for (size_t i = 0; i < tal_count(flows); ++i) {
struct amount_msat max_deliverable;
if (!flow_maximum_deliverable(&max_deliverable, flows[i],
gossmap, chan_extra_map))
return false;
struct amount_msat delivers = flow_delivers(flows[i]);
check &= amount_msat_less_eq(delivers, max_deliverable);
}
return check;
}
/* flows should be a set of optimal routes delivering an amount that is
* slighty less than amount_to_deliver. We will try to reallocate amounts in
* these flows so that it delivers the exact amount_to_deliver to the
* destination.
* Returns how much we are delivering at the end. */
bool flows_fit_amount(const tal_t *ctx, struct amount_msat *amount_allocated,
struct flow **flows, struct amount_msat amount_to_deliver,
const struct gossmap *gossmap,
struct chan_extra_map *chan_extra_map, char **fail)
{
tal_t *this_ctx = tal(ctx, tal_t);
char *errmsg;
struct amount_msat total_deliver;
if (!flow_set_delivers(&total_deliver, flows)) {
if (fail)
*fail = tal_fmt(
ctx, "(%s, line %d) flow_set_delivers failed",
__PRETTY_FUNCTION__, __LINE__);
goto function_fail;
}
if (amount_msat_greater_eq(total_deliver, amount_to_deliver)) {
*amount_allocated = total_deliver;
goto function_success;
}
struct amount_msat deficit;
if (!amount_msat_sub(&deficit, amount_to_deliver, total_deliver)) {
// this should not happen, because we already checked that
// total_deliver<amount_to_deliver
if (fail)
*fail = tal_fmt(
ctx,
"(%s, line %d) unexpected amount_msat_sub failure",
__PRETTY_FUNCTION__, __LINE__);
goto function_fail;
}
/* FIXME Current algorithm assigns as much of the deficit as possible to
* the list of routes, we can improve this lets say in order to maximize
* the probability. If the deficit is very small with respect to the
* amount each flow carries then optimization here will not make much
* difference. */
for (size_t i = 0; i < tal_count(flows) && !amount_msat_zero(deficit);
++i) {
struct amount_msat max_deliverable;
if (!flow_maximum_deliverable(&max_deliverable, flows[i],
gossmap, chan_extra_map)) {
if (fail)
*fail =
tal_fmt(ctx,
"(%s, line %d) "
"flow_maximum_deliverable failed",
__PRETTY_FUNCTION__, __LINE__);
goto function_fail;
}
struct amount_msat delivers = flow_delivers(flows[i]);
struct amount_msat diff;
if (!amount_msat_sub(&diff, max_deliverable, delivers)) {
// this should never happen, a precondition of this
// function is that the flows already respect the
// liquidity bounds.
if (fail)
*fail = tal_fmt(ctx,
"(%s, line %d) unexpected "
"amount_msat_sub failure",
__PRETTY_FUNCTION__, __LINE__);
goto function_fail;
}
if (amount_msat_zero(diff))
continue;
diff = amount_msat_min(diff, deficit);
if (!amount_msat_sub(&deficit, deficit, diff)) {
// this should never happen
if (fail)
*fail = tal_fmt(ctx,
"(%s, line %d) unexpected "
"amount_msat_sub failure",
__PRETTY_FUNCTION__, __LINE__);
goto function_fail;
}
if (!amount_msat_add(&delivers, delivers, diff)) {
if (fail)
*fail = tal_fmt(
ctx,
"(%s, line %d) amount_msat_add overflow",
__PRETTY_FUNCTION__, __LINE__);
goto function_fail;
}
if (!flow_complete(this_ctx, flows[i], gossmap, chan_extra_map,
delivers, &errmsg)) {
if (fail)
*fail = tal_fmt(
ctx,
"(%s, line %d) flow_complete failed: %s",
__PRETTY_FUNCTION__, __LINE__, errmsg);
goto function_fail;
}
}
if (!check_liquidity_bounds(flows, gossmap, chan_extra_map)) {
// this should not happen if our algorithm is correct
if (fail)
*fail = tal_fmt(ctx,
"(%s, line %d) liquidity bounds not "
"satisfied or failed check",
__PRETTY_FUNCTION__, __LINE__);
goto function_fail;
}
if (!flow_set_delivers(amount_allocated, flows)) {
if (fail)
*fail = tal_fmt(
ctx, "(%s, line %d) flow_set_delivers failed",
__PRETTY_FUNCTION__, __LINE__);
goto function_fail;
}
function_success:
tal_free(this_ctx);
return true;
function_fail:
tal_free(this_ctx);
return false;
}
/* This helper function preserves the uncertainty network invariant after the
* knowledge is updated. It assumes that the (channel,!dir) knowledge is
* correct. */
static bool chan_extra_adjust_half(const tal_t *ctx, struct chan_extra *ce,
int dir, char **fail)
{
assert(ce);
assert(dir==0 || dir==1);
struct amount_msat new_known_max, new_known_min;
if (!amount_msat_sub(&new_known_max, ce->capacity,
ce->half[!dir].known_min)) {
if(fail)
*fail = tal_fmt(
ctx, "cannot substract capacity=%s and known_min=%s",
type_to_string(ctx, struct amount_msat, &ce->capacity),
type_to_string(ctx, struct amount_msat,
&ce->half[!dir].known_min));
goto function_fail;
}
if (!amount_msat_sub(&new_known_min, ce->capacity,
ce->half[!dir].known_max)) {
if(fail)
*fail = tal_fmt(
ctx, "cannot substract capacity=%s and known_max=%s",
type_to_string(ctx, struct amount_msat, &ce->capacity),
type_to_string(ctx, struct amount_msat,
&ce->half[!dir].known_max));
goto function_fail;
}
ce->half[dir].known_max = new_known_max;
ce->half[dir].known_min = new_known_min;
return true;
function_fail:
return false;
}
/* Update the knowledge that this (channel,direction) can send x msat.*/
static bool chan_extra_can_send_(const tal_t *ctx, struct chan_extra *ce,
int dir, struct amount_msat x, char **fail)
{
assert(ce);
assert(dir==0 || dir==1);
const tal_t *this_ctx = tal(ctx,tal_t);
char *errmsg;
if (amount_msat_greater(x, ce->capacity)) {
if(fail)
*fail = tal_fmt(
ctx,
"can send amount (%s) is larger than the "
"channel's capacity (%s)",
type_to_string(ctx, struct amount_msat, &x),
type_to_string(ctx, struct amount_msat, &ce->capacity));
goto function_fail;
}
struct amount_msat known_min, known_max;
// in case we fail, let's remember the original state
known_min = ce->half[dir].known_min;
known_max = ce->half[dir].known_max;
ce->half[dir].known_min = amount_msat_max(ce->half[dir].known_min, x);
ce->half[dir].known_max = amount_msat_max(ce->half[dir].known_max, x);
if (!chan_extra_adjust_half(this_ctx, ce, !dir, &errmsg)) {
if(fail)
*fail = tal_fmt(ctx, "chan_extra_adjust_half failed: %s",
errmsg);
goto restore_and_fail;
}
return true;
restore_and_fail:
// we fail, thus restore the original state
ce->half[dir].known_min = known_min;
ce->half[dir].known_max = known_max;
function_fail:
return false;
}
bool chan_extra_can_send(const tal_t *ctx,
struct chan_extra_map *chan_extra_map,
const struct short_channel_id_dir *scidd,
char **fail)
{
assert(scidd);
assert(chan_extra_map);
struct chan_extra *ce = chan_extra_map_get(chan_extra_map, scidd->scid);
if (!ce) {
if(fail)
*fail = chan_extra_not_found_error(ctx, &scidd->scid);
goto function_fail;
}
if (!chan_extra_can_send_(ctx, ce, scidd->dir,
ce->half[scidd->dir].htlc_total, fail)) {
goto function_fail;
}
return true;
function_fail:
return false;
}
/* Update the knowledge that this (channel,direction) cannot send.*/
bool chan_extra_cannot_send(const tal_t *ctx,
struct chan_extra_map *chan_extra_map,
const struct short_channel_id_dir *scidd,
char **fail)
{
assert(scidd);
assert(chan_extra_map);
const tal_t *this_ctx = tal(ctx,tal_t);
char *errmsg;
struct amount_msat x;
struct chan_extra *ce = chan_extra_map_get(chan_extra_map,
scidd->scid);
if(!ce)
{
if(fail)
*fail = chan_extra_not_found_error(ctx, &scidd->scid);
goto function_fail;
}
/* Note: sent is already included in htlc_total! */
if (!amount_msat_sub(&x, ce->half[scidd->dir].htlc_total,
AMOUNT_MSAT(1))) {
if(fail)
*fail = tal_fmt(
ctx, "htlc_total=%s is less than 0msats in channel %s",
type_to_string(this_ctx, struct amount_msat,
&ce->half[scidd->dir].htlc_total),
type_to_string(this_ctx, struct short_channel_id,
&scidd->scid));
goto function_fail;
}
struct amount_msat known_min, known_max;
// in case we fail, let's remember the original state
known_min = ce->half[scidd->dir].known_min;
known_max = ce->half[scidd->dir].known_max;
/* If we "knew" the capacity was at least this, we just showed we're wrong! */
if (amount_msat_less(x, ce->half[scidd->dir].known_min)) {
/* Skip to half of x, since we don't know (rounds down) */
ce->half[scidd->dir].known_min = amount_msat_div(x, 2);
}
ce->half[scidd->dir].known_max = amount_msat_min(ce->half[scidd->dir].known_max,x);
if(!chan_extra_adjust_half(this_ctx, ce,!scidd->dir,&errmsg))
{
if(fail)
*fail = tal_fmt(ctx, "chan_extra_adjust_half failed: %s",
errmsg);
goto restore_and_fail;
}
tal_free(this_ctx);
return true;
restore_and_fail:
// we fail, thus restore the original state
ce->half[scidd->dir].known_min = known_min;
ce->half[scidd->dir].known_max = known_max;
function_fail:
tal_free(this_ctx);
return false;
}
/* Update the knowledge that this (channel,direction) has liquidity x.*/
static bool chan_extra_set_liquidity_(const tal_t *ctx, struct chan_extra *ce,
int dir, struct amount_msat x,
char **fail)
{
assert(ce);
assert(dir==0 || dir==1);
const tal_t *this_ctx = tal(ctx,tal_t);
char *errmsg;
if (amount_msat_greater(x, ce->capacity)) {
if(fail)
*fail = tal_fmt(
ctx,
"tried to set liquidity (%s) to a value greater than "
"channel's capacity (%s)",
type_to_string(this_ctx, struct amount_msat, &x),
type_to_string(this_ctx, struct amount_msat, &ce->capacity));
goto function_fail;
}
// in case we fail, let's remember the original state
struct amount_msat known_min, known_max;
known_min = ce->half[dir].known_min;
known_max = ce->half[dir].known_max;
ce->half[dir].known_min = x;
ce->half[dir].known_max = x;
if (!chan_extra_adjust_half(this_ctx, ce, !dir, &errmsg)) {
if(fail)
*fail = tal_fmt(ctx, "chan_extra_adjust_half failed: %s",
errmsg);
goto restore_and_fail;
}
tal_free(this_ctx);
return true;
restore_and_fail:
// we fail, thus restore the original state
ce->half[dir].known_min = known_min;
ce->half[dir].known_max = known_max;
function_fail:
tal_free(this_ctx);
return false;
}
bool chan_extra_set_liquidity(const tal_t *ctx,
struct chan_extra_map *chan_extra_map,
const struct short_channel_id_dir *scidd,
struct amount_msat x, char **fail)
{
assert(scidd);
assert(chan_extra_map);
struct chan_extra *ce = chan_extra_map_get(chan_extra_map, scidd->scid);
if (!ce) {
if(fail)
*fail = chan_extra_not_found_error(ctx, &scidd->scid);
goto function_fail;
}
if (!chan_extra_set_liquidity_(ctx, ce, scidd->dir, x, fail)) {
goto function_fail;
}
return true;
function_fail:
return false;
}
/* Update the knowledge that this (channel,direction) has sent x msat.*/
bool chan_extra_sent_success(const tal_t *ctx,
struct chan_extra_map *chan_extra_map,
const struct short_channel_id_dir *scidd,
struct amount_msat x, char **fail)
{
assert(scidd);
assert(chan_extra_map);
tal_t *this_ctx = tal(ctx, tal_t);
char *errmsg;
// if we sent amount x, it first means that all htlcs on this channel fit
// in the liquidity
if (!chan_extra_can_send(this_ctx, chan_extra_map, scidd, &errmsg)) {
if (fail)
*fail = tal_fmt(ctx, "chan_extra_can_send failed: %s",
errmsg);
goto function_fail;
}
struct chan_extra *ce = chan_extra_map_get(chan_extra_map, scidd->scid);
if (!ce) {
if(fail)
*fail = chan_extra_not_found_error(ctx, &scidd->scid);
goto function_fail;
}
if (amount_msat_greater(x, ce->capacity)) {
if(fail)
*fail = tal_fmt(
ctx,
"sent success (%s) is larger than the "
"channel's capacity (%s)",
type_to_string(this_ctx, struct amount_msat, &x),
type_to_string(this_ctx, struct amount_msat, &ce->capacity));
goto function_fail;
}
// in case we fail, let's remember the original state
struct amount_msat known_min, known_max;
known_min = ce->half[scidd->dir].known_min;
known_max = ce->half[scidd->dir].known_max;
struct amount_msat new_a, new_b;
if (!amount_msat_sub(&new_a, ce->half[scidd->dir].known_min, x))
new_a = AMOUNT_MSAT(0);
if (!amount_msat_sub(&new_b, ce->half[scidd->dir].known_max, x))
new_b = AMOUNT_MSAT(0);
ce->half[scidd->dir].known_min = new_a;
ce->half[scidd->dir].known_max = new_b;
if (!chan_extra_adjust_half(this_ctx, ce, !scidd->dir, &errmsg)) {
if(fail)
*fail =
tal_fmt(ctx, "chan_extra_adjust_half failed: %s", errmsg);
goto restore_and_fail;
}
tal_free(this_ctx);
return true;
// we fail, thus restore the original state
restore_and_fail:
ce->half[scidd->dir].known_min = known_min;
ce->half[scidd->dir].known_max = known_max;
function_fail:
tal_free(this_ctx);
return false;
}
/* Forget a bit about this (channel,direction) state. */
static bool chan_extra_relax(const tal_t *ctx, struct chan_extra *ce, int dir,
struct amount_msat down, struct amount_msat up,
char **fail)
{
assert(ce);
assert(dir==0 || dir==1);
const tal_t *this_ctx = tal(ctx,tal_t);
char *errmsg;
struct amount_msat new_a, new_b;
if (!amount_msat_sub(&new_a, ce->half[dir].known_min, down))
new_a = AMOUNT_MSAT(0);
if (!amount_msat_add(&new_b, ce->half[dir].known_max, up))
new_b = ce->capacity;
new_b = amount_msat_min(new_b, ce->capacity);
// in case we fail, let's remember the original state
struct amount_msat known_min, known_max;
known_min = ce->half[dir].known_min;
known_max = ce->half[dir].known_max;
ce->half[dir].known_min = new_a;
ce->half[dir].known_max = new_b;
if (!chan_extra_adjust_half(this_ctx,ce, !dir, &errmsg)) {
if(fail)
*fail = tal_fmt(ctx, "chan_extra_adjust_half failed: %s",
errmsg);
goto restore_and_fail;
}
tal_free(this_ctx);
return true;
// we fail, thus restore the original state
restore_and_fail:
ce->half[dir].known_min = known_min;
ce->half[dir].known_max = known_max;
tal_free(this_ctx);
return false;
}
/* Forget the channel information by a fraction of the capacity. */
bool chan_extra_relax_fraction(const tal_t *ctx, struct chan_extra *ce,
double fraction, char **fail)
{
assert(ce);
assert(fraction>=0);
/* Allow to have values greater than 1 to indicate full relax. */
// assert(fraction<=1);
const tal_t *this_ctx = tal(ctx,tal_t);
char *errmsg;
fraction = fabs(fraction); // this number is always non-negative
fraction = MIN(1.0, fraction); // this number cannot be greater than 1.
struct amount_msat delta =
amount_msat(ce->capacity.millisatoshis * fraction); /* Raw: get a fraction of the capacity */
/* The direction here is not important because the 'down' and the 'up'
* limits are changed by the same amount.
* Notice that if chan[0] with capacity C changes from (a,b) to
* (a-d,b+d) then its counterpart chan[1] changes from (C-b,C-a) to
* (C-b-d,C-a+d), hence both dirs are applied the same transformation.
*/
if (!chan_extra_relax(this_ctx, ce, /*dir=*/0, delta, delta, &errmsg)) {
if(fail)
*fail = tal_fmt(ctx, "chan_extra_relax failed: %s", errmsg);
goto function_fail;
}
tal_free(this_ctx);
return true;
function_fail:
tal_free(this_ctx);
return false;
}
/* Returns either NULL, or an entry from the hash */
struct chan_extra_half *
get_chan_extra_half_by_scid(struct chan_extra_map *chan_extra_map,
const struct short_channel_id_dir *scidd)
{
assert(scidd);
assert(chan_extra_map);
struct chan_extra *ce;
ce = chan_extra_map_get(chan_extra_map, scidd->scid);
if (!ce)
return NULL;
return &ce->half[scidd->dir];
}
/* Helper if we have a gossmap_chan */
struct chan_extra_half *
get_chan_extra_half_by_chan(const struct gossmap *gossmap,
struct chan_extra_map *chan_extra_map,
const struct gossmap_chan *chan,
int dir)
{
assert(chan);
assert(dir==0 || dir==1);
assert(gossmap);
assert(chan_extra_map);
struct short_channel_id_dir scidd;
scidd.scid = gossmap_chan_scid(gossmap, chan);
scidd.dir = dir;
return get_chan_extra_half_by_scid(chan_extra_map, &scidd);
}
// static void destroy_chan_extra(struct chan_extra *ce,
// struct chan_extra_map *chan_extra_map)
// {
// chan_extra_map_del(chan_extra_map, ce);
// }
/* Helper to get the chan_extra_half. If it doesn't exist create a new one. */
struct chan_extra_half *
get_chan_extra_half_by_chan_verify(const struct gossmap *gossmap,
struct chan_extra_map *chan_extra_map,
const struct gossmap_chan *chan, int dir)
{
assert(chan);
assert(dir==0 || dir==1);
assert(gossmap);
assert(chan_extra_map);
struct short_channel_id_dir scidd;
scidd.scid = gossmap_chan_scid(gossmap, chan);
scidd.dir = dir;
struct chan_extra_half *h =
get_chan_extra_half_by_scid(chan_extra_map, &scidd);
if (!h) {
struct amount_sat cap;
struct amount_msat cap_msat;
if (!gossmap_chan_get_capacity(gossmap, chan, &cap) ||
!amount_sat_to_msat(&cap_msat, cap)) {
return NULL;
}
h = &new_chan_extra(chan_extra_map, scidd.scid, cap_msat)
->half[scidd.dir];
}
return h;
}
/* Assuming a uniform distribution, what is the chance this f gets through?
* Here we compute the conditional probability of success for a flow f, given
* the knowledge that the liquidity is in the range [a,b) and some amount
* x is already committed on another part of the payment.
*
* The probability equation for x=0 is:
*
* prob(f) =
*
* for f<a: 1.
* for b>=f>=a: (b-f)/(b-a)
* for b<f: 0.
*
* When x>0 the prob. of success for passing x and f is:
*
* prob(f and x) = prob(x) * prob(f|x)
*
* and it can be shown to be equal to
*
* prob(f and x) = prob(f+x)
*
* The purpose of this function is to obtain prob(f|x), i.e. the probability of
* getting f through provided that we already succeeded in getting x.
* This conditional probability comes with 4 cases:
*
* prob(f|x) =
*
* for x<a and f<a-x: 1.
* for x<a and f>=a-x: (b-x-f)/(b-a)
* for x>=a: (b-x-f)/(b-x)
* for f>b-x: 0.
*
* This is the same as the probability of success of f when the bounds are
* shifted by x amount, the new bounds be [MAX(0,a-x),b-x).
*/
static double edge_probability(const tal_t *ctx, struct amount_msat min,
struct amount_msat max,
struct amount_msat in_flight,
struct amount_msat f, char **fail)
{
assert(amount_msat_less_eq(min,max));
assert(amount_msat_less_eq(in_flight,max));
const tal_t *this_ctx = tal(ctx, tal_t);
const struct amount_msat one = AMOUNT_MSAT(1);
struct amount_msat B=max; // = max +1 - in_flight
// one past the last known value, makes computations simpler
if(!amount_msat_add(&B,B,one))
{
if(fail)
*fail = tal_fmt(ctx,"addition overflow");
goto function_fail;
}
// in_flight cannot be greater than max
if(!amount_msat_sub(&B,B,in_flight))
{
if(fail)
*fail = tal_fmt(ctx,
"in_flight=%s cannot be greater than known_max+1=%s",
type_to_string(this_ctx, struct amount_msat, &in_flight),
type_to_string(this_ctx, struct amount_msat, &B)
);
goto function_fail;
}
struct amount_msat A=min; // = MAX(0,min-in_flight);
if(!amount_msat_sub(&A,A,in_flight))
A = AMOUNT_MSAT(0);
struct amount_msat denominator; // = B-A
// B cannot be smaller than or equal A
if(!amount_msat_sub(&denominator,B,A) || amount_msat_less_eq(B,A))
{
if(fail)
*fail = tal_fmt(ctx,"known_max+1=%s must be greater than known_min=%s",
type_to_string(this_ctx, struct amount_msat, &B),
type_to_string(this_ctx, struct amount_msat, &A));
goto function_fail;
}
struct amount_msat numerator; // MAX(0,B-f)
if(!amount_msat_sub(&numerator,B,f))
numerator = AMOUNT_MSAT(0);
tal_free(this_ctx);
return amount_msat_less_eq(f,A) ? 1.0 : amount_msat_ratio(numerator,denominator);
function_fail:
tal_free(this_ctx);
return -1;
}
// TODO(eduardo): remove this function, is a duplicate
/* If this function fails it means there is a bad data inconsistency and the
* program should stop. */
bool remove_completed_flow(const tal_t *ctx, const struct gossmap *gossmap,
struct chan_extra_map *chan_extra_map,
struct flow *flow, char **fail)
{
assert(flow);
assert(gossmap);
assert(chan_extra_map);
tal_t *this_ctx = tal(ctx, tal_t);
for (size_t i = 0; i < tal_count(flow->path); i++) {
struct chan_extra_half *h = get_chan_extra_half_by_chan(gossmap,
chan_extra_map,
flow->path[i],
flow->dirs[i]);
if (!amount_msat_sub(&h->htlc_total, h->htlc_total, flow->amounts[i]))
{
if(fail)
*fail =
tal_fmt(ctx,
"could not substract HTLC amounts, "
"total htlc amount = %s, "
"flow->amounts[%zu] = %s.",
type_to_string(this_ctx, struct amount_msat,
&h->htlc_total),
i,
type_to_string(this_ctx, struct amount_msat,
&flow->amounts[i]));
goto function_fail;
}
if (h->num_htlcs == 0)
{
if(fail)
*fail =
tal_fmt(ctx, "could not decrease HTLC count.");
goto function_fail;
}
h->num_htlcs--;
}
tal_free(this_ctx);
return true;
function_fail:
tal_free(this_ctx);
return false;
}
// TODO(eduardo): remove this function, is a duplicate
/* If this function fails it means there is a bad data inconsistency and the
* program should stop. */
bool remove_completed_flowset(const tal_t *ctx, const struct gossmap *gossmap,
struct chan_extra_map *chan_extra_map,
struct flow **flows, char **fail)
{
assert(flows);
assert(gossmap);
assert(chan_extra_map);
for (size_t i = 0; i < tal_count(flows); ++i) {
if (!remove_completed_flow(ctx, gossmap, chan_extra_map, flows[i],
fail)) {
return false;
}
}
return true;
}
// TODO(eduardo): remove this function, is a duplicate
bool commit_flow(const tal_t *ctx, const struct gossmap *gossmap,
struct chan_extra_map *chan_extra_map, struct flow *flow,
char **fail)
{
assert(flow);
assert(gossmap);
assert(chan_extra_map);
tal_t *this_ctx = tal(ctx, tal_t);
for (size_t i = 0; i < tal_count(flow->path); i++) {
struct chan_extra_half *h = get_chan_extra_half_by_chan(gossmap,
chan_extra_map,
flow->path[i],
flow->dirs[i]);
if (!amount_msat_add(&h->htlc_total, h->htlc_total, flow->amounts[i]))
{
if (fail)
*fail =
tal_fmt(ctx,
"could not add HTLC amounts, "
"flow->amounts[%zu] = %s.",
i,
type_to_string(this_ctx, struct amount_msat,
&flow->amounts[i]));
goto function_fail;
}
h->num_htlcs++;
}
tal_free(this_ctx);
return true;
function_fail:
tal_free(this_ctx);
return false;
}
// TODO(eduardo): remove this function, is a duplicate
/* Returns the number of flows successfully commited. */
size_t commit_flowset(const tal_t *ctx, const struct gossmap *gossmap,
struct chan_extra_map *chan_extra_map, struct flow **flows,
char **fail)
{
assert(flows);
assert(gossmap);
assert(chan_extra_map);
const size_t N = tal_count(flows);
for(size_t i=0; i<N; ++i)
{
if (!commit_flow(ctx, gossmap, chan_extra_map, flows[i],
fail)) {
return i;
}
}
return N;
}
/* Helper function to fill in amounts and success_prob for flow
*
* @ctx: tal context for allocated objects that outlive this function call, eg.
* fail
* @flow: the flow we want to complete with precise amounts
* @gossmap: state of the network
* @chan_extra_map: state of the network
* @delivered: how much we are supposed to deliver at destination
* @fail: here we write verbose message errors in case of failure
*
* IMPORTANT: here we do not commit flows to chan_extra, flows are commited
* after we send those htlc.
*
* IMPORTANT: flow->success_prob is misleading, because that's the prob. of
* success provided that there are no other flows in the current MPP flow set.
* */
bool flow_complete(const tal_t *ctx, struct flow *flow,
const struct gossmap *gossmap,
struct chan_extra_map *chan_extra_map,
struct amount_msat delivered, char **fail)
{
assert(flow);
assert(gossmap);
assert(chan_extra_map);
tal_t *this_ctx = tal(ctx, tal_t);
char *errmsg;
flow->success_prob = 1.0;
flow->amounts =
tal_arr(flow, struct amount_msat, tal_count(flow->path));
struct amount_msat max_deliverable;
if (!flow_maximum_deliverable(&max_deliverable, flow, gossmap,
chan_extra_map)) {
if (fail)
*fail = tal_fmt(ctx, "flow_maximum_deliverable failed");
goto function_fail;
}
// we cannot deliver more than it is allowed by the liquidity
// constraints: HTLC max, fees, known_max
delivered = amount_msat_min(delivered, max_deliverable);
for (int i = tal_count(flow->path) - 1; i >= 0; i--) {
const struct chan_extra_half *h = get_chan_extra_half_by_chan(
gossmap, chan_extra_map, flow->path[i], flow->dirs[i]);
if (!h) {
if (fail)
*fail = tal_fmt(
ctx, "channel not found in chan_extra_map");
goto function_fail;
}
flow->amounts[i] = delivered;
double prob =
edge_probability(this_ctx, h->known_min, h->known_max,
h->htlc_total, delivered, &errmsg);
if (prob < 0) {
if (fail)
*fail = tal_fmt(
ctx, "edge_probability failed: %s", errmsg);
goto function_fail;
}
flow->success_prob *= prob;
if (!amount_msat_add_fee(
&delivered, flow_edge(flow, i)->base_fee,
flow_edge(flow, i)->proportional_fee)) {
if (fail)
*fail = tal_fmt(ctx, "fee overflow");
goto function_fail;
}
}
tal_free(this_ctx);
return true;
function_fail:
tal_free(this_ctx);
return false;
}
/* Compute the prob. of success of a set of concurrent set of flows.
*
* IMPORTANT: this is not simply the multiplication of the prob. of success of
* all of them, because they're not independent events. A flow that passes
* through a channel c changes that channel's liquidity and then if another flow
* passes through that same channel the previous liquidity change must be taken
* into account.
*
* P(A and B) != P(A) * P(B),
*
* but
*
* P(A and B) = P(A) * P(B | A)
*
* also due to the linear form of P() we have
*
* P(A and B) = P(A + B)
* */
struct chan_inflight_flow
{
struct amount_msat half[2];
};
// TODO(eduardo): here chan_extra_map should be const
// TODO(eduardo): here flows should be const
double flowset_probability(const tal_t *ctx, struct flow **flows,
const struct gossmap *const gossmap,
struct chan_extra_map *chan_extra_map, char **fail)
{
assert(flows);
assert(gossmap);
assert(chan_extra_map);
tal_t *this_ctx = tal(ctx, tal_t);
char *errmsg;
double prob = 1.0;
// TODO(eduardo): should it be better to use a map instead of an array
// here?
const size_t max_num_chans = gossmap_max_chan_idx(gossmap);
struct chan_inflight_flow *in_flight =
tal_arr(this_ctx, struct chan_inflight_flow, max_num_chans);
for (size_t i = 0; i < max_num_chans; ++i) {
in_flight[i].half[0] = in_flight[i].half[1] = AMOUNT_MSAT(0);
}
for (size_t i = 0; i < tal_count(flows); ++i) {
const struct flow *f = flows[i];
for (size_t j = 0; j < tal_count(f->path); ++j) {
const struct chan_extra_half *h =
get_chan_extra_half_by_chan(gossmap, chan_extra_map,
f->path[j], f->dirs[j]);
if (!h) {
if (fail)
*fail = tal_fmt(
ctx,
"channel not found in chan_extra_map");
goto function_fail;
}
const u32 c_idx = gossmap_chan_idx(gossmap, f->path[j]);
const int c_dir = f->dirs[j];
const struct amount_msat deliver = f->amounts[j];
struct amount_msat prev_flow;
if (!amount_msat_add(&prev_flow, h->htlc_total,
in_flight[c_idx].half[c_dir])) {
if (fail)
*fail = tal_fmt(
ctx, "in-flight amount_msat overflow");
goto function_fail;
}
double edge_prob =
edge_probability(this_ctx, h->known_min, h->known_max,
prev_flow, deliver, &errmsg);
if (edge_prob < 0) {
if (fail)
*fail = tal_fmt(ctx,
"edge_probability failed: %s",
errmsg);
goto function_fail;
}
prob *= edge_prob;
if (!amount_msat_add(&in_flight[c_idx].half[c_dir],
in_flight[c_idx].half[c_dir],
deliver)) {
if (fail)
*fail = tal_fmt(
ctx, "in-flight amount_msat overflow");
goto function_fail;
}
}
}
tal_free(this_ctx);
return prob;
function_fail:
tal_free(this_ctx);
return -1;
}
bool flowset_fee(struct amount_msat *ret, struct flow **flows)
{
assert(ret);
assert(flows);
struct amount_msat fee = AMOUNT_MSAT(0);
for (size_t i = 0; i < tal_count(flows); i++) {
struct amount_msat this_fee;
size_t n = tal_count(flows[i]->amounts);
if (!amount_msat_sub(&this_fee, flows[i]->amounts[0],
flows[i]->amounts[n - 1])) {
return false;
}
if (!amount_msat_add(&fee, this_fee, fee)) {
return false;
}
}
*ret = fee;
return true;
}
/* Helper to access the half chan at flow index idx */
const struct half_chan *flow_edge(const struct flow *flow, size_t idx)
{
assert(flow);
assert(idx < tal_count(flow->path));
return &flow->path[idx]->half[flow->dirs[idx]];
}
#ifndef SUPERVERBOSE_ENABLED
#undef SUPERVERBOSE
#endif
Reference in New Issue View Git Blame Copy Permalink