core-lightning/lightningd/pay.c

#include "config.h"
#include <ccan/json_escape/json_escape.h>
#include <ccan/mem/mem.h>
#include <ccan/tal/str/str.h>
#include <common/blinding.h>
#include <common/bolt12_merkle.h>
#include <common/configdir.h>
#include <common/json_command.h>
#include <common/json_param.h>
#include <common/onion_decode.h>
#include <common/onionreply.h>
#include <common/route.h>
#include <common/timeout.h>
#include <lightningd/chaintopology.h>
#include <lightningd/channel.h>
#include <lightningd/invoice.h>
#include <lightningd/notification.h>
#include <lightningd/pay.h>
#include <lightningd/peer_control.h>
#include <lightningd/peer_htlcs.h>
#include <wallet/invoices.h>

/* Routing failure object */
struct routing_failure {
	unsigned int erring_index;
	enum onion_wire failcode;
	const struct node_id *erring_node;
	const struct short_channel_id *erring_channel;
	int channel_dir;
	/* If remote sent us a message, this is it. */
	const u8 *msg;
};

/* waitsendpay command */
struct waitsendpay_command {
	struct list_node list;

	struct sha256 payment_hash;
	u64 partid;
	u64 groupid;
	struct command *cmd;
	void *arg;

	struct command_result *(*success)(struct command *cmd,
					  const struct wallet_payment *payment,
					  void *arg);
	struct command_result *(*fail)(struct command *cmd,
				       const struct wallet_payment *payment,
				       enum jsonrpc_errcode pay_errcode,
				       const struct onionreply *onionreply,
				       const struct routing_failure *fail,
				       const char *errmsg,
				       void *arg);
};

static bool string_to_payment_status(const char *status_str, size_t len,
				     enum payment_status *status)
{
	if (memeqstr(status_str, len, "complete")) {
		*status = PAYMENT_COMPLETE;
		return true;
	} else if (memeqstr(status_str, len, "pending")) {
		*status = PAYMENT_PENDING;
		return true;
	} else if (memeqstr(status_str, len, "failed")) {
		*status = PAYMENT_FAILED;
		return true;
	}
	return false;
}

static const char *payment_status_to_string(const enum payment_status status)
{
	switch (status) {
	case PAYMENT_COMPLETE:
		return "complete";
	case PAYMENT_FAILED:
		return "failed";
	case PAYMENT_PENDING:
		return "pending";
	}
	//This should never happen
	abort();
}


static void destroy_waitsendpay_command(struct waitsendpay_command *pc)
{
	list_del(&pc->list);
}

/* Owned by cmd, if cmd is deleted, then sendpay_success/sendpay_fail will
 * no longer be called. */
static void
add_waitsendpay_waiter_(struct lightningd *ld,
			struct command *cmd,
			const struct sha256 *payment_hash,
			u64 partid, u64 groupid,
			struct command_result *(*success)(struct command *cmd,
							  const struct wallet_payment *payment,
							  void *arg),
			struct command_result *(*fail)(struct command *cmd,
						       const struct wallet_payment *payment,
						       enum jsonrpc_errcode pay_errcode,
						       const struct onionreply *onionreply,
						       const struct routing_failure *fail,
						       const char *errmsg,
						       void *arg),
			void *arg)
{
	struct waitsendpay_command *pc = tal(cmd, struct waitsendpay_command);

	pc->payment_hash = *payment_hash;
	pc->partid = partid;
	pc->groupid = groupid;
	pc->cmd = cmd;
	pc->arg = arg;
	pc->success = success;
	pc->fail = fail;
	list_add(&ld->waitsendpay_commands, &pc->list);
	tal_add_destructor(pc, destroy_waitsendpay_command);
}

#define add_waitsendpay_waiter(ld, cmd, payment_hash, partid, groupid, success, fail, arg) \
	add_waitsendpay_waiter_((ld), (cmd), (payment_hash), (partid), (groupid), \
				typesafe_cb_preargs(struct command_result *, void *, \
						    (success), (arg),	\
						    struct command *,	\
						    const struct wallet_payment *), \
				typesafe_cb_preargs(struct command_result *, void *, \
						    (fail), (arg),	\
						    struct command *,	\
						    const struct wallet_payment *, \
						    enum jsonrpc_errcode, \
						    const struct onionreply *, \
						    const struct routing_failure *, \
						    const char *),	\
				(arg))

/* Outputs fields, not a separate object*/
void json_add_payment_fields(struct json_stream *response,
			     const struct wallet_payment *t)
{
	json_add_u64(response, "created_index", t->id);
	json_add_u64(response, "id", t->id);
	json_add_sha256(response, "payment_hash", &t->payment_hash);
	json_add_u64(response, "groupid", t->groupid);
	if (t->updated_index)
		json_add_u64(response, "updated_index", t->updated_index);
	if (t->partid)
		json_add_u64(response, "partid", t->partid);
	if (t->destination != NULL)
		json_add_node_id(response, "destination", t->destination);

	/* If we have a 0 amount delivered at the remote end we simply don't
	 * know since the onion was generated externally. */
	if (amount_msat_greater(t->msatoshi, AMOUNT_MSAT(0)))
		json_add_amount_msat(response, "amount_msat", t->msatoshi);

	json_add_amount_msat(response, "amount_sent_msat", t->msatoshi_sent);
	json_add_u32(response, "created_at", t->timestamp);
	if (t->completed_at)
		json_add_u32(response, "completed_at", *t->completed_at);

	switch (t->status) {
	case PAYMENT_PENDING:
		json_add_string(response, "status", "pending");
		break;
	case PAYMENT_COMPLETE:
		json_add_string(response, "status", "complete");
		break;
	case PAYMENT_FAILED:
		json_add_string(response, "status", "failed");
		break;
	}
	if (t->payment_preimage)
		json_add_preimage(response, "payment_preimage",
                    t->payment_preimage);
	if (t->label)
		json_add_string(response, "label", t->label);
	if (t->invstring) {
		if (strstarts(t->invstring, "lni"))
			json_add_string(response, "bolt12", t->invstring);
		else
			json_add_string(response, "bolt11", t->invstring);
	}
	if (t->description)
		json_add_string(response, "description", t->description);

	if (t->failonion)
		json_add_hex(response, "erroronion", t->failonion,
			     tal_count(t->failonion));
}

static struct command_result *sendpay_success(struct command *cmd,
					      const struct wallet_payment *payment,
					      void *unused)
{
	struct json_stream *response;

	assert(payment->status == PAYMENT_COMPLETE);

	response = json_stream_success(cmd);
	json_add_payment_fields(response, payment);
	return command_success(cmd, response);
}

static void
json_add_routefail_info(struct json_stream *js,
			unsigned int erring_index,
			enum onion_wire failcode,
			const struct node_id *erring_node,
			const struct short_channel_id *erring_channel,
			int channel_dir,
			const u8 *msg)
{
	const char *failcodename = onion_wire_name(failcode);

	json_add_num(js, "erring_index", erring_index);
	json_add_num(js, "failcode", failcode);
	/* FIXME: Better way to detect this? */
	if (!strstarts(failcodename, "INVALID "))
		json_add_string(js, "failcodename", failcodename);

	if (erring_node != NULL)
		json_add_node_id(js, "erring_node", erring_node);

	if (erring_channel != NULL) {
		json_add_short_channel_id(js, "erring_channel", *erring_channel);
		json_add_num(js, "erring_direction", channel_dir);
	}

	if (msg)
		json_add_hex_talarr(js, "raw_message", msg);
}

void json_sendpay_fail_fields(struct json_stream *js,
			      const struct wallet_payment *payment,
			      enum jsonrpc_errcode pay_errcode,
			      const struct onionreply *onionreply,
			      const struct routing_failure *fail)
{
	/* "immediate_routing_failure" is before payment creation. */
	if (payment)
		json_add_payment_fields(js, payment);
	if (pay_errcode == PAY_UNPARSEABLE_ONION && onionreply)
		json_add_hex_talarr(js, "onionreply", onionreply->contents);
	else if (fail)
		json_add_routefail_info(js,
					fail->erring_index,
					fail->failcode,
					fail->erring_node,
					fail->erring_channel,
					fail->channel_dir,
					fail->msg);
}

static const char *sendpay_errmsg_fmt(const tal_t *ctx, enum jsonrpc_errcode pay_errcode,
				      const struct routing_failure *fail,
				      const char *details)
{
	char *errmsg;
	if (pay_errcode == PAY_UNPARSEABLE_ONION)
		errmsg = "Malformed error reply";
	else {
		assert(fail);
		errmsg = tal_fmt(ctx, "failed: %s (%s)",
				 onion_wire_name(fail->failcode), details);
	}
	return errmsg;
}

/* onionreply used if pay_errcode == PAY_UNPARSEABLE_ONION */
static struct command_result *
sendpay_fail(struct command *cmd,
	     const struct wallet_payment *payment,
	     enum jsonrpc_errcode pay_errcode,
	     const struct onionreply *onionreply,
	     const struct routing_failure *fail,
	     const char *errmsg,
	     void *unused)
{
	struct json_stream *data;

	data = json_stream_fail(cmd, pay_errcode,
				errmsg);
	json_sendpay_fail_fields(data,
				 payment,
				 pay_errcode,
				 onionreply,
				 fail);
	json_object_end(data);
	return command_failed(cmd, data);
}

/* We defer sendpay "success" until we know it's pending; consumes cmd */
static struct command_result *
json_sendpay_in_progress(struct command *cmd,
			 const struct wallet_payment *payment)
{
	struct json_stream *response = json_stream_success(cmd);
	json_add_string(response, "message",
			"Monitor status with listpays or waitsendpay");
	json_add_payment_fields(response, payment);
	return command_success(cmd, response);
}

static void tell_waiters_failed(struct lightningd *ld,
				const struct sha256 *payment_hash,
				const struct wallet_payment *payment,
				enum jsonrpc_errcode pay_errcode,
				const struct onionreply *onionreply,
				const struct routing_failure *fail,
				const char *details)
{
	struct waitsendpay_command *pc;
	struct waitsendpay_command *next;
	const char *errmsg =
	    sendpay_errmsg_fmt(tmpctx, pay_errcode, fail, details);

	/* Careful: ->fail deletes cmd */
	list_for_each_safe(&ld->waitsendpay_commands, pc, next, list) {
		if (!sha256_eq(payment_hash, &pc->payment_hash))
			continue;
		if (payment->partid != pc->partid)
			continue;
		if (payment->groupid != pc->groupid)
			continue;

		pc->fail(pc->cmd, payment, pay_errcode, onionreply, fail, errmsg, pc->arg);
	}

	notify_sendpay_failure(ld,
			       payment,
			       pay_errcode,
			       onionreply,
			       fail,
			       errmsg);
}

static void tell_waiters_success(struct lightningd *ld,
				 const struct sha256 *payment_hash,
				 struct wallet_payment *payment)
{
	struct waitsendpay_command *pc;
	struct waitsendpay_command *next;

	/* Careful: sendpay_success deletes cmd */
	list_for_each_safe(&ld->waitsendpay_commands, pc, next, list) {
		if (!sha256_eq(payment_hash, &pc->payment_hash))
			continue;
		if (payment->partid != pc->partid)
			continue;
		if (payment->groupid != pc->groupid)
			continue;

		pc->success(pc->cmd, payment, pc->arg);
	}
	notify_sendpay_success(ld, payment);
}

void payment_succeeded(struct lightningd *ld,
		       const struct sha256 *payment_hash,
		       u64 partid, u64 groupid,
		       const struct preimage *rval)
{
	struct wallet_payment *payment;

	wallet_payment_set_status(ld->wallet, payment_hash,
				  partid, groupid,
				  PAYMENT_COMPLETE, rval);
	payment = wallet_payment_by_hash(tmpctx, ld->wallet,
					 payment_hash,
					 partid, groupid);
	assert(payment);

	if (payment->local_invreq_id)
		wallet_invoice_request_mark_used(ld->wallet->db,
						 payment->local_invreq_id);
	tell_waiters_success(ld, payment_hash, payment);
}

/* Return a struct routing_failure for an immediate failure
 * (returned directly from send_htlc_out). The returned
 * failure is allocated from the given context. */
static struct routing_failure*
immediate_routing_failure(const tal_t *ctx,
			  const struct lightningd *ld,
			  enum onion_wire failcode,
			  struct short_channel_id channel0,
			  const struct node_id *dstid)
{
	struct routing_failure *routing_failure;

	assert(failcode);

	routing_failure = tal(ctx, struct routing_failure);
	routing_failure->erring_index = 0;
	routing_failure->failcode = failcode;
	routing_failure->erring_node =
	    tal_dup(routing_failure, struct node_id, &ld->our_nodeid);
	routing_failure->erring_channel =
	    tal_dup(routing_failure, struct short_channel_id, &channel0);
	routing_failure->channel_dir = node_id_idx(&ld->our_nodeid, dstid);
	routing_failure->msg = NULL;

	return routing_failure;
}

/* Return a struct routing_failure for a local failure allocated
 * from the given context. */
static struct routing_failure*
local_routing_failure(const tal_t *ctx,
		      const struct lightningd *ld,
		      enum onion_wire failcode,
		      const struct wallet_payment *payment)
{
	struct routing_failure *routing_failure;

	routing_failure = tal(ctx, struct routing_failure);
	routing_failure->erring_index = 0;
	routing_failure->failcode = failcode;

	routing_failure->erring_node =
	    tal_dup(routing_failure, struct node_id, &ld->our_nodeid);

	if (payment->route_nodes != NULL && payment->route_channels != NULL) {
		routing_failure->erring_channel =
		    tal_dup(routing_failure, struct short_channel_id,
			    &payment->route_channels[0]);
		routing_failure->channel_dir =
		    node_id_idx(&ld->our_nodeid, &payment->route_nodes[0]);
	} else {
		routing_failure->erring_channel = NULL;
	}

	routing_failure->msg = NULL;

	return routing_failure;
}

/* Fills in *pay_errcode with PAY_TRY_OTHER_ROUTE or PAY_DESTINATION_PERM_FAIL */
static struct routing_failure*
remote_routing_failure(const tal_t *ctx,
		       struct lightningd *ld,
		       const struct wallet_payment *payment,
		       const u8 *failuremsg,
		       int origin_index,
		       struct logger *log,
		       enum jsonrpc_errcode *pay_errcode)
{
	enum onion_wire failcode = fromwire_peektype(failuremsg);
	struct routing_failure *routing_failure;
	const struct node_id *route_nodes;
	const struct node_id *erring_node;
	const struct short_channel_id *route_channels;
	const struct short_channel_id *erring_channel;
	int dir;

	routing_failure = tal(ctx, struct routing_failure);
	route_nodes = payment->route_nodes;
	route_channels = payment->route_channels;

	assert(route_nodes == NULL || origin_index < tal_count(route_nodes));

	/* Either we have both channels and nodes, or neither */
	assert((route_nodes == NULL) == (route_channels == NULL));

	if (route_nodes == NULL) {
		/* This means we have the `shared_secrets`, but cannot infer
		 * the erring channel and node since we don't have them. This
		 * can happen if the payment was initialized using `sendonion`
		 * and the `shared_secrets` where specified. */
		dir = 0;
		erring_channel = NULL;
		erring_node = NULL;

		/* We don't know if there's another route, that'd depend on
		 * where the failure occured and whether it was a node
		 * failure. Let's assume it wasn't a terminal one, and have
		 * the sendonion caller deal with the actual decision. */
		*pay_errcode = PAY_TRY_OTHER_ROUTE;
	} else if (origin_index == tal_count(route_nodes) - 1) {
		/* If any channel is to blame, it's the last one. */
		erring_channel = &route_channels[origin_index];
		/* Single hop? */
		if (origin_index == 0)
			dir = node_id_idx(&ld->our_nodeid,
					  &route_nodes[origin_index]);
		else
			dir = node_id_idx(&route_nodes[origin_index - 1],
					  &route_nodes[origin_index]);

		/* BOLT #4:
		 *
		 * - if the _final node_ is returning the error:
		 *   - if the PERM bit is set:
		 *     - SHOULD fail the payment.
		 * */
		if (failcode & BADONION)
			*pay_errcode = PAY_UNPARSEABLE_ONION;
		else if (failcode & PERM)
			*pay_errcode = PAY_DESTINATION_PERM_FAIL;
		else
			/* FIXME: not right for WIRE_FINAL_EXPIRY_TOO_SOON */
			*pay_errcode = PAY_TRY_OTHER_ROUTE;
		erring_node = &route_nodes[origin_index];
	} else {
		*pay_errcode = PAY_TRY_OTHER_ROUTE;

		/* Report the *next* channel as failing. */
		erring_channel = &route_channels[origin_index + 1];

		dir = node_id_idx(&route_nodes[origin_index],
				  &route_nodes[origin_index+1]);

		/* If the error is a BADONION, then it's on behalf of the
		 * following node. */
		if (failcode & BADONION) {
			log_debug(log, "failcode %u from onionreply %s",
				  failcode, tal_hex(tmpctx, failuremsg));
			erring_node = &route_nodes[origin_index + 1];
		} else
			erring_node = &route_nodes[origin_index];
	}

	routing_failure->erring_index = (unsigned int) (origin_index + 1);
	routing_failure->failcode = failcode;
	routing_failure->msg = tal_dup_talarr(routing_failure, u8, failuremsg);

	routing_failure->erring_node =
		tal_dup_or_null(routing_failure, struct node_id, erring_node);

	if (erring_channel != NULL) {
		routing_failure->erring_channel = tal_dup(
		    routing_failure, struct short_channel_id, erring_channel);
		routing_failure->channel_dir = dir;
	} else {
		routing_failure->erring_channel = NULL;
		routing_failure->channel_dir = 0;
	}

	return routing_failure;
}

void payment_failed(struct lightningd *ld,
		    struct logger *log,
		    const struct sha256 *payment_hash,
		    u64 partid, u64 groupid,
		    const struct onionreply *failonion,
		    const u8 *failmsg,
		    const char *localfail)
{
	struct wallet_payment *payment;
	struct routing_failure* fail = NULL;
	const char *failstr;
	enum jsonrpc_errcode pay_errcode;
	int origin_index;

	payment = wallet_payment_by_hash(tmpctx, ld->wallet,
					 payment_hash,
					 partid, groupid);

#ifdef COMPAT_V052
	/* Prior to "pay: delete HTLC when we delete payment." we would
	 * delete a payment on retry, but leave the HTLC. */
	if (!payment) {
		log_unusual(log,
			    "No payment for %s:"
			    " was this an old database?",
			    fmt_sha256(tmpctx, payment_hash));
		return;
	}
#else
	assert(payment);
#endif
	assert((payment->route_channels == NULL) == (payment->route_nodes == NULL));

	/* This gives more details than a generic failure message */
	if (localfail) {
		/* Use temporary_channel_failure if failmsg has it */
		enum onion_wire failcode;
		failcode = fromwire_peektype(failmsg);

		fail = local_routing_failure(tmpctx, ld, failcode, payment);
		log_debug(log, "local_routing_failure: %u (%s)",
			  fail->failcode,
			  onion_wire_name(fail->failcode));
		failstr = localfail;
		pay_errcode = PAY_TRY_OTHER_ROUTE;
	} else if (payment->path_secrets == NULL) {
		/* This was a payment initiated with `sendonion`/`injectonionmessage`, we therefore
		 * don't have the path secrets and cannot decode the error
		 * onion. We hand it to the user. */
		pay_errcode = PAY_UNPARSEABLE_ONION;
		fail = NULL;
		failstr = NULL;
	} else if (failmsg) {
		/* This can happen when a direct peer told channeld it's a
		 * malformed onion using update_fail_malformed_htlc. */
		failstr = "local failure";
		origin_index = 0;
		pay_errcode = PAY_TRY_OTHER_ROUTE;
		goto use_failmsg;
	} else {
		/* Must be normal remote fail with an onion-wrapped error. */
		failstr = "reply from remote";
		/* Try to parse reply. */
		struct secret *path_secrets = payment->path_secrets;

		failmsg = unwrap_onionreply(tmpctx, path_secrets,
					    tal_count(path_secrets),
					    failonion, &origin_index);
		if (!failmsg) {
			log_info(log,
				 "htlc failed with bad reply (%s)",
				 tal_hex(tmpctx, failonion->contents));
			/* Cannot record failure. */
			fail = NULL;
			pay_errcode = PAY_UNPARSEABLE_ONION;
		} else {
			enum onion_wire failcode;

		use_failmsg:
			failcode = fromwire_peektype(failmsg);
			log_info(log,
				 "htlc failed from %ith node "
				 "with code 0x%04x (%s)",
				 origin_index,
				 failcode, onion_wire_name(failcode));
			fail = remote_routing_failure(tmpctx, ld,
						      payment, failmsg,
						      origin_index,
						      log,
						      &pay_errcode);
		}
	}

	wallet_payment_set_status(ld->wallet, payment_hash,
				  partid, groupid,
				  PAYMENT_FAILED, NULL);
	wallet_payment_set_failinfo(ld->wallet,
				    payment_hash,
				    partid,
				    /* We only save failonion if it's unparseable */
				    fail ? NULL : failonion,
				    pay_errcode == PAY_DESTINATION_PERM_FAIL,
				    fail ? fail->erring_index : -1,
				    fail ? fail->failcode : 0,
				    fail ? fail->erring_node : NULL,
				    fail ? fail->erring_channel : NULL,
				    NULL,
				    failstr,
				    fail ? fail->channel_dir : 0);

	tell_waiters_failed(ld, payment_hash, payment, pay_errcode,
			    failonion, fail, failstr);
}

/* Wait for a payment. If cmd is deleted, then wait_payment()
 * no longer be called.
 * Return callback if we called already, otherwise NULL. */
static struct command_result *wait_payment(struct lightningd *ld,
					   struct command *cmd,
					   const struct sha256 *payment_hash,
					   u64 partid, u64 groupid)
{
	struct wallet_payment *payment;
	struct onionreply *failonionreply;
	bool faildestperm;
	int failindex;
	enum onion_wire failcode;
	struct node_id *failnode;
	struct short_channel_id *failchannel;
	u8 *failupdate;
	char *faildetail;
	struct routing_failure *fail;
	int faildirection;
	enum jsonrpc_errcode rpcerrorcode;

	payment = wallet_payment_by_hash(tmpctx, ld->wallet,
					 payment_hash, partid, groupid);
	if (!payment) {
		return command_fail(cmd, PAY_NO_SUCH_PAYMENT,
				    "Never attempted payment part %"PRIu64
				    " for '%s'",
				    partid,
				    fmt_sha256(tmpctx, payment_hash));
	}

	log_debug(cmd->ld->log, "Payment part %"PRIu64"/%"PRIu64"/%"PRIu64" status %u",
		  partid, payment->partid, payment->groupid, payment->status);

	switch (payment->status) {
	case PAYMENT_PENDING:
		add_waitsendpay_waiter(ld, cmd, payment_hash, partid, groupid,
				       sendpay_success, sendpay_fail, NULL);
		return NULL;

	case PAYMENT_COMPLETE:
		return sendpay_success(cmd, payment, NULL);

	case PAYMENT_FAILED:
		/* Get error from DB */
		wallet_payment_get_failinfo(tmpctx, ld->wallet,
					    payment_hash,
					    partid,
					    groupid,
					    &failonionreply,
					    &faildestperm,
					    &failindex,
					    &failcode,
					    &failnode,
					    &failchannel,
					    &failupdate,
					    &faildetail,
					    &faildirection);
		/* Old DB might not save failure information */
		if (!failonionreply && !failnode) {
			return command_fail(cmd, PAY_UNSPECIFIED_ERROR,
					    "Payment failure reason unknown");
		} else if (failonionreply) {
			/* failed to parse returned onion error */
			return sendpay_fail(
			    cmd, payment, PAY_UNPARSEABLE_ONION, failonionreply,
			    NULL,
			    sendpay_errmsg_fmt(tmpctx, PAY_UNPARSEABLE_ONION,
					       NULL, faildetail),
			    NULL);
		} else {
			/* Parsed onion error, get its details */
			assert(failnode);
			fail = tal(tmpctx, struct routing_failure);
			fail->erring_index = failindex;
			fail->failcode = failcode;
			fail->erring_node =
			    tal_dup(fail, struct node_id, failnode);

			if (failchannel) {
				fail->erring_channel = tal_dup(
				    fail, struct short_channel_id, failchannel);
				fail->channel_dir = faildirection;
			} else {
				fail->erring_channel = NULL;
			}

			/* FIXME: We don't store this! */
			fail->msg = NULL;

			rpcerrorcode = faildestperm ? PAY_DESTINATION_PERM_FAIL
						    : PAY_TRY_OTHER_ROUTE;

			return sendpay_fail(
			    cmd, payment, rpcerrorcode, NULL, fail,
			    sendpay_errmsg_fmt(tmpctx, rpcerrorcode, fail,
					       faildetail),
			    NULL);
		}
	}

	/* Impossible. */
	abort();
}

/* Returns failmsg on failure, tallocated off ctx */
static const u8 *send_onion(const tal_t *ctx, struct lightningd *ld,
			    const struct onionpacket *packet,
			    const struct route_hop *first_hop,
			    const struct amount_msat final_amount,
			    const struct sha256 *payment_hash,
			    const struct pubkey *path_key,
			    u64 partid,
			    u64 groupid,
			    struct channel *channel,
			    struct htlc_out **hout)
{
	const u8 *onion;
	unsigned int base_expiry;

	/* Use bitcoind's block height, even if we're behind in processing */
	base_expiry = get_network_blockheight(ld->topology) + 1;
	onion = serialize_onionpacket(tmpctx, packet);
	return send_htlc_out(ctx, channel, first_hop->amount,
			     base_expiry + first_hop->delay,
			     final_amount, payment_hash,
			     path_key, partid, groupid, onion, NULL, hout);
}

static struct command_result *check_invoice_request_usage(struct command *cmd,
							  const struct sha256 *local_invreq_id)
{
	enum offer_status status;
	struct db_stmt *stmt;

	if (!local_invreq_id)
		return NULL;

	if (!wallet_invoice_request_find(tmpctx, cmd->ld->wallet,
					 local_invreq_id,
					 NULL, &status))
		return command_fail(cmd, PAY_INVOICE_REQUEST_INVALID,
				    "Unknown invoice_request %s",
				    fmt_sha256(tmpctx, local_invreq_id));

	if (!offer_status_active(status))
		return command_fail(cmd, PAY_INVOICE_REQUEST_INVALID,
				    "Inactive invoice_request %s",
				    fmt_sha256(tmpctx, local_invreq_id));

	if (!offer_status_single(status))
		return NULL;

	/* OK, we must not attempt more than one payment at once for
	 * single_use invoice_request we publish! */
	stmt = payments_by_invoice_request(cmd->ld->wallet, local_invreq_id);
	if (stmt) {
		const struct wallet_payment *payment;
		payment = payment_get_details(tmpctx, stmt);

		tal_free(stmt);
		switch (payment->status) {
		case PAYMENT_COMPLETE:
			return command_fail(cmd, PAY_INVOICE_REQUEST_INVALID,
					    "Single-use invoice_request already paid"
					    " with %s",
					    fmt_sha256(tmpctx,
						       &payment->payment_hash));
		case PAYMENT_PENDING:
			return command_fail(cmd, PAY_INVOICE_REQUEST_INVALID,
					    "Single-use invoice_request already"
					    " in progress with %s",
					    fmt_sha256(tmpctx,
						       &payment->payment_hash));
		case PAYMENT_FAILED:
			break;
		}
	}

	return NULL;
}

static struct channel *
find_channel_for_htlc_add(struct lightningd *ld,
			  struct command *cmd,
			  const struct node_id *node,
			  struct short_channel_id scid_or_alias,
			  const struct amount_msat *amount)
{
	struct channel *channel;
	struct short_channel_id scid;
	struct peer *peer = peer_by_id(ld, node);
	if (!peer)
		return NULL;

	channel = find_channel_by_scid(peer, scid_or_alias);
	if (channel && channel_state_can_add_htlc(channel->state)) {
		goto found;
	}

	channel = find_channel_by_alias(peer, scid_or_alias, LOCAL);
	if (channel && channel_state_can_add_htlc(channel->state)) {
		goto found;
	}

	/* All-zero means "any" */
	if (!channel && memeqzero(&scid_or_alias, sizeof(scid_or_alias))) {
		list_for_each(&peer->channels, channel, list) {
			if (channel_state_can_add_htlc(channel->state) &&
			    amount_msat_greater(channel->our_msat, *amount)) {
				goto found;
			}
		}
	}

	log_debug(ld->log, "No channel found for selector %s (%s)",
		  fmt_short_channel_id(tmpctx, scid_or_alias),
		  fmt_amount_msat(tmpctx, *amount));
	return NULL;

found:
	scid = channel_scid_or_local_alias(channel);
	log_debug(
	    ld->log, "Selected channel %s (%s) for selector %s (%s)",
	    fmt_short_channel_id(tmpctx, scid),
	    fmt_amount_msat(tmpctx, channel->our_msat),
	    fmt_short_channel_id(tmpctx, scid_or_alias),
	    fmt_amount_msat(tmpctx, *amount));

	return channel;
}

/* Check if payment already in progress.  Returns NULL if all good */
static struct command_result *check_progress(struct lightningd *ld,
					     struct command *cmd,
					     const struct sha256 *rhash,
					     struct amount_msat msat,
					     struct amount_msat total_msat,
					     u64 partid,
					     u64 group,
					     const struct node_id *destination)
{
	bool have_complete = false;
	struct amount_msat msat_already_pending = AMOUNT_MSAT(0);

	/* Now, do we already have one or more payments? */
	for (struct db_stmt *stmt = payments_by_hash(cmd->ld->wallet, rhash);
	     stmt;
	     stmt = payments_next(cmd->ld->wallet, stmt)) {
		const struct wallet_payment *payment;

		payment = payment_get_details(tmpctx, stmt);
		log_debug(ld->log, "Payment: %s %s",
			  fmt_amount_msat(tmpctx, payment->msatoshi),
			  payment->status == PAYMENT_COMPLETE ? "COMPLETE"
			  : payment->status == PAYMENT_PENDING ? "PENDING"
			  : "FAILED");

		switch (payment->status) {
		case PAYMENT_COMPLETE:
			have_complete = true;
			if (payment->partid != partid)
				continue;

			tal_free(stmt);

			/* Must match successful payment parameters. */
			if (!amount_msat_eq(payment->msatoshi, msat)) {
				return command_fail(cmd, PAY_RHASH_ALREADY_USED,
						    "Already succeeded "
						    "with amount %s (not %s)",
						    fmt_amount_msat(tmpctx,
								    payment->msatoshi),
						    fmt_amount_msat(tmpctx,
								    msat));
			}
			if (payment->destination && destination
			    && !node_id_eq(payment->destination,
					   destination)) {
				return command_fail(cmd, PAY_RHASH_ALREADY_USED,
						    "Already succeeded to %s",
						    fmt_node_id(tmpctx,
								payment->destination));
			}
			return sendpay_success(cmd, payment, NULL);

		case PAYMENT_PENDING:
			/* At most one payment group can be in-flight at any
			 * time. */
			if (payment->groupid != group) {
				tal_free(stmt);
				return command_fail(
				    cmd, PAY_IN_PROGRESS,
				    "Payment with groupid=%" PRIu64
				    " still in progress, cannot retry before "
				    "that completes.",
				    payment->groupid);
			}

			/* Can't mix non-parallel and parallel payments! */
			if (!payment->partid != !partid) {
				tal_free(stmt);
				return command_fail(cmd, PAY_IN_PROGRESS,
						    "Already have %s payment in progress",
						    payment->partid ? "parallel" : "non-parallel");
			}

			if (payment->partid == partid) {
				tal_free(stmt);
				/* You can't change details while it's pending */
				if (!amount_msat_eq(payment->msatoshi, msat)) {
					return command_fail(cmd, PAY_RHASH_ALREADY_USED,
						    "Already pending "
						    "with amount %s (not %s)",
						    fmt_amount_msat(tmpctx,
								    payment->msatoshi),
						    fmt_amount_msat(tmpctx,
								    msat));
				}
				if (payment->destination && destination
				    && !node_id_eq(payment->destination,
						   destination)) {
					return command_fail(cmd, PAY_RHASH_ALREADY_USED,
							    "Already pending to %s",
							    fmt_node_id(tmpctx,
									   payment->destination));
				}
				return json_sendpay_in_progress(cmd, payment);
			}
			/* You shouldn't change your mind about amount being
			 * sent, since we'll use it in onion! */
			else if (!amount_msat_eq(payment->total_msat,
						 total_msat)) {
				tal_free(stmt);
				return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
						    "msatoshi was previously %s, now %s",
						    fmt_amount_msat(tmpctx,
								    payment->total_msat),
						    fmt_amount_msat(tmpctx,
								    total_msat));
			}

			if (!amount_msat_accumulate(&msat_already_pending,
						    payment->msatoshi)) {
				tal_free(stmt);
				return command_fail(cmd, LIGHTNINGD,
						    "Internal amount overflow!"
						    " %s + %s",
						    fmt_amount_msat(tmpctx,
								    msat_already_pending),
						    fmt_amount_msat(tmpctx,
								    payment->msatoshi));
			}
			break;

		case PAYMENT_FAILED:
			break;
 		}
		/* There is no way for us to add a payment with the
		 * same (payment_hash, partid, groupid) tuple since
		 * it'd collide with the database primary key. So
		 * report this as soon as possible. */

		if (payment->partid == partid && payment->groupid == group) {
			tal_free(stmt);
			return command_fail(
			    cmd, PAY_RHASH_ALREADY_USED,
			    "There already is a payment with payment_hash=%s, "
			    "groupid=%" PRIu64 ", partid=%" PRIu64
			    ". Either change the partid, or wait for the "
			    "payment to complete and start a new group.",
			    fmt_sha256(tmpctx, rhash), group,
			    partid);
		}
	}

	/* If any part has succeeded, you can't start a new one! */
	if (have_complete) {
		return command_fail(cmd, PAY_RHASH_ALREADY_USED,
				    "Already succeeded other parts");
	}

	/* BOLT #4:
	 *
	 * - MUST NOT send another HTLC if the total `amt_to_forward` of the HTLC
	 *   set is already greater or equal to `total_msat`.
	 */
	/* We don't do this for single 0-value payments (sendonion does this) */
	if (!amount_msat_is_zero(total_msat)
	    && amount_msat_greater_eq(msat_already_pending, total_msat)) {
		return command_fail(cmd, PAY_IN_PROGRESS,
				    "Already have %s of %s payments in progress",
				    fmt_amount_msat(tmpctx,
						    msat_already_pending),
				    fmt_amount_msat(tmpctx, total_msat));
	}

	return NULL;
}

/* destination/route_channels/route_nodes are NULL (and path_secrets may be NULL)
 * if we're sending a raw onion. */
static struct command_result *
send_payment_core(struct lightningd *ld,
		  struct command *cmd,
		  const struct sha256 *rhash,
		  u64 partid,
		  u64 group,
		  const struct route_hop *first_hop,
		  struct amount_msat msat,
		  struct amount_msat total_msat,
		  const char *label TAKES,
		  const char *invstring TAKES,
		  const char *description TAKES,
		  const struct onionpacket *packet,
		  const struct node_id *destination,
		  struct node_id *route_nodes TAKES,
		  struct short_channel_id *route_channels TAKES,
		  struct secret *path_secrets,
		  const struct sha256 *local_invreq_id)
{
	struct channel *channel;
	const u8 *failmsg;
	struct htlc_out *hout;
	struct routing_failure *fail;
	struct command_result *ret;
	struct wallet_payment *payment;

	/* Reconcile this with previous attempts */
	ret = check_progress(ld, cmd, rhash, msat, total_msat, partid, group,
			     destination);
	if (ret)
		return ret;

	ret = check_invoice_request_usage(cmd, local_invreq_id);
	if (ret)
		return ret;

	channel = find_channel_for_htlc_add(ld, cmd, &first_hop->node_id,
					    first_hop->scid, &msat);
	if (!channel) {
		struct json_stream *data
			= json_stream_fail(cmd, PAY_TRY_OTHER_ROUTE,
					   "No connection to first "
					   "peer found");

		json_add_routefail_info(data, 0, WIRE_UNKNOWN_NEXT_PEER,
					&ld->our_nodeid, NULL,
					node_id_idx(&ld->our_nodeid,
						    &first_hop->node_id),
					NULL);
		json_object_end(data);
		return command_failed(cmd, data);
	}

	if (route_channels)
		log_info(ld->log, "Sending %s over %zu hops to deliver %s",
			 fmt_amount_msat(tmpctx, first_hop->amount),
			 tal_count(route_channels),
			 fmt_amount_msat(tmpctx, msat));
	else
		log_info(ld->log, "Sending %s in onion to deliver %s",
			 fmt_amount_msat(tmpctx, first_hop->amount),
			 fmt_amount_msat(tmpctx, msat));

	failmsg = send_onion(tmpctx, ld, packet, first_hop, msat,
			     rhash, NULL, partid,
			     group, channel, &hout);

	if (failmsg) {
		fail = immediate_routing_failure(
		    cmd, ld, fromwire_peektype(failmsg),
		    channel_scid_or_local_alias(channel),
		    &channel->peer->id);

		return sendpay_fail(
		    cmd, NULL, PAY_TRY_OTHER_ROUTE, NULL, fail,
		    sendpay_errmsg_fmt(tmpctx, PAY_TRY_OTHER_ROUTE, fail,
				       "First peer not ready"),
		    NULL);
	}

	payment = wallet_add_payment(cmd,
				     ld->wallet,
				     time_now().ts.tv_sec,
				     NULL,
				     rhash,
				     partid,
				     group,
				     PAYMENT_PENDING,
				     destination,
				     msat,
				     first_hop->amount,
				     total_msat,
				     NULL,
				     path_secrets,
				     route_nodes,
				     route_channels,
				     invstring,
				     label,
				     description,
				     NULL,
				     local_invreq_id);

	return json_sendpay_in_progress(cmd, payment);
}

static struct command_result *
send_payment(struct lightningd *ld,
	     struct command *cmd,
	     const struct sha256 *rhash,
	     u64 partid,
	     u64 group,
	     const struct route_hop *route,
	     struct amount_msat msat,
	     struct amount_msat total_msat,
	     const char *label TAKES,
	     const char *invstring TAKES,
	     const char *description TAKES,
	     const struct sha256 *local_invreq_id,
	     const struct secret *payment_secret,
	     const u8 *payment_metadata,
	     bool dev_legacy_hop)
{
	unsigned int base_expiry;
	struct onionpacket *packet;
	struct secret *path_secrets;
	size_t i, n_hops = tal_count(route);
	struct node_id *ids = tal_arr(tmpctx, struct node_id, n_hops);
	struct short_channel_id *channels;
	struct sphinx_path *path;
	struct pubkey pubkey;
	bool ret;
	u8 *onion;

	/* Expiry for HTLCs is absolute.  And add one to give some margin,
	   and use bitcoind's block height, even if we're behind in processing */
	base_expiry = get_network_blockheight(ld->topology) + 1;

	path = sphinx_path_new(tmpctx, rhash->u.u8);
	/* Extract IDs for each hop: create_onionpacket wants array. */
	for (i = 0; i < n_hops; i++)
		ids[i] = route[i].node_id;

	/* Create sphinx path */
	for (i = 0; i < n_hops - 1; i++) {
		ret = pubkey_from_node_id(&pubkey, &ids[i]);
		assert(ret);

		if (dev_legacy_hop && i == n_hops - 2) {
			sphinx_add_v0_hop(path, &pubkey,
					  &route[i + 1].scid,
					  route[i + 1].amount,
					  base_expiry + route[i + 1].delay);
			continue;
		}

		sphinx_add_hop_has_length(path, &pubkey,
			       take(onion_nonfinal_hop(NULL,
					&route[i + 1].scid,
					route[i + 1].amount,
					base_expiry + route[i + 1].delay)));
	}

	/* And finally set the final hop to the special values in
	 * BOLT04 */
	ret = pubkey_from_node_id(&pubkey, &ids[i]);
	assert(ret);

	onion = onion_final_hop(cmd,
				route[i].amount,
				base_expiry + route[i].delay,
				total_msat,
				payment_secret, payment_metadata);
	if (!onion) {
		return command_fail(cmd, PAY_DESTINATION_PERM_FAIL,
				    "Destination does not support"
				    " payment_secret");
	}
	sphinx_add_hop_has_length(path, &pubkey, onion);

	/* Copy channels used along the route. */
	channels = tal_arr(tmpctx, struct short_channel_id, n_hops);
	for (i = 0; i < n_hops; ++i)
		channels[i] = route[i].scid;

	packet = create_onionpacket(tmpctx, path, ROUTING_INFO_SIZE, &path_secrets);
	return send_payment_core(ld, cmd, rhash, partid, group, &route[0],
				 msat, total_msat,
				 label, invstring, description,
				 packet, &ids[n_hops - 1], ids,
				 channels, path_secrets, local_invreq_id);
}

static struct command_result *
param_route_hop(struct command *cmd, const char *name, const char *buffer,
		const jsmntok_t *tok, struct route_hop **hop)
{
	const jsmntok_t *idtok, *channeltok, *amounttok, *delaytok;
	struct route_hop *res;

	res = tal(cmd, struct route_hop);
	idtok = json_get_member(buffer, tok, "id");
	channeltok = json_get_member(buffer, tok, "channel");
	amounttok = json_get_member(buffer, tok, "amount_msat");
	delaytok = json_get_member(buffer, tok, "delay");

	/* General verification that all fields that we need are present. */
	if (!idtok && !channeltok)
		return command_fail(
		    cmd, JSONRPC2_INVALID_PARAMS,
		    "Either 'id' or 'channel' is required for a route_hop");

	if (!amounttok)
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "'amount_msat' is required");

	if (!delaytok)
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "'delay' is required");

	/* Parsing of actual values including sanity check for all parsed
	 * values. */
	if (!idtok) {
		memset(&res->node_id, 0, sizeof(struct node_id));
	} else if (!json_to_node_id(buffer, idtok, &res->node_id)) {
		return command_fail_badparam(cmd, name, buffer, idtok,
					     "should be a node_id");
	}

	if (!channeltok) {
		memset(&res->scid, 0, sizeof(struct short_channel_id));
	} else if (!json_to_short_channel_id(buffer, channeltok, &res->scid)) {
		return command_fail_badparam(cmd, name, buffer, channeltok,
					     "should be a short_channel_id");
	}

	if (!json_to_msat(buffer, amounttok, &res->amount))
		return command_fail_badparam(cmd, name, buffer, amounttok,
					     "should be a valid amount_msat");

	if (!json_to_number(buffer, delaytok, &res->delay) || res->delay < 1)
		return command_fail_badparam(cmd, name, buffer, delaytok,
					     "should be a positive, non-zero, number");

	*hop = res;
	return NULL;
}

static struct command_result *json_sendonion(struct command *cmd,
					     const char *buffer,
					     const jsmntok_t *obj UNNEEDED,
					     const jsmntok_t *params)
{
	u8 *onion;
	struct onionpacket *packet;
	enum onion_wire failcode;
	struct route_hop *first_hop;
	struct sha256 *payment_hash;
	struct lightningd *ld = cmd->ld;
	const char *label, *invstring, *description;
	struct node_id *destination;
	struct secret *path_secrets;
	struct amount_msat *msat;
	u64 *partid, *group;
	struct sha256 *local_invreq_id = NULL;

	if (!param_check(cmd, buffer, params,
			 p_req("onion", param_bin_from_hex, &onion),
			 p_req("first_hop", param_route_hop, &first_hop),
			 p_req("payment_hash", param_sha256, &payment_hash),
			 p_opt("label", param_escaped_string, &label),
			 p_opt("shared_secrets", param_secrets_array, &path_secrets),
			 p_opt_def("partid", param_u64, &partid, 0),
			 /* FIXME: parameter should be invstring now */
			 p_opt("bolt11", param_invstring, &invstring),
			 p_opt_def("amount_msat", param_msat, &msat, AMOUNT_MSAT(0)),
			 p_opt("destination", param_node_id, &destination),
			 p_opt("localinvreqid", param_sha256, &local_invreq_id),
			 p_opt("groupid", param_u64, &group),
			 p_opt("description", param_string, &description),
			 NULL))
		return command_param_failed();

	/* If groupid was not provided default to incrementing from the previous one. */
	if (group == NULL) {
		group = tal(tmpctx, u64);
		*group =
		    wallet_payment_get_groupid(cmd->ld->wallet, payment_hash) +
		    1;
	}

	packet = parse_onionpacket(cmd, onion, tal_bytelen(onion), &failcode);

	if (!packet)
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "Could not parse the onion. Parsing failed "
				    "with failcode=%d",
				    failcode);

	if (command_check_only(cmd))
		return command_check_done(cmd);

	return send_payment_core(ld, cmd, payment_hash, *partid, *group,
				 first_hop, *msat, AMOUNT_MSAT(0),
				 label, invstring, description,
				 packet, destination, NULL, NULL,
				 path_secrets, local_invreq_id);
}

static const struct json_command sendonion_command = {
	"sendonion",
	json_sendonion,
};
AUTODATA(json_command, &sendonion_command);

/*-----------------------------------------------------------------------------
JSON-RPC sendpay interface
-----------------------------------------------------------------------------*/

/* FIXME: We accept his parameter for now, will deprecate eventually */
static struct command_result *param_route_hop_style(struct command *cmd,
						    const char *name,
						    const char *buffer,
						    const jsmntok_t *tok,
						    int **unused)
{
	if (json_tok_streq(buffer, tok, "tlv")) {
		return NULL;
	}

	return command_fail_badparam(cmd, name, buffer, tok,
			    "should be 'tlv' ('legacy' not supported)");
}

static struct command_result *param_route_hops(struct command *cmd,
					       const char *name,
					       const char *buffer,
					       const jsmntok_t *tok,
					       struct route_hop **hops)
{
	size_t i;
	const jsmntok_t *t;

	if (tok->type != JSMN_ARRAY)
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "%s must be an array", name);

	*hops = tal_arr(cmd, struct route_hop, tok->size);
	json_for_each_arr(i, t, tok) {
		struct amount_msat *amount_msat;
		struct node_id *id;
		struct short_channel_id *channel;
		unsigned *delay, *direction;
		int *ignored;

		if (!param(cmd, buffer, t,
			   p_req("amount_msat", param_msat, &amount_msat),
			   p_req("id", param_node_id, &id),
			   p_req("delay", param_number, &delay),
			   p_req("channel", param_short_channel_id, &channel),
			   /* Allowed (getroute supplies it) but ignored */
			   p_opt("direction", param_number, &direction),
			   p_opt("style", param_route_hop_style, &ignored),
			   NULL))
			return command_param_failed();

		(*hops)[i].amount = *amount_msat;
		(*hops)[i].node_id = *id;
		(*hops)[i].delay = *delay;
		(*hops)[i].scid = *channel;
	}

	return NULL;
}

/* We're paying ourselves! */
static struct command_result *self_payment(struct lightningd *ld,
					   struct command *cmd,
					   const struct sha256 *rhash,
					   u64 partid,
					   u64 groupid,
					   struct amount_msat msat,
					   const char *label TAKES,
					   const char *invstring TAKES,
					   const char *description TAKES,
					   const struct sha256 *local_invreq_id,
					   const struct secret *payment_secret,
					   const u8 *payment_metadata)
{
	struct wallet_payment *payment;
	const struct invoice_details *inv;
	u64 inv_dbid;
	const char *err;

	payment = wallet_add_payment(tmpctx,
				     ld->wallet,
				     time_now().ts.tv_sec,
				     NULL,
				     rhash,
				     partid,
				     groupid,
				     PAYMENT_PENDING,
				     &ld->our_nodeid,
				     msat,
				     msat,
				     msat,
				     NULL,
				     NULL,
				     NULL,
				     NULL,
				     invstring,
				     label,
				     description,
				     NULL,
				     local_invreq_id);

	/* Now, resolve the invoice */
	inv = invoice_check_payment(tmpctx, ld, rhash, msat, payment_secret, &err);
	if (!inv) {
		struct routing_failure *fail;
		wallet_payment_set_status(ld->wallet, rhash, partid, groupid,
					  PAYMENT_FAILED, NULL);

		/* tell_waiters_failed expects one of these! */
		fail = tal(payment, struct routing_failure);
		fail->failcode = WIRE_INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS;
		fail->erring_node = &ld->our_nodeid;
		fail->erring_index = 0;
		fail->erring_channel = NULL;
		fail->msg = NULL;

		/* Only some of these fields make sense for self payments */
		wallet_payment_set_failinfo(ld->wallet,
					    rhash,
					    partid, NULL,
					    true,
					    0,
					    fail->failcode, fail->erring_node,
					    NULL, NULL,
					    err,
					    0);
		/* We do this even though there really can't be any waiters,
		 * since we didn't block. */
		tell_waiters_failed(ld, rhash, payment, PAY_DESTINATION_PERM_FAIL,
				    NULL, fail, err);
		return sendpay_fail(cmd, payment, PAY_DESTINATION_PERM_FAIL, NULL,
				    fail, err, NULL);
	}

	/* These should not fail, given the above succeded! */
	if (!invoices_find_by_rhash(ld->wallet->invoices, &inv_dbid, rhash)
	    || !invoices_resolve(ld->wallet->invoices, inv_dbid, msat, inv->label, NULL)) {
		log_broken(ld->log, "Could not resolve invoice %"PRIu64"!?!", inv_dbid);
		return sendpay_fail(cmd, payment, PAY_DESTINATION_PERM_FAIL, NULL, NULL, "broken", NULL);
	}

	log_info(ld->log, "Self-resolved invoice '%s' with amount %s",
		 inv->label->s,
		 fmt_amount_msat(tmpctx, msat));
	notify_invoice_payment(ld, msat, &inv->r, inv->label, NULL);

	/* Now resolve the payment */
	payment_succeeded(ld, rhash, partid, groupid,  &inv->r);

	/* Now the specific command which called this. */
	payment->status = PAYMENT_COMPLETE;
	payment->payment_preimage = tal_dup(payment, struct preimage, &inv->r);
	return sendpay_success(cmd, payment, NULL);
}

static struct command_result *json_sendpay(struct command *cmd,
					   const char *buffer,
					   const jsmntok_t *obj UNNEEDED,
					   const jsmntok_t *params)
{
	struct sha256 *rhash;
	struct route_hop *route;
	struct amount_msat *msat;
	const char *invstring, *label, *description;
	u64 *partid, *group;
	struct secret *payment_secret;
	struct sha256 *local_invreq_id;
	u8 *payment_metadata;
	bool *dev_legacy_hop;

	if (!param_check(cmd, buffer, params,
			 p_req("route", param_route_hops, &route),
			 p_req("payment_hash", param_sha256, &rhash),
			 p_opt("label", param_escaped_string, &label),
			 p_opt("amount_msat", param_msat, &msat),
			 /* FIXME: parameter should be invstring now */
			 p_opt("bolt11", param_invstring, &invstring),
			 p_opt("payment_secret", param_secret, &payment_secret),
			 p_opt_def("partid", param_u64, &partid, 0),
			 p_opt("localinvreqid", param_sha256, &local_invreq_id),
			 p_opt("groupid", param_u64, &group),
			 p_opt("payment_metadata", param_bin_from_hex, &payment_metadata),
			 p_opt("description", param_string, &description),
			 p_opt_dev("dev_legacy_hop", param_bool, &dev_legacy_hop, false),
		   NULL))
		return command_param_failed();

	if (*partid && !msat)
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "Must specify msatoshi with partid");

	/* If groupid was not provided default to incrementing from the previous one. */
	if (group == NULL) {
		group = tal(tmpctx, u64);
		*group = wallet_payment_get_groupid(cmd->ld->wallet, rhash) + 1;
	}

	if (tal_count(route) == 0) {
		if (!msat)
			return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
					    "Self-payment requires amount_msat");
		if (*partid)
			return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
					    "Self-payment does not allow (non-zero) partid");
		if (command_check_only(cmd))
			return command_check_done(cmd);

		return self_payment(cmd->ld, cmd, rhash, *partid, *group, *msat,
				    label, invstring, description, local_invreq_id,
				    payment_secret, payment_metadata);
	}

	const struct amount_msat final_amount = route[tal_count(route)-1].amount;

	if (msat && !*partid && !amount_msat_eq(*msat, final_amount))
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "Do not specify msatoshi (%s) without"
				    " partid: if you do, it must be exactly"
				    " the final amount (%s)",
				    fmt_amount_msat(tmpctx, *msat),
				    fmt_amount_msat(tmpctx, final_amount));

	/* For MPP, the total we send must *exactly* equal the amount
	 * we promise to send (msatoshi).  So no single payment can be
	 * > than that. */
	if (*partid) {
		if (amount_msat_greater(final_amount, *msat))
			return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
					    "Final amount %s is greater than"
					    " %s, despite MPP",
					    fmt_amount_msat(tmpctx, final_amount),
					    fmt_amount_msat(tmpctx, *msat));
	}

	if (*partid && !payment_secret)
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "partid requires payment_secret");

	if (command_check_only(cmd))
		return command_check_done(cmd);

	return send_payment(cmd->ld, cmd, rhash, *partid, *group,
			    route,
			    final_amount,
			    msat ? *msat : final_amount,
			    label, invstring, description, local_invreq_id,
			    payment_secret, payment_metadata, *dev_legacy_hop);
}

static const struct json_command sendpay_command = {
	"sendpay",
	json_sendpay,
};
AUTODATA(json_command, &sendpay_command);

static void waitsendpay_timeout(struct command *cmd)
{
	was_pending(command_fail(cmd, PAY_IN_PROGRESS,
				 "Timed out while waiting"));
}

static struct command_result *json_waitsendpay(struct command *cmd,
					       const char *buffer,
					       const jsmntok_t *obj UNNEEDED,
					       const jsmntok_t *params)
{
	struct sha256 *rhash;
	unsigned int *timeout;
	struct command_result *res;
	u64 *partid, *groupid;

	if (!param(cmd, buffer, params,
		   p_req("payment_hash", param_sha256, &rhash),
		   p_opt("timeout", param_number, &timeout),
		   p_opt_def("partid", param_u64, &partid, 0),
		   p_opt("groupid", param_u64, &groupid),
		   NULL))
		return command_param_failed();

	if (groupid == NULL) {
		groupid = tal(cmd, u64);
		*groupid = wallet_payment_get_groupid(cmd->ld->wallet, rhash);
	}
	res = wait_payment(cmd->ld, cmd, rhash, *partid, *groupid);
	if (res)
		return res;

	if (timeout)
		new_reltimer(cmd->ld->timers, cmd, time_from_sec(*timeout),
			     &waitsendpay_timeout, cmd);
	return command_still_pending(cmd);
}

static const struct json_command waitsendpay_command = {
	"waitsendpay",
	json_waitsendpay,
};
AUTODATA(json_command, &waitsendpay_command);

static struct command_result *
injectonion_fail(struct command *cmd,
		 const struct wallet_payment *payment,
		 enum jsonrpc_errcode pay_errcode,
		 const struct onionreply *onionreply,
		 const struct routing_failure *fail,
		 const char *errmsg,
		 struct secret *shared_secret)
{
	struct json_stream *js;

	/* Turn local errors into onion reply. */
	if (!onionreply)
		onionreply = create_onionreply(tmpctx, shared_secret, fail->msg);

	js = json_stream_fail(cmd, PAY_INJECTPAYMENTONION_FAILED, errmsg);
	/* We wrap the onion reply, as it expects. */
	json_add_hex_talarr(js, "onionreply",
			    wrap_onionreply(tmpctx, shared_secret, onionreply)
			    ->contents);

	json_object_end(js);
	return command_failed(cmd, js);
}

static struct command_result *
injectonion_succeed(struct command *cmd,
		    const struct wallet_payment *payment,
		    void *unused)
{
	struct json_stream *response = json_stream_success(cmd);

	assert(payment->status == PAYMENT_COMPLETE);

	json_add_u64(response, "created_index", payment->id);
	json_add_u32(response, "created_at", payment->timestamp);
	json_add_u32(response, "completed_at", *payment->completed_at);
	json_add_preimage(response, "payment_preimage", payment->payment_preimage);
	return command_success(cmd, response);
}

struct selfpay {
	struct command *cmd;
	struct secret shared_secret;
	u64 partid, groupid;
	struct sha256 payment_hash;
};

/* FIXME: Map errors better using payment_failed? */
static void selfpay_mpp_fail(struct selfpay *selfpay, const u8 *failmsg TAKES)
{
	struct onionreply *reply = create_onionreply(tmpctx, &selfpay->shared_secret, failmsg);

	if (taken(failmsg))
		tal_steal(selfpay->cmd, failmsg);

	payment_failed(selfpay->cmd->ld,
		       selfpay->cmd->ld->log,
		       &selfpay->payment_hash,
		       selfpay->partid,
		       selfpay->groupid,
		       reply,
		       NULL,
		       NULL);
}

static void selfpay_mpp_succeeded(struct selfpay *selfpay,
				  const struct preimage *preimage)
{
	payment_succeeded(selfpay->cmd->ld,
			  &selfpay->payment_hash,
			  selfpay->partid,
			  selfpay->groupid,
			  preimage);
}

static struct command_result *param_u64_nonzero(struct command *cmd,
						const char *name,
						const char *buffer,
						const jsmntok_t *tok,
						u64 **val)
{
	struct command_result *res = param_u64(cmd, name, buffer, tok, val);
	if (res == NULL && *val == 0)
		res = command_fail_badparam(cmd, name, buffer, tok,
					    "Must be non-zero");
	return res;
}

static void register_payment_and_waiter(struct command *cmd,
					const struct sha256 *payment_hash,
					u64 partid, u64 groupid,
					struct amount_msat msat,
					struct amount_msat msat_sent,
					struct amount_msat total_msat,
					const char *label,
					const char *invstring,
					struct sha256 *local_invreq_id,
					const struct secret *shared_secret)
{
	wallet_add_payment(cmd,
			   cmd->ld->wallet,
			   time_now().ts.tv_sec,
			   NULL,
			   payment_hash,
			   partid,
			   groupid,
			   PAYMENT_PENDING,
			   NULL,
			   msat,
			   msat_sent,
			   total_msat,
			   NULL,
			   NULL,
			   NULL,
			   NULL,
			   invstring,
			   label,
			   NULL,
			   NULL,
			   local_invreq_id);

	/* Now we wait for htlc to resolve (it will need shared_secret!) */
	add_waitsendpay_waiter(cmd->ld, cmd, payment_hash, partid, groupid,
			       injectonion_succeed, injectonion_fail,
			       tal_dup(cmd, struct secret, shared_secret));
}

static struct command_result *json_injectpaymentonion(struct command *cmd,
						      const char *buffer,
						      const jsmntok_t *obj UNNEEDED,
						      const jsmntok_t *params)
{
	u8 *onion;
	enum onion_wire failcode;
	struct sha256 *payment_hash;
	struct lightningd *ld = cmd->ld;
	const char *label, *invstring;
	struct pubkey *blinding, *next_path_key;
	struct amount_msat *msat;
	u32 *cltv;
	u64 *partid, *groupid;
	struct sha256 *local_invreq_id;
	struct secret shared_secret;
	struct onionpacket *op;
	struct onion_payload *payload;
	struct route_step *rs;
	u64 failtlvtype;
	size_t failtlvpos;
	struct channel *next;
	struct command_result *ret;
	const u8 *failmsg;
	struct htlc_out *hout;

	if (!param_check(cmd, buffer, params,
			 p_req("onion", param_bin_from_hex, &onion),
			 p_req("payment_hash", param_sha256, &payment_hash),
			 p_req("amount_msat", param_msat, &msat),
			 p_req("cltv_expiry", param_u32, &cltv),
			 p_req("partid", param_u64_nonzero, &partid),
			 p_req("groupid", param_u64, &groupid),
			 p_opt("blinding", param_pubkey, &blinding),
			 p_opt("label", param_escaped_string, &label),
			 p_opt("invstring", param_invstring, &invstring),
			 p_opt("localinvreqid", param_sha256, &local_invreq_id),
			 NULL))
		return command_param_failed();

	/* Safety check: reconcile this with previous attempts, check
	 * partid/groupid uniqueness: we don't know amount or total. */
	ret = check_progress(cmd->ld, cmd, payment_hash, AMOUNT_MSAT(0),
			     AMOUNT_MSAT(0),
			     *partid, *groupid, NULL);
	if (ret)
		return ret;

	/* This checks we're not trying to pay our a locally-generated
	 * invoice_request more than once. */
	ret = check_invoice_request_usage(cmd, local_invreq_id);
	if (ret)
		return ret;

	if (tal_bytelen(onion) != TOTAL_PACKET_SIZE(ROUTING_INFO_SIZE)) {
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "onion must be %u bytes long",
				    TOTAL_PACKET_SIZE(ROUTING_INFO_SIZE));
	}

	op = parse_onionpacket(tmpctx, onion, tal_bytelen(onion),
			       &failcode);
	if (!op) {
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "Could not parse onion: %s",
				    onion_wire_name(failcode));
	}

	if (!ecdh_maybe_blinding(&op->ephemeralkey,
				 blinding,
				 &shared_secret)) {
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "Could not tweak ephemeral key");
	}

	rs = process_onionpacket(tmpctx, op, &shared_secret,
				 payment_hash->u.u8,
				 sizeof(payment_hash->u.u8));
	if (!rs) {
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "Could not process onion");
	}

	payload = onion_decode(tmpctx, rs, blinding,
			       cmd->ld->accept_extra_tlv_types,
			       *msat, *cltv,
			       &failtlvtype,
			       &failtlvpos);
	if (!payload) {
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "Onion decode for %s failed at type %"PRIu64" offset %zu",
				    tal_hex(tmpctx, rs->raw_payload),
				    failtlvtype, failtlvpos);
	}

	if (payload->final) {
		struct selfpay *selfpay;

		if (command_check_only(cmd))
			return command_check_done(cmd);

		selfpay = tal(cmd, struct selfpay);
		selfpay->cmd = cmd;
		selfpay->shared_secret = shared_secret;
		selfpay->partid = *partid;
		selfpay->groupid = *groupid;
		selfpay->payment_hash = *payment_hash;

		/* We actually *do* know msat delivered and total msat, but
		 * then check_progress will complain on the next part, because
		 * we don't know it then, so leave them 0 */
		register_payment_and_waiter(cmd,
					    payment_hash,
					    *partid, *groupid,
					    AMOUNT_MSAT(0), *msat, AMOUNT_MSAT(0),
					    label, invstring, local_invreq_id,
					    &shared_secret);

		/* Mark it pending now, though htlc_set_add might
		 * not resolve immediately */
		fixme_ignore(command_still_pending(cmd));
		htlc_set_add(cmd->ld, cmd->ld->log, *msat, *payload->total_msat,
			     payment_hash, payload->payment_secret,
			     selfpay_mpp_fail, selfpay_mpp_succeeded,
			     selfpay);
		return command_its_complicated("htlc_set_add may have immediately succeeded or failed");
	}

	/* If they use scid, we use exactly the channel they tell us to here! */
	if (payload->forward_channel) {
		next = any_channel_by_scid(cmd->ld,
					   *payload->forward_channel,
					   false);
		if (!next)
			return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
					    "Unknown scid %s",
					    fmt_short_channel_id(tmpctx,
								 *payload->forward_channel));

		if (!channel_state_can_add_htlc(next->state)) {
			return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
					    "channel %s in state %s",
					    fmt_short_channel_id(tmpctx,
								 *payload->forward_channel),
					    channel_state_str(next->state));
		}
	} else {
		struct node_id nid;
		struct peer *next_peer;

		node_id_from_pubkey(&nid, payload->forward_node_id);
		next_peer = peer_by_id(cmd->ld, &nid);
		if (!next_peer)
			return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
					    "Unknown peer %s",
					    fmt_node_id(tmpctx, &nid));

		next = best_channel(cmd->ld, next_peer, *msat, NULL);
		if (!next)
			return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
					    "No available channel with peer %s",
					    fmt_node_id(tmpctx, &nid));
	}

	if (amount_msat_greater(*msat, next->htlc_maximum_msat)
	    || amount_msat_less(*msat, next->htlc_minimum_msat)) {
		/* Are we in old-range grace-period? */
		if (!time_before(time_now(), next->old_feerate_timeout)
		    || amount_msat_less(*msat, next->old_htlc_minimum_msat)
		    || amount_msat_greater(*msat, next->old_htlc_maximum_msat)) {
			return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
					    "Amount %s not in htlc min/max range %s-%s",
					    fmt_amount_msat(tmpctx, *msat),
					    fmt_amount_msat(tmpctx, next->htlc_minimum_msat),
					    fmt_amount_msat(tmpctx, next->htlc_maximum_msat));
		}
		log_info(next->log,
			 "Allowing payment using older htlc_minimum/maximum_msat");
	}

	/* BOLT #2:
	 *
	 * An offering node:
	 *   - MUST estimate a timeout deadline for each HTLC it offers.
	 *   - MUST NOT offer an HTLC with a timeout deadline before its
	 *     `cltv_expiry`.
	 */
	/* In our case, G = 1, so we need to expire it one after it's expiration.
	 * But never offer an expired HTLC; that's dumb. */
	if (get_block_height(cmd->ld->topology) >= *cltv) {
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "Expiry cltv %u too close to current %u",
				    *cltv,
				    get_block_height(ld->topology));
	}

	/* BOLT #4:
	 *
	 *  - if the `cltv_expiry` is more than `max_htlc_cltv` in the future:
	 *     - return an `expiry_too_far` error.
	 */
	if (get_block_height(ld->topology)
	    + ld->config.max_htlc_cltv < *cltv) {
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "Expiry cltv %u too far from current %u + max %u",
				    *cltv,
				    get_block_height(ld->topology),
				    ld->config.max_htlc_cltv);
	}

	/* We could have blinding from cmdline or from inside onion. */
	if (payload->path_key) {
		struct sha256 sha;
		blinding_hash_e_and_ss(payload->path_key,
				       &payload->blinding_ss,
				       &sha);
		next_path_key = tal(tmpctx, struct pubkey);
		blinding_next_path_key(payload->path_key, &sha,
				       next_path_key);
	} else
		next_path_key = NULL;

	if (command_check_only(cmd))
		return command_check_done(cmd);

	register_payment_and_waiter(cmd,
				    payment_hash,
				    *partid, *groupid,
				    AMOUNT_MSAT(0), *msat, AMOUNT_MSAT(0),
				    label, invstring, local_invreq_id,
				    &shared_secret);

	failmsg = send_htlc_out(tmpctx, next, *msat,
				/* We set final_msat to the same, so fees == 0
				 * (in fact, we don't know!) */
				*cltv, *msat,
				payment_hash,
				next_path_key, *partid, *groupid,
				serialize_onionpacket(tmpctx, rs->next),
				NULL, &hout);
	if (failmsg) {
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "Could not send to first peer: %s",
				    onion_wire_name(fromwire_peektype(failmsg)));
	}
	return command_still_pending(cmd);
}

static const struct json_command injectpaymentonion_command = {
	"injectpaymentonion",
	json_injectpaymentonion,
};
AUTODATA(json_command, &injectpaymentonion_command);


static u64 sendpay_index_inc(struct lightningd *ld,
			     const struct sha256 *payment_hash,
			     u64 partid,
			     u64 groupid,
			     enum payment_status status,
			     enum wait_index idx)
{
	return wait_index_increment(ld, WAIT_SUBSYSTEM_SENDPAY, idx,
				    "status", payment_status_to_string(status),
				    "=partid", tal_fmt(tmpctx, "%"PRIu64, partid),
				    "=groupid", tal_fmt(tmpctx, "%"PRIu64, groupid),
				    "payment_hash",
				    fmt_sha256(tmpctx, payment_hash),
				    NULL);
}

void sendpay_index_deleted(struct lightningd *ld,
			   const struct sha256 *payment_hash,
			   u64 partid,
			   u64 groupid,
			   enum payment_status status)
{
	sendpay_index_inc(ld, payment_hash, partid, groupid, status, WAIT_INDEX_DELETED);
}

/* Fortuntely, dbids start at 1, not 0! */
u64 sendpay_index_created(struct lightningd *ld,
			  const struct sha256 *payment_hash,
			  u64 partid,
			  u64 groupid,
			  enum payment_status status)
{
	return sendpay_index_inc(ld, payment_hash, partid, groupid, status,
				 WAIT_INDEX_CREATED);
}

u64 sendpay_index_update_status(struct lightningd *ld,
				const struct sha256 *payment_hash,
				u64 partid,
				u64 groupid,
				enum payment_status status)
{
	return sendpay_index_inc(ld, payment_hash, partid, groupid, status,
				 WAIT_INDEX_UPDATED);
}

static struct command_result *param_payment_status(struct command *cmd,
						   const char *name,
						   const char *buffer,
						   const jsmntok_t *tok,
						   enum payment_status **status)
{
	*status = tal(cmd, enum payment_status);
	if (string_to_payment_status(buffer + tok->start,
				     tok->end - tok->start,
				     *status))
		return NULL;

	return command_fail_badparam(cmd, name, buffer, tok,
				     "should be an invoice status");
}

static struct command_result *json_listsendpays(struct command *cmd,
						const char *buffer,
						const jsmntok_t *obj UNNEEDED,
						const jsmntok_t *params)
{
	struct json_stream *response;
	struct sha256 *rhash;
	const char *invstring;
	enum payment_status *status;
	struct db_stmt *stmt;
	enum wait_index *listindex;
	u64 *liststart;
	u32 *listlimit;

	if (!param_check(cmd, buffer, params,
			 /* FIXME: parameter should be invstring now */
			 p_opt("bolt11", param_invstring, &invstring),
			 p_opt("payment_hash", param_sha256, &rhash),
			 p_opt("status", param_payment_status, &status),
			 p_opt("index", param_index, &listindex),
			 p_opt_def("start", param_u64, &liststart, 0),
			 p_opt("limit", param_u32, &listlimit),
			 NULL))
		return command_param_failed();

	if (rhash && invstring) {
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "Can only specify one of"
				    " {bolt11} or {payment_hash}");
	}

	if (*liststart != 0 && !listindex) {
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "Can only specify {start} with {index}");
	}
	if (listlimit && !listindex) {
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "Can only specify {limit} with {index}");
	}

	if ((rhash || invstring) && *liststart != 0) {
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "Cannot use start with bolt11 or payment_hash");
	}

	if (invstring) {
		struct bolt11 *b11;
		char *fail;

		b11 = bolt11_decode(cmd, invstring, cmd->ld->our_features, NULL,
				    chainparams, &fail);
		if (b11) {
			rhash = &b11->payment_hash;
		} else {
			struct tlv_invoice *b12;

			b12 = invoice_decode(cmd, invstring, strlen(invstring),
					     cmd->ld->our_features,
					     chainparams, &fail);
			if (b12 && b12->invoice_payment_hash)
				rhash = b12->invoice_payment_hash;
			else
				return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
						    "Invalid invstring: %s", fail);
		}
	}

	if (command_check_only(cmd))
		return command_check_done(cmd);

	response = json_stream_success(cmd);

	json_array_start(response, "payments");
	if (rhash)
		stmt = payments_by_hash(cmd->ld->wallet, rhash);
	else if (status)
		stmt = payments_by_status(cmd->ld->wallet, *status,
					  listindex, *liststart, listlimit);
	else
		stmt = payments_first(cmd->ld->wallet,
				      listindex, *liststart, listlimit);

	for (; stmt; stmt = payments_next(cmd->ld->wallet, stmt)) {
		json_object_start(response, NULL);
		json_add_payment_fields(response, payment_get_details(tmpctx, stmt));
		json_object_end(response);
	}
	json_array_end(response);

	return command_success(cmd, response);
}

static const struct json_command listsendpays_command = {
	"listsendpays",
	json_listsendpays,
};
AUTODATA(json_command, &listsendpays_command);

static struct command_result *
param_payment_status_nopending(struct command *cmd,
			       const char *name,
			       const char *buffer,
			       const jsmntok_t *tok,
			       enum payment_status **status)
{
	struct command_result *res;

	res = param_payment_status(cmd, name, buffer, tok, status);
	if (res)
		return res;

	switch (**status) {
	case PAYMENT_COMPLETE:
	case PAYMENT_FAILED:
		break;
	case PAYMENT_PENDING:
		return command_fail_badparam(cmd, name, buffer, tok,
					     "Cannot delete pending status");
	}
	return NULL;
}

static struct command_result *json_delpay(struct command *cmd,
						const char *buffer,
						const jsmntok_t *obj UNNEEDED,
						const jsmntok_t *params)
{
	const enum payment_status *found_status = NULL;
	struct json_stream *response;
	const struct wallet_payment **payments;
	enum payment_status *status;
	struct sha256 *payment_hash;
	u64 *groupid, *partid;
	struct db_stmt *stmt;

	if (!param_check(cmd, buffer, params,
			 p_req("payment_hash", param_sha256, &payment_hash),
			 p_req("status", param_payment_status_nopending, &status),
			 p_opt("partid", param_u64, &partid),
			 p_opt("groupid", param_u64, &groupid),
			 NULL))
		return command_param_failed();

	if ((partid != NULL) != (groupid != NULL))
		return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
				    "Must set both partid and groupid, or neither");

	stmt = payments_by_hash(cmd->ld->wallet, payment_hash);
	if (!stmt)
		return command_fail(cmd, PAY_NO_SUCH_PAYMENT, "Unknown payment with payment_hash: %s",
				    fmt_sha256(tmpctx, payment_hash));

	payments = tal_arr(cmd, const struct wallet_payment *, 0);
	for (; stmt; stmt = payments_next(cmd->ld->wallet, stmt)) {
		struct wallet_payment *payment;
		payment = payment_get_details(payments, stmt);
		if (groupid && payment->groupid != *groupid)
			continue;
		if (partid && payment->partid != *partid)
			continue;

		if (payment->status == *status)
			tal_arr_expand(&payments, payment);
		else
			found_status = &payment->status;
	}

	if (tal_count(payments) == 0) {
		if (found_status)
			return command_fail(cmd, PAY_NO_SUCH_PAYMENT, "Payment with hash %s has %s status but it different from the one provided %s",
				fmt_sha256(tmpctx, payment_hash),
				payment_status_to_string(*found_status),
				payment_status_to_string(*status));

		return command_fail(cmd, PAY_NO_SUCH_PAYMENT,
				    "No payment for that payment_hash with that partid and groupid");
	}

	if (command_check_only(cmd))
		return command_check_done(cmd);

	wallet_payment_delete(cmd->ld->wallet, payment_hash, groupid, partid, status);

	response = json_stream_success(cmd);
	json_array_start(response, "payments");
	for (int i = 0; i < tal_count(payments); i++) {
		json_object_start(response, NULL);
		json_add_payment_fields(response, payments[i]);
		json_object_end(response);
	}
	json_array_end(response);
	return command_success(cmd, response);
}

static const struct json_command delpay_command = {
	"delpay",
	json_delpay,
};
AUTODATA(json_command, &delpay_command);

static struct command_result *json_createonion(struct command *cmd,
						const char *buffer,
						const jsmntok_t *obj UNNEEDED,
						const jsmntok_t *params)
{
	struct json_stream *response;
	struct secret *session_key, *shared_secrets;
	struct sphinx_path *sp;
	u8 *assocdata, *serialized;
	u32 *packet_size;
	struct onionpacket *packet;
	struct sphinx_hop *hops;

	if (!param_check(cmd, buffer, params,
			 p_req("hops", param_hops_array, &hops),
			 p_req("assocdata", param_bin_from_hex, &assocdata),
			 p_opt("session_key", param_secret, &session_key),
			 p_opt_def("onion_size", param_number, &packet_size, ROUTING_INFO_SIZE),
			 NULL)) {
		return command_param_failed();
	}

	if (session_key == NULL)
		sp = sphinx_path_new(cmd, assocdata);
	else
		sp = sphinx_path_new_with_key(cmd, assocdata, session_key);

	for (size_t i=0; i<tal_count(hops); i++) {
		if (!sphinx_add_hop_has_length(sp, &hops[i].pubkey, hops[i].raw_payload))
			return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
					    "hops[%zi] payload is not prefixed with length!",
					    i);
	}

	if (sphinx_path_payloads_size(sp) > *packet_size)
		return command_fail(
		    cmd, JSONRPC2_INVALID_PARAMS,
		    "Payloads exceed maximum onion packet size.");

	packet = create_onionpacket(cmd, sp, *packet_size, &shared_secrets);
	if (!packet)
		return command_fail(cmd, LIGHTNINGD,
				    "Could not create onion packet");

	if (command_check_only(cmd))
		return command_check_done(cmd);

	serialized = serialize_onionpacket(cmd, packet);

	response = json_stream_success(cmd);
	json_add_hex(response, "onion", serialized, tal_bytelen(serialized));
	json_array_start(response, "shared_secrets");
	for (size_t i=0; i<tal_count(hops); i++) {
		json_add_secret(response, NULL, &shared_secrets[i]);
	}
	json_array_end(response);
	return command_success(cmd, response);
}

static const struct json_command createonion_command = {
	"createonion",
	json_createonion,
};
AUTODATA(json_command, &createonion_command);