Browse Source
This doesn't actually remove some of the now-unnecessary infrastructure though. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>plugin-timeout-inc
Rusty Russell
6 years ago
committed by
Christian Decker
Christian Decker
8 changed files with 8 additions and 714 deletions
@ -1,702 +0,0 @@ |
|||
#include "pay.h" |
|||
#include "payalgo.h" |
|||
#include <ccan/crypto/siphash24/siphash24.h> |
|||
#include <ccan/list/list.h> |
|||
#include <ccan/tal/str/str.h> |
|||
#include <ccan/time/time.h> |
|||
#include <common/bolt11.h> |
|||
#include <common/json_command.h> |
|||
#include <common/jsonrpc_errors.h> |
|||
#include <common/param.h> |
|||
#include <common/pseudorand.h> |
|||
#include <common/timeout.h> |
|||
#include <common/type_to_string.h> |
|||
#include <gossipd/gen_gossip_wire.h> |
|||
#include <gossipd/routing.h> |
|||
#include <lightningd/json.h> |
|||
#include <lightningd/jsonrpc.h> |
|||
#include <lightningd/lightningd.h> |
|||
#include <lightningd/log.h> |
|||
#include <lightningd/subd.h> |
|||
#include <sodium/randombytes.h> |
|||
#include <wallet/wallet.h> |
|||
|
|||
/* Record of failures. */ |
|||
enum pay_failure_type { |
|||
FAIL_UNPARSEABLE_ONION, |
|||
FAIL_PAYMENT_REPLY |
|||
}; |
|||
/* A payment failure. */ |
|||
struct pay_failure { |
|||
/* Part of pay_failures list of struct pay */ |
|||
struct list_node list; |
|||
/* The type of payment failure */ |
|||
enum pay_failure_type type; |
|||
/* A tal_arr of route hops, whose parent is
|
|||
* this struct */ |
|||
struct route_hop *route; |
|||
/* The raw onion reply, if TYPE_UNPARSEABLE_ONION, a
|
|||
* tal_arr whose parent is this struct */ |
|||
const u8 *onionreply; |
|||
/* The routing failure, if TYPE_PAYMENT_REPLY, a tal
|
|||
* object whose parent is this struct */ |
|||
struct routing_failure *routing_failure; |
|||
/* The detail of the routing failure. A tal_arr
|
|||
* string whose parent is this struct. */ |
|||
char *details; |
|||
}; |
|||
|
|||
/* Output a pay failure */ |
|||
static void |
|||
json_add_failure(struct json_stream *r, char const *n, |
|||
const struct pay_failure *f) |
|||
{ |
|||
struct routing_failure *rf; |
|||
json_object_start(r, n); |
|||
json_add_string(r, "message", f->details); |
|||
switch (f->type) { |
|||
case FAIL_UNPARSEABLE_ONION: |
|||
json_add_string(r, "type", "FAIL_UNPARSEABLE_ONION"); |
|||
json_add_hex_talarr(r, "onionreply", f->onionreply); |
|||
break; |
|||
|
|||
case FAIL_PAYMENT_REPLY: |
|||
rf = f->routing_failure; |
|||
json_add_string(r, "type", "FAIL_PAYMENT_REPLY"); |
|||
json_add_num(r, "erring_index", rf->erring_index); |
|||
json_add_num(r, "failcode", (unsigned) rf->failcode); |
|||
json_add_pubkey(r, "erring_node", &rf->erring_node); |
|||
json_add_short_channel_id(r, "erring_channel", |
|||
&rf->erring_channel); |
|||
if (rf->channel_update) |
|||
json_add_hex_talarr(r, "channel_update", |
|||
rf->channel_update); |
|||
break; |
|||
} |
|||
json_add_route(r, "route", f->route, tal_count(f->route)); |
|||
json_object_end(r); |
|||
} |
|||
|
|||
/* Output an array of payment failures. */ |
|||
static void |
|||
json_add_failures(struct json_stream *r, char const *n, |
|||
const struct list_head *fs) |
|||
{ |
|||
struct pay_failure *f; |
|||
json_array_start(r, n); |
|||
list_for_each(fs, f, list) { |
|||
json_add_failure(r, NULL, f); |
|||
} |
|||
json_array_end(r); |
|||
} |
|||
|
|||
/* Pay command */ |
|||
struct pay { |
|||
/* Parent command. */ |
|||
struct command *cmd; |
|||
|
|||
/* Bolt11 details */ |
|||
struct sha256 payment_hash; |
|||
struct pubkey receiver_id; |
|||
struct timeabs expiry; |
|||
u32 min_final_cltv_expiry; |
|||
|
|||
/* Command details */ |
|||
u64 msatoshi; |
|||
double riskfactor; |
|||
double maxfeepercent; |
|||
u32 maxdelay; |
|||
|
|||
/* Number of getroute and sendpay tries */ |
|||
unsigned int getroute_tries; |
|||
unsigned int sendpay_tries; |
|||
|
|||
/* Current fuzz we pass into getroute. */ |
|||
double fuzz; |
|||
|
|||
/* Parent of the current pay attempt. This object is
|
|||
* freed, then allocated at the start of each pay |
|||
* attempt to ensure no leaks across long pay attempts */ |
|||
char *try_parent; |
|||
|
|||
/* Current route being attempted. */ |
|||
struct route_hop *route; |
|||
|
|||
/* List of failures to pay. */ |
|||
struct list_head pay_failures; |
|||
|
|||
/* Whether we are attempting payment or not. */ |
|||
bool in_sendpay; |
|||
|
|||
/* Maximum fee that is exempted from the maxfeepercent computation. This
|
|||
* is mainly useful for tiny transfers for which the leveraged fee would |
|||
* be dominated by the forwarding fee. */ |
|||
u64 exemptfee; |
|||
|
|||
/* The description from the bolt11 string */ |
|||
const char *description; |
|||
}; |
|||
|
|||
static struct routing_failure * |
|||
dup_routing_failure(const tal_t *ctx, const struct routing_failure *fail) |
|||
{ |
|||
struct routing_failure *nobj = tal(ctx, struct routing_failure); |
|||
|
|||
nobj->erring_index = fail->erring_index; |
|||
nobj->failcode = fail->failcode; |
|||
nobj->erring_node = fail->erring_node; |
|||
nobj->erring_channel = fail->erring_channel; |
|||
if (fail->channel_update) |
|||
nobj->channel_update = tal_dup_arr(nobj, u8, |
|||
fail->channel_update, |
|||
tal_count(fail->channel_update), |
|||
0); |
|||
else |
|||
nobj->channel_update = NULL; |
|||
|
|||
return nobj; |
|||
} |
|||
|
|||
/* Add a pay_failure from a sendpay_result */ |
|||
static void |
|||
add_pay_failure(struct pay *pay, |
|||
const struct sendpay_result *r) |
|||
{ |
|||
struct pay_failure *f = tal(pay, struct pay_failure); |
|||
|
|||
/* Append to tail */ |
|||
list_add_tail(&pay->pay_failures, &f->list); |
|||
|
|||
switch (r->errorcode) { |
|||
case PAY_UNPARSEABLE_ONION: |
|||
f->type = FAIL_UNPARSEABLE_ONION; |
|||
f->onionreply = tal_dup_arr(f, u8, r->onionreply, |
|||
tal_count(r->onionreply), 0); |
|||
break; |
|||
|
|||
case PAY_TRY_OTHER_ROUTE: |
|||
f->type = FAIL_PAYMENT_REPLY; |
|||
f->routing_failure = dup_routing_failure(f, |
|||
r->routing_failure); |
|||
break; |
|||
|
|||
/* All other errors are disallowed */ |
|||
default: |
|||
abort(); |
|||
} |
|||
f->details = tal_strdup(f, r->details); |
|||
/* Grab the route */ |
|||
f->route = tal_steal(f, pay->route); |
|||
pay->route = NULL; |
|||
} |
|||
|
|||
static void |
|||
json_pay_success(struct pay *pay, |
|||
const struct sendpay_result *r) |
|||
{ |
|||
struct command *cmd = pay->cmd; |
|||
struct json_stream *response; |
|||
|
|||
response = json_stream_success(cmd); |
|||
json_object_start(response, NULL); |
|||
json_add_payment_fields(response, r->payment); |
|||
json_add_num(response, "getroute_tries", pay->getroute_tries); |
|||
json_add_num(response, "sendpay_tries", pay->sendpay_tries); |
|||
json_add_route(response, "route", |
|||
pay->route, tal_count(pay->route)); |
|||
json_add_failures(response, "failures", &pay->pay_failures); |
|||
json_object_end(response); |
|||
was_pending(command_success(cmd, response)); |
|||
} |
|||
|
|||
static void json_pay_failure(struct pay *pay, |
|||
const struct sendpay_result *r) |
|||
{ |
|||
struct json_stream *data; |
|||
struct routing_failure *fail; |
|||
|
|||
assert(!r->succeeded); |
|||
|
|||
switch (r->errorcode) { |
|||
case PAY_IN_PROGRESS: |
|||
data = json_stream_fail(pay->cmd, r->errorcode, r->details); |
|||
json_object_start(data, NULL); |
|||
json_add_num(data, "getroute_tries", pay->getroute_tries); |
|||
json_add_num(data, "sendpay_tries", pay->sendpay_tries); |
|||
json_add_payment_fields(data, r->payment); |
|||
json_add_failures(data, "failures", &pay->pay_failures); |
|||
json_object_end(data); |
|||
was_pending(command_failed(pay->cmd, data)); |
|||
return; |
|||
|
|||
case PAY_RHASH_ALREADY_USED: |
|||
case PAY_STOPPED_RETRYING: |
|||
data = json_stream_fail(pay->cmd, r->errorcode, r->details); |
|||
json_object_start(data, NULL); |
|||
json_add_num(data, "getroute_tries", pay->getroute_tries); |
|||
json_add_num(data, "sendpay_tries", pay->sendpay_tries); |
|||
json_add_failures(data, "failures", &pay->pay_failures); |
|||
json_object_end(data); |
|||
was_pending(command_failed(pay->cmd, data)); |
|||
return; |
|||
|
|||
case PAY_UNPARSEABLE_ONION: |
|||
/* Impossible case */ |
|||
abort(); |
|||
|
|||
case PAY_DESTINATION_PERM_FAIL: |
|||
fail = r->routing_failure; |
|||
assert(r->details != NULL); |
|||
|
|||
data = json_stream_fail(pay->cmd, |
|||
r->errorcode, |
|||
tal_fmt(tmpctx, "failed: %s (%s)", |
|||
onion_type_name(fail->failcode), |
|||
r->details)); |
|||
json_object_start(data, NULL); |
|||
json_add_num(data, "erring_index", |
|||
fail->erring_index); |
|||
json_add_num(data, "failcode", |
|||
(unsigned) fail->failcode); |
|||
json_add_pubkey(data, "erring_node", &fail->erring_node); |
|||
json_add_short_channel_id(data, "erring_channel", |
|||
&fail->erring_channel); |
|||
if (fail->channel_update) |
|||
json_add_hex_talarr(data, "channel_update", |
|||
fail->channel_update); |
|||
json_add_failures(data, "failures", &pay->pay_failures); |
|||
json_object_end(data); |
|||
was_pending(command_failed(pay->cmd, data)); |
|||
return; |
|||
|
|||
case PAY_TRY_OTHER_ROUTE: |
|||
/* Impossible case */ |
|||
abort(); |
|||
return; |
|||
} |
|||
abort(); |
|||
} |
|||
|
|||
/* Determine if we should delay before retrying. Return a reason
|
|||
* string, or NULL if we will not retry */ |
|||
static const char *should_delay_retry(const tal_t *ctx, |
|||
const struct sendpay_result *r) |
|||
{ |
|||
/* The routing failures WIRE_EXPIRY_TOO_FAR, WIRE_EXPIRY_TOO_SOON,
|
|||
* and WIRE_FINAL_EXPIRY_TOO_SOON may arise due to disagreement |
|||
* between the peers about what the block heights are. So |
|||
* delay for those before retrying. */ |
|||
if (!r->succeeded && r->errorcode == PAY_TRY_OTHER_ROUTE) { |
|||
switch (r->routing_failure->failcode) { |
|||
case WIRE_EXPIRY_TOO_FAR: |
|||
case WIRE_EXPIRY_TOO_SOON: |
|||
case WIRE_FINAL_EXPIRY_TOO_SOON: |
|||
return tal_fmt(ctx, |
|||
"Possible blockheight disagreement " |
|||
"(%s from peer)", |
|||
onion_type_name(r->routing_failure->failcode)); |
|||
|
|||
default: |
|||
/* Do nothing */ ; |
|||
} |
|||
} |
|||
|
|||
return NULL; |
|||
} |
|||
|
|||
/* Start a payment attempt. */ |
|||
static struct command_result *json_pay_try(struct pay *pay); |
|||
|
|||
/* Used when delaying. */ |
|||
static void do_pay_try(struct pay *pay) |
|||
{ |
|||
log_info(pay->cmd->ld->log, "pay(%p): Try another route", pay); |
|||
json_pay_try(pay); |
|||
} |
|||
|
|||
/* Call when sendpay returns to us. */ |
|||
static void json_pay_sendpay_resolve(const struct sendpay_result *r, |
|||
void *vpay) |
|||
{ |
|||
struct pay *pay = (struct pay *) vpay; |
|||
char const *why; |
|||
|
|||
pay->in_sendpay = false; |
|||
|
|||
/* If we succeed, hurray */ |
|||
if (r->succeeded) { |
|||
log_info(pay->cmd->ld->log, "pay(%p): Success", pay); |
|||
json_pay_success(pay, r); |
|||
return; |
|||
} |
|||
|
|||
/* We can retry only if it is one of the retryable errors
|
|||
* below. If it is not, fail now. */ |
|||
if (r->errorcode != PAY_UNPARSEABLE_ONION && |
|||
r->errorcode != PAY_TRY_OTHER_ROUTE) { |
|||
log_info(pay->cmd->ld->log, "pay(%p): Failed, reporting to caller", pay); |
|||
json_pay_failure(pay, r); |
|||
return; |
|||
} |
|||
|
|||
add_pay_failure(pay, r); |
|||
|
|||
/* Should retry here, question is whether to retry now or later */ |
|||
|
|||
why = should_delay_retry(pay->try_parent, r); |
|||
if (why) { |
|||
/* We have some reason to delay retrying. */ |
|||
|
|||
log_info(pay->cmd->ld->log, |
|||
"pay(%p): Delay before retry: %s", pay, why); |
|||
|
|||
/* Clear previous try memory. */ |
|||
pay->try_parent = tal_free(pay->try_parent); |
|||
pay->try_parent = tal(pay, char); |
|||
|
|||
/* Delay for 3 seconds if needed. FIXME: random
|
|||
* exponential backoff */ |
|||
new_reltimer(&pay->cmd->ld->timers, pay->try_parent, |
|||
time_from_sec(3), |
|||
&do_pay_try, pay); |
|||
} else |
|||
do_pay_try(pay); |
|||
} |
|||
|
|||
/* Generates a string describing the route. Route should be a
|
|||
* tal_arr */ |
|||
static char const *stringify_route(const tal_t *ctx, struct route_hop *route) |
|||
{ |
|||
size_t i; |
|||
char *rv = tal_strdup(ctx, "us"); |
|||
for (i = 0; i < tal_count(route); ++i) |
|||
tal_append_fmt(&rv, " -> %s (%"PRIu64"msat, %"PRIu32"blk) -> %s", |
|||
type_to_string(ctx, struct short_channel_id, &route[i].channel_id), |
|||
route[i].amount, route[i].delay, |
|||
type_to_string(ctx, struct pubkey, &route[i].nodeid)); |
|||
return rv; |
|||
} |
|||
|
|||
static void log_route(struct pay *pay, struct route_hop *route) |
|||
{ |
|||
log_info(pay->cmd->ld->log, "pay(%p): sendpay via route: %s", |
|||
pay, stringify_route(tmpctx, route)); |
|||
} |
|||
|
|||
static void json_pay_sendpay_resume(const struct sendpay_result *r, |
|||
void *vpay) |
|||
{ |
|||
struct pay *pay = (struct pay *) vpay; |
|||
bool completed = r->succeeded || r->errorcode != PAY_IN_PROGRESS; |
|||
|
|||
if (completed) |
|||
/* Already completed. */ |
|||
json_pay_sendpay_resolve(r, pay); |
|||
else { |
|||
/* Clear previous try memory. */ |
|||
pay->try_parent = tal_free(pay->try_parent); |
|||
pay->try_parent = tal(pay, char); |
|||
|
|||
/* Not yet complete? Wait for it. */ |
|||
wait_payment(pay->try_parent, pay->cmd->ld, &pay->payment_hash, |
|||
json_pay_sendpay_resolve, pay); |
|||
} |
|||
} |
|||
|
|||
static void json_pay_getroute_reply(struct subd *gossip UNUSED, |
|||
const u8 *reply, const int *fds UNUSED, |
|||
struct pay *pay) |
|||
{ |
|||
struct route_hop *route; |
|||
u64 msatoshi_sent; |
|||
u64 fee; |
|||
double feepercent; |
|||
bool fee_too_high; |
|||
bool delay_too_high; |
|||
struct json_stream *data; |
|||
char const *err; |
|||
|
|||
fromwire_gossip_getroute_reply(reply, reply, &route); |
|||
|
|||
if (tal_count(route) == 0) { |
|||
data = json_stream_fail(pay->cmd, PAY_ROUTE_NOT_FOUND, |
|||
"Could not find a route"); |
|||
json_object_start(data, NULL); |
|||
json_add_num(data, "getroute_tries", pay->getroute_tries); |
|||
json_add_num(data, "sendpay_tries", pay->sendpay_tries); |
|||
json_add_failures(data, "failures", &pay->pay_failures); |
|||
json_object_end(data); |
|||
was_pending(command_failed(pay->cmd, data)); |
|||
return; |
|||
} |
|||
|
|||
msatoshi_sent = route[0].amount; |
|||
fee = msatoshi_sent - pay->msatoshi; |
|||
/* Casting u64 to double will lose some precision. The loss of precision
|
|||
* in feepercent will be like 3.0000..(some dots)..1 % - 3.0 %. |
|||
* That loss will not be representable in double. So, it's Okay to |
|||
* cast u64 to double for feepercent calculation. */ |
|||
feepercent = ((double) fee) * 100.0 / ((double) pay->msatoshi); |
|||
fee_too_high = (fee > pay->exemptfee && feepercent > pay->maxfeepercent); |
|||
delay_too_high = (route[0].delay > pay->maxdelay); |
|||
/* compare fuzz to range */ |
|||
if ((fee_too_high || delay_too_high) && pay->fuzz < 0.01) { |
|||
err = ""; |
|||
if (fee_too_high) |
|||
err = tal_fmt(pay, |
|||
"Fee %"PRIu64" is %f%% " |
|||
"of payment %"PRIu64"; " |
|||
"max fee requested is %f%%.", |
|||
fee, feepercent, |
|||
pay->msatoshi, |
|||
pay->maxfeepercent); |
|||
if (fee_too_high && delay_too_high) |
|||
err = tal_fmt(pay, "%s ", err); |
|||
if (delay_too_high) |
|||
err = tal_fmt(pay, |
|||
"%s" |
|||
"Delay (locktime) is %"PRIu32" blocks; " |
|||
"max delay requested is %u.", |
|||
err, route[0].delay, pay->maxdelay); |
|||
|
|||
data = json_stream_fail(pay->cmd, PAY_ROUTE_TOO_EXPENSIVE, err); |
|||
json_object_start(data, NULL); |
|||
json_add_u64(data, "msatoshi", pay->msatoshi); |
|||
json_add_u64(data, "fee", fee); |
|||
json_add_double(data, "feepercent", feepercent); |
|||
json_add_double(data, "maxfeepercent", pay->maxfeepercent); |
|||
json_add_u64(data, "delay", (u64) route[0].delay); |
|||
json_add_num(data, "maxdelay", pay->maxdelay); |
|||
json_add_num(data, "getroute_tries", pay->getroute_tries); |
|||
json_add_num(data, "sendpay_tries", pay->sendpay_tries); |
|||
json_add_route(data, "route", |
|||
route, tal_count(route)); |
|||
json_add_failures(data, "failures", &pay->pay_failures); |
|||
json_object_end(data); |
|||
|
|||
was_pending(command_failed(pay->cmd, data)); |
|||
return; |
|||
} |
|||
if (fee_too_high || delay_too_high) { |
|||
/* Retry with lower fuzz */ |
|||
pay->fuzz -= 0.15; |
|||
if (pay->fuzz <= 0.0) |
|||
pay->fuzz = 0.0; |
|||
json_pay_try(pay); |
|||
return; |
|||
} |
|||
|
|||
++pay->sendpay_tries; |
|||
|
|||
log_route(pay, route); |
|||
assert(!pay->route); |
|||
pay->route = tal_dup_arr(pay, struct route_hop, route, |
|||
tal_count(route), 0); |
|||
|
|||
pay->in_sendpay = true; |
|||
send_payment(pay->try_parent, |
|||
pay->cmd->ld, &pay->payment_hash, route, |
|||
pay->msatoshi, |
|||
pay->description, |
|||
&json_pay_sendpay_resume, pay); |
|||
} |
|||
|
|||
/* Start a payment attempt. Return NULL if deferred, otherwise
|
|||
* command_failed(). */ |
|||
static struct command_result *json_pay_try(struct pay *pay) |
|||
{ |
|||
u8 *req; |
|||
struct command *cmd = pay->cmd; |
|||
struct timeabs now = time_now(); |
|||
u64 maxoverpayment; |
|||
u64 overpayment; |
|||
|
|||
/* If too late anyway, fail now. */ |
|||
if (time_after(now, pay->expiry)) { |
|||
struct json_stream *data |
|||
= json_stream_fail(cmd, PAY_INVOICE_EXPIRED, |
|||
"Invoice expired"); |
|||
json_object_start(data, NULL); |
|||
json_add_num(data, "now", now.ts.tv_sec); |
|||
json_add_num(data, "expiry", pay->expiry.ts.tv_sec); |
|||
json_add_num(data, "getroute_tries", pay->getroute_tries); |
|||
json_add_num(data, "sendpay_tries", pay->sendpay_tries); |
|||
json_add_failures(data, "failures", &pay->pay_failures); |
|||
json_object_end(data); |
|||
return command_failed(cmd, data); |
|||
} |
|||
|
|||
/* Clear previous try memory. */ |
|||
pay->try_parent = tal_free(pay->try_parent); |
|||
pay->try_parent = tal(pay, char); |
|||
|
|||
/* Clear route */ |
|||
pay->route = tal_free(pay->route); |
|||
|
|||
/* Generate an overpayment, from fuzz * maxfee. */ |
|||
/* Now normally the use of double for money is very bad.
|
|||
* Note however that a later stage will ensure that |
|||
* we do not end up paying more than maxfeepercent |
|||
* of the msatoshi we intend to pay. */ |
|||
maxoverpayment = ((double) pay->msatoshi * pay->fuzz * pay->maxfeepercent) |
|||
/ 100.0; |
|||
if (maxoverpayment > 0) { |
|||
/* We will never generate the maximum computed
|
|||
* overpayment this way. Maybe OK for most |
|||
* purposes. */ |
|||
overpayment = pseudorand(maxoverpayment); |
|||
} else |
|||
overpayment = 0; |
|||
|
|||
++pay->getroute_tries; |
|||
|
|||
/* FIXME: use b11->routes */ |
|||
req = towire_gossip_getroute_request(pay->try_parent, |
|||
&cmd->ld->id, |
|||
&pay->receiver_id, |
|||
pay->msatoshi + overpayment, |
|||
pay->riskfactor, |
|||
pay->min_final_cltv_expiry, |
|||
&pay->fuzz, NULL, |
|||
ROUTING_MAX_HOPS); |
|||
subd_req(pay->try_parent, cmd->ld->gossip, req, -1, 0, json_pay_getroute_reply, pay); |
|||
|
|||
return NULL; |
|||
} |
|||
|
|||
static void json_pay_stop_retrying(struct pay *pay) |
|||
{ |
|||
struct sendpay_result *sr; |
|||
|
|||
sr = tal(pay, struct sendpay_result); |
|||
sr->succeeded = false; |
|||
if (pay->in_sendpay) { |
|||
/* Still in sendpay. Return with PAY_IN_PROGRESS */ |
|||
sr->errorcode = PAY_IN_PROGRESS; |
|||
sr->payment = wallet_payment_by_hash(sr, |
|||
pay->cmd->ld->wallet, |
|||
&pay->payment_hash); |
|||
sr->details = "Stopped retrying during payment attempt; " |
|||
"continue monitoring with " |
|||
"pay or listpayments"; |
|||
} else { |
|||
/* Outside sendpay, no ongoing payment */ |
|||
sr->errorcode = PAY_STOPPED_RETRYING; |
|||
sr->details = "Stopped retrying, no ongoing payment"; |
|||
} |
|||
json_pay_failure(pay, sr); |
|||
} |
|||
|
|||
static struct command_result *json_pay(struct command *cmd, |
|||
const char *buffer, |
|||
const jsmntok_t *obj UNNEEDED, |
|||
const jsmntok_t *params) |
|||
{ |
|||
double *riskfactor; |
|||
double *maxfeepercent; |
|||
u64 *msatoshi; |
|||
struct pay *pay = tal(cmd, struct pay); |
|||
struct bolt11 *b11; |
|||
const char *b11str, *desc; |
|||
char *fail; |
|||
unsigned int *retryfor; |
|||
unsigned int *maxdelay; |
|||
unsigned int *exemptfee; |
|||
struct command_result *res; |
|||
|
|||
if (!param(cmd, buffer, params, |
|||
p_req("bolt11", param_string, &b11str), |
|||
p_opt("msatoshi", param_u64, &msatoshi), |
|||
p_opt("description", param_string, &desc), |
|||
p_opt_def("riskfactor", param_double, &riskfactor, 1.0), |
|||
p_opt_def("maxfeepercent", param_percent, &maxfeepercent, 0.5), |
|||
p_opt_def("retry_for", param_number, &retryfor, 60), |
|||
p_opt_def("maxdelay", param_number, &maxdelay, |
|||
cmd->ld->config.locktime_max), |
|||
p_opt_def("exemptfee", param_number, &exemptfee, 5000), |
|||
NULL)) |
|||
return command_param_failed(); |
|||
|
|||
b11 = bolt11_decode(pay, b11str, desc, &fail); |
|||
if (!b11) { |
|||
return command_fail(cmd, JSONRPC2_INVALID_PARAMS, |
|||
"Invalid bolt11: %s", fail); |
|||
} |
|||
|
|||
pay->cmd = cmd; |
|||
pay->payment_hash = b11->payment_hash; |
|||
pay->receiver_id = b11->receiver_id; |
|||
memset(&pay->expiry, 0, sizeof(pay->expiry)); |
|||
pay->expiry.ts.tv_sec = b11->timestamp + b11->expiry; |
|||
pay->min_final_cltv_expiry = b11->min_final_cltv_expiry; |
|||
pay->exemptfee = *exemptfee; |
|||
|
|||
if (b11->msatoshi) { |
|||
if (msatoshi) { |
|||
return command_fail(cmd, JSONRPC2_INVALID_PARAMS, |
|||
"msatoshi parameter unnecessary"); |
|||
} |
|||
msatoshi = b11->msatoshi; |
|||
} else { |
|||
if (!msatoshi) { |
|||
return command_fail(cmd, JSONRPC2_INVALID_PARAMS, |
|||
"msatoshi parameter required"); |
|||
} |
|||
} |
|||
pay->msatoshi = *msatoshi; |
|||
pay->riskfactor = *riskfactor * 1000; |
|||
pay->maxfeepercent = *maxfeepercent; |
|||
|
|||
if (*maxdelay < pay->min_final_cltv_expiry) { |
|||
return command_fail(cmd, JSONRPC2_INVALID_PARAMS, |
|||
"maxdelay (%u) must be greater than " |
|||
"min_final_cltv_expiry (%"PRIu32") of " |
|||
"invoice", |
|||
*maxdelay, pay->min_final_cltv_expiry); |
|||
} |
|||
pay->maxdelay = *maxdelay; |
|||
|
|||
pay->getroute_tries = 0; |
|||
pay->sendpay_tries = 0; |
|||
/* Higher fuzz increases the potential fees we will pay, since
|
|||
* higher fuzz makes it more likely that high-fee paths get |
|||
* selected. We start with very high fuzz, but if the |
|||
* returned route is too expensive for the given |
|||
* `maxfeepercent` or `maxdelay` we reduce the fuzz. |
|||
* Starting with high |
|||
* fuzz means, if the user allows high fee/locktime, we can take |
|||
* advantage of that to increase randomization and |
|||
* improve privacy somewhat. */ |
|||
pay->fuzz = 0.75; |
|||
pay->try_parent = NULL; |
|||
/* Start with no route */ |
|||
pay->route = NULL; |
|||
/* Start with no failures */ |
|||
list_head_init(&pay->pay_failures); |
|||
pay->in_sendpay = false; |
|||
pay->description = b11->description; |
|||
|
|||
/* Initiate payment */ |
|||
res = json_pay_try(pay); |
|||
if (res) |
|||
return res; |
|||
|
|||
/* Set up timeout. */ |
|||
new_reltimer(&cmd->ld->timers, pay, time_from_sec(*retryfor), |
|||
&json_pay_stop_retrying, pay); |
|||
return command_still_pending(cmd); |
|||
} |
|||
|
|||
static const struct json_command pay_command = { |
|||
"pay", |
|||
json_pay, |
|||
"Send payment specified by {bolt11} with {msatoshi} " |
|||
"(ignored if {bolt11} has an amount), " |
|||
"{description} (required if {bolt11} uses description hash), " |
|||
"{riskfactor} (default 1.0), " |
|||
"{maxfeepercent} (default 0.5) the maximum acceptable fee as a percentage (e.g. 0.5 => 0.5%), " |
|||
"{exemptfee} (default 5000 msat) disables the maxfeepercent check for fees below the threshold, " |
|||
"{retry_for} (default 60) the integer number of seconds before we stop retrying, and " |
|||
"{maxdelay} (default 500) the maximum number of blocks we allow the funds to possibly get locked" |
|||
}; |
|||
AUTODATA(json_command, &pay_command); |
|||
@ -1,5 +0,0 @@ |
|||
#ifndef LIGHTNING_LIGHTNINGD_PAYALGO_H |
|||
#define LIGHTNING_LIGHTNINGD_PAYALGO_H |
|||
#include "config.h" |
|||
|
|||
#endif /* LIGHTNING_LIGHTNINGD_PAYALGO_H */ |
|||
Loading…
Reference in new issue