Rusty Russell
7 years ago
committed by
Christian Decker
Christian Decker
68 changed files with 75 additions and 14951 deletions
@ -1 +1 @@ |
|||
from .lightning import LightningRpc, LegacyLightningRpc |
|||
from .lightning import LightningRpc |
|||
|
|||
@ -1,359 +0,0 @@ |
|||
#include "channel.h" |
|||
#include "htlc.h" |
|||
#include "remove_dust.h" |
|||
#include "type_to_string.h" |
|||
#include <assert.h> |
|||
#include <ccan/array_size/array_size.h> |
|||
#include <ccan/mem/mem.h> |
|||
#include <ccan/structeq/structeq.h> |
|||
#include <ccan/tal/str/str.h> |
|||
#include <inttypes.h> |
|||
#include <string.h> |
|||
|
|||
uint64_t fee_by_feerate(size_t txsize, uint64_t fee_rate) |
|||
{ |
|||
/* FIXME-OLD #2:
|
|||
* |
|||
* The fee for a transaction MUST be calculated by multiplying this |
|||
* bytecount by the fee rate, dividing by 1000 and truncating |
|||
* (rounding down) the result to an even number of satoshis. |
|||
*/ |
|||
return txsize * fee_rate / 2000 * 2; |
|||
} |
|||
|
|||
/* FIXME-OLD #2:
|
|||
* |
|||
* A node MUST use the formula 338 + 32 bytes for every non-dust HTLC |
|||
* as the bytecount for calculating commitment transaction fees. Note |
|||
* that the fee requirement is unchanged, even if the elimination of |
|||
* dust HTLC outputs has caused a non-zero fee already. |
|||
*/ |
|||
static size_t tx_bytes(size_t num_nondust_htlcs) |
|||
{ |
|||
return 338 + 32 * num_nondust_htlcs; |
|||
} |
|||
|
|||
static uint64_t calculate_fee_msat(size_t num_nondust_htlcs, |
|||
uint64_t fee_rate) |
|||
{ |
|||
/* milli-satoshis */ |
|||
return fee_by_feerate(tx_bytes(num_nondust_htlcs), fee_rate) * 1000; |
|||
} |
|||
|
|||
/* Pay this much fee, if possible. Return amount unpaid. */ |
|||
static uint64_t pay_fee(struct channel_oneside *side, uint64_t fee_msat) |
|||
{ |
|||
if (side->pay_msat >= fee_msat) { |
|||
side->pay_msat -= fee_msat; |
|||
side->fee_msat += fee_msat; |
|||
return 0; |
|||
} else { |
|||
uint64_t remainder = fee_msat - side->pay_msat; |
|||
side->fee_msat += side->pay_msat; |
|||
side->pay_msat = 0; |
|||
return remainder; |
|||
} |
|||
} |
|||
|
|||
/* Charge the fee as per FIXME-OLD #2 */ |
|||
static void recalculate_fees(struct channel_oneside *a, |
|||
struct channel_oneside *b, |
|||
uint64_t fee_msat) |
|||
{ |
|||
uint64_t remainder; |
|||
|
|||
/* Fold in fees, to recalcuate again below. */ |
|||
a->pay_msat += a->fee_msat; |
|||
b->pay_msat += b->fee_msat; |
|||
a->fee_msat = b->fee_msat = 0; |
|||
|
|||
/* FIXME-OLD #2:
|
|||
* |
|||
* 1. If each nodes can afford half the fee from their |
|||
* to-`final_key` output, reduce the two to-`final_key` |
|||
* outputs accordingly. |
|||
* |
|||
* 2. Otherwise, reduce the to-`final_key` output of one node |
|||
* which cannot afford the fee to zero (resulting in that |
|||
* entire output paying fees). If the remaining |
|||
* to-`final_key` output is greater than the fee remaining, |
|||
* reduce it accordingly, otherwise reduce it to zero to |
|||
* pay as much fee as possible. |
|||
*/ |
|||
remainder = pay_fee(a, fee_msat / 2) + pay_fee(b, fee_msat / 2); |
|||
|
|||
/* If there's anything left, the other side tries to pay for it. */ |
|||
remainder = pay_fee(a, remainder); |
|||
pay_fee(b, remainder); |
|||
} |
|||
|
|||
/* a transfers htlc_msat to a HTLC (gains it, if -ve) */ |
|||
static bool change_funding(uint64_t anchor_satoshis, |
|||
uint64_t fee_rate, |
|||
int64_t htlc_msat, |
|||
struct channel_oneside *a, |
|||
struct channel_oneside *b, |
|||
size_t num_nondust_htlcs, |
|||
bool must_afford_fee) |
|||
{ |
|||
uint64_t fee_msat; |
|||
uint64_t htlcs_total; |
|||
|
|||
htlcs_total = anchor_satoshis * 1000 |
|||
- (a->pay_msat + a->fee_msat + b->pay_msat + b->fee_msat); |
|||
|
|||
fee_msat = calculate_fee_msat(num_nondust_htlcs, fee_rate); |
|||
|
|||
/* If A is paying, can it afford it? */ |
|||
if (htlc_msat >= 0) { |
|||
uint64_t cost = htlc_msat; |
|||
if (must_afford_fee) |
|||
cost += fee_msat / 2; |
|||
if (cost > a->pay_msat + a->fee_msat) |
|||
return false; |
|||
} |
|||
|
|||
/* OK, now adjust funds for A, then recalculate fees. */ |
|||
a->pay_msat -= htlc_msat; |
|||
recalculate_fees(a, b, fee_msat); |
|||
|
|||
htlcs_total += htlc_msat; |
|||
assert(htlcs_total == anchor_satoshis * 1000 |
|||
- (a->pay_msat + a->fee_msat + b->pay_msat + b->fee_msat)); |
|||
return true; |
|||
} |
|||
|
|||
bool anchor_too_large(uint64_t anchor_satoshis) |
|||
{ |
|||
/* Anchor must fit in 32 bit. */ |
|||
return anchor_satoshis >= (1ULL << 32) / 1000; |
|||
} |
|||
|
|||
struct channel_state *initial_cstate(const tal_t *ctx, |
|||
uint64_t anchor_satoshis, |
|||
uint64_t fee_rate, |
|||
enum side funding) |
|||
{ |
|||
uint64_t fee_msat; |
|||
struct channel_state *cstate = talz(ctx, struct channel_state); |
|||
struct channel_oneside *funder, *fundee; |
|||
|
|||
cstate->fee_rate = fee_rate; |
|||
cstate->anchor = anchor_satoshis; |
|||
cstate->num_nondust = 0; |
|||
|
|||
/* Anchor must fit in 32 bit. */ |
|||
assert(!anchor_too_large(anchor_satoshis)); |
|||
|
|||
fee_msat = calculate_fee_msat(0, fee_rate); |
|||
if (fee_msat > anchor_satoshis * 1000) |
|||
return tal_free(cstate); |
|||
|
|||
funder = &cstate->side[funding]; |
|||
fundee = &cstate->side[!funding]; |
|||
|
|||
/* Neither side has HTLCs. */ |
|||
funder->num_htlcs = fundee->num_htlcs = 0; |
|||
|
|||
/* Initially, all goes back to funder. */ |
|||
funder->pay_msat = anchor_satoshis * 1000 - fee_msat; |
|||
funder->fee_msat = fee_msat; |
|||
|
|||
/* Make sure it checks out. */ |
|||
assert(change_funding(anchor_satoshis, fee_rate, 0, funder, fundee, 0, false)); |
|||
assert(funder->fee_msat == fee_msat); |
|||
assert(fundee->fee_msat == 0); |
|||
|
|||
return cstate; |
|||
} |
|||
|
|||
/* FIXME: Write exact variant! */ |
|||
uint64_t approx_max_feerate(const struct channel_state *cstate, |
|||
enum side side) |
|||
{ |
|||
uint64_t max_funds; |
|||
|
|||
max_funds = cstate->side[side].pay_msat + cstate->side[side].fee_msat; |
|||
|
|||
return max_funds / tx_bytes(cstate->num_nondust); |
|||
} |
|||
|
|||
bool can_afford_feerate(const struct channel_state *cstate, uint64_t fee_rate, |
|||
enum side side) |
|||
{ |
|||
u64 fee_msat = calculate_fee_msat(cstate->num_nondust, fee_rate); |
|||
|
|||
return cstate->side[side].pay_msat + cstate->side[side].fee_msat |
|||
>= fee_msat; |
|||
} |
|||
|
|||
void adjust_fee(struct channel_state *cstate, uint64_t fee_rate) |
|||
{ |
|||
uint64_t fee_msat; |
|||
|
|||
fee_msat = calculate_fee_msat(cstate->num_nondust, fee_rate); |
|||
|
|||
recalculate_fees(&cstate->side[LOCAL], &cstate->side[REMOTE], fee_msat); |
|||
} |
|||
|
|||
bool force_fee(struct channel_state *cstate, uint64_t fee) |
|||
{ |
|||
/* Beware overflow! */ |
|||
if (fee > 0xFFFFFFFFFFFFFFFFULL / 1000) |
|||
return false; |
|||
recalculate_fees(&cstate->side[LOCAL], &cstate->side[REMOTE], fee * 1000); |
|||
return cstate->side[LOCAL].fee_msat + cstate->side[REMOTE].fee_msat == fee * 1000; |
|||
} |
|||
|
|||
/* Add a HTLC to @creator if it can afford it. */ |
|||
bool cstate_add_htlc(struct channel_state *cstate, const struct htlc *htlc, |
|||
bool must_afford_fee) |
|||
{ |
|||
size_t nondust; |
|||
struct channel_oneside *creator, *recipient; |
|||
|
|||
creator = &cstate->side[htlc_owner(htlc)]; |
|||
recipient = &cstate->side[!htlc_owner(htlc)]; |
|||
|
|||
/* Remember to count the new one in total txsize if not dust! */ |
|||
nondust = cstate->num_nondust; |
|||
if (!is_dust(htlc->msatoshi / 1000)) |
|||
nondust++; |
|||
|
|||
if (!change_funding(cstate->anchor, cstate->fee_rate, |
|||
htlc->msatoshi, creator, recipient, nondust, |
|||
must_afford_fee)) |
|||
return false; |
|||
|
|||
cstate->num_nondust = nondust; |
|||
creator->num_htlcs++; |
|||
return true; |
|||
} |
|||
|
|||
/* Remove htlc from creator, credit it to beneficiary. */ |
|||
static void remove_htlc(struct channel_state *cstate, |
|||
enum side creator, |
|||
enum side beneficiary, |
|||
const struct htlc *htlc) |
|||
{ |
|||
size_t nondust; |
|||
|
|||
/* Remember to remove this one in total txsize if not dust! */ |
|||
nondust = cstate->num_nondust; |
|||
if (!is_dust(htlc->msatoshi / 1000)) { |
|||
assert(nondust > 0); |
|||
nondust--; |
|||
} |
|||
|
|||
/* Can't fail since msatoshi is positive. */ |
|||
if (!change_funding(cstate->anchor, cstate->fee_rate, |
|||
-(int64_t)htlc->msatoshi, |
|||
&cstate->side[beneficiary], |
|||
&cstate->side[!beneficiary], nondust, false)) |
|||
abort(); |
|||
|
|||
/* Actually remove the HTLC. */ |
|||
assert(cstate->side[creator].num_htlcs > 0); |
|||
cstate->side[creator].num_htlcs--; |
|||
cstate->num_nondust = nondust; |
|||
} |
|||
|
|||
void cstate_fail_htlc(struct channel_state *cstate, const struct htlc *htlc) |
|||
{ |
|||
remove_htlc(cstate, htlc_owner(htlc), htlc_owner(htlc), htlc); |
|||
} |
|||
|
|||
void cstate_fulfill_htlc(struct channel_state *cstate, const struct htlc *htlc) |
|||
{ |
|||
remove_htlc(cstate, htlc_owner(htlc), !htlc_owner(htlc), htlc); |
|||
} |
|||
|
|||
struct channel_state *copy_cstate(const tal_t *ctx, |
|||
const struct channel_state *cstate) |
|||
{ |
|||
return tal_dup(ctx, struct channel_state, cstate); |
|||
} |
|||
|
|||
void force_add_htlc(struct channel_state *cstate, const struct htlc *htlc) |
|||
{ |
|||
struct channel_oneside *creator; |
|||
|
|||
creator = &cstate->side[htlc_owner(htlc)]; |
|||
creator->num_htlcs++; |
|||
creator->pay_msat -= htlc->msatoshi; |
|||
|
|||
/* Remember to count the new one in total txsize if not dust! */ |
|||
if (!is_dust(htlc->msatoshi / 1000)) |
|||
cstate->num_nondust++; |
|||
} |
|||
|
|||
static void force_remove_htlc(struct channel_state *cstate, |
|||
enum side beneficiary, |
|||
const struct htlc *htlc) |
|||
{ |
|||
cstate->side[beneficiary].pay_msat += htlc->msatoshi; |
|||
cstate->side[htlc_owner(htlc)].num_htlcs--; |
|||
if (!is_dust(htlc->msatoshi / 1000)) |
|||
cstate->num_nondust--; |
|||
} |
|||
|
|||
void force_fail_htlc(struct channel_state *cstate, const struct htlc *htlc) |
|||
{ |
|||
force_remove_htlc(cstate, htlc_owner(htlc), htlc); |
|||
} |
|||
|
|||
void force_fulfill_htlc(struct channel_state *cstate, const struct htlc *htlc) |
|||
{ |
|||
force_remove_htlc(cstate, !htlc_owner(htlc), htlc); |
|||
} |
|||
|
|||
bool balance_after_force(struct channel_state *cstate) |
|||
{ |
|||
/* We should not spend more than anchor */ |
|||
if (cstate->side[LOCAL].pay_msat + cstate->side[REMOTE].pay_msat |
|||
> cstate->anchor * 1000) |
|||
return false; |
|||
|
|||
/* Check for wrap. */ |
|||
if (cstate->side[LOCAL].pay_msat > cstate->anchor * 1000) |
|||
return false; |
|||
if (cstate->side[REMOTE].pay_msat > cstate->anchor * 1000) |
|||
return false; |
|||
|
|||
if (cstate->num_nondust |
|||
> cstate->side[LOCAL].num_htlcs + cstate->side[REMOTE].num_htlcs) |
|||
return false; |
|||
|
|||
/* Recalc fees. */ |
|||
adjust_fee(cstate, cstate->fee_rate); |
|||
return true; |
|||
} |
|||
|
|||
static char *fmt_channel_oneside(const tal_t *ctx, |
|||
const struct channel_oneside *co) |
|||
{ |
|||
return tal_fmt(ctx, "{ pay_msat=%u" |
|||
" fee_msat=%u" |
|||
" num_htlcs=%u }", |
|||
co->pay_msat, |
|||
co->fee_msat, |
|||
co->num_htlcs); |
|||
} |
|||
|
|||
static char *fmt_channel_state(const tal_t *ctx, |
|||
const struct channel_state *cs) |
|||
{ |
|||
return tal_fmt(ctx, "{ anchor=%"PRIu64 |
|||
" fee_rate=%"PRIu64 |
|||
" num_nondust=%u" |
|||
" ours=%s" |
|||
" theirs=%s }", |
|||
cs->anchor, |
|||
cs->fee_rate, |
|||
cs->num_nondust, |
|||
fmt_channel_oneside(ctx, &cs->side[LOCAL]), |
|||
fmt_channel_oneside(ctx, &cs->side[REMOTE])); |
|||
} |
|||
|
|||
REGISTER_TYPE_TO_STRING(channel_oneside, fmt_channel_oneside); |
|||
REGISTER_TYPE_TO_STRING(channel_state, fmt_channel_state); |
|||
@ -1,140 +0,0 @@ |
|||
#ifndef LIGHTNING_DAEMON_CHANNEL_H |
|||
#define LIGHTNING_DAEMON_CHANNEL_H |
|||
#include "config.h" |
|||
#include "bitcoin/locktime.h" |
|||
#include "daemon/htlc.h" |
|||
#include <assert.h> |
|||
#include <ccan/crypto/sha256/sha256.h> |
|||
#include <ccan/tal/tal.h> |
|||
#include <stdbool.h> |
|||
|
|||
struct channel_oneside { |
|||
/* Payment and fee is in millisatoshi. */ |
|||
uint32_t pay_msat, fee_msat; |
|||
/* Number of HTLCs (required for limiting total number) */ |
|||
unsigned int num_htlcs; |
|||
}; |
|||
|
|||
struct channel_state { |
|||
/* Satoshis paid by anchor. */ |
|||
uint64_t anchor; |
|||
/* Satoshis per 1000 bytes. */ |
|||
uint64_t fee_rate; |
|||
/* Number of non-dust htlcs (to calculate txsize) */ |
|||
unsigned int num_nondust; |
|||
struct channel_oneside side[2]; |
|||
}; |
|||
|
|||
/**
|
|||
* initial_cstate: Given initial fees and funding anchor, what is initial state? |
|||
* @ctx: tal context to allocate return value from. |
|||
* @anchor_satoshis: The anchor amount. |
|||
* @fee_rate: amount to pay in fees per kb (in satoshi). |
|||
* @dir: which side paid for the anchor. |
|||
* |
|||
* Returns state, or NULL if malformed. |
|||
*/ |
|||
struct channel_state *initial_cstate(const tal_t *ctx, |
|||
uint64_t anchor_satoshis, |
|||
uint64_t fee_rate, |
|||
enum side side); |
|||
|
|||
/**
|
|||
* copy_cstate: Make a deep copy of channel_state |
|||
* @ctx: tal context to allocate return value from. |
|||
* @cstate: state to copy. |
|||
*/ |
|||
struct channel_state *copy_cstate(const tal_t *ctx, |
|||
const struct channel_state *cstate); |
|||
|
|||
/**
|
|||
* cstate_add_htlc: append an HTLC to cstate if it can afford it |
|||
* @cstate: The channel state |
|||
* @htlc: the htlc pointer. |
|||
* @must_afford_fee: true if payer must meet fee. |
|||
* |
|||
* If that direction can't afford the HTLC this will return false and |
|||
* leave @cstate unchanged. If @must_afford_fee is true, and the |
|||
* direction can't afford its half of the fees, it will also return |
|||
* false and leave @cstate unchanged. Otherwise, pay_msat and fee_msat |
|||
* are adjusted accordingly; true is returned. |
|||
*/ |
|||
bool cstate_add_htlc(struct channel_state *cstate, const struct htlc *htlc, |
|||
bool must_afford_fee); |
|||
|
|||
/**
|
|||
* cstate_fail_htlc: remove an HTLC, funds to the side which offered it. |
|||
* @cstate: The channel state |
|||
* @htlc: the htlc to remove. |
|||
* |
|||
* This will remove the @index'th entry in cstate->side[dir].htlcs[], and credit |
|||
* the value of the HTLC (back) to cstate->side[dir]. |
|||
*/ |
|||
void cstate_fail_htlc(struct channel_state *cstate, const struct htlc *htlc); |
|||
|
|||
/**
|
|||
* cstate_fulfill_htlc: remove an HTLC, funds to side which accepted it. |
|||
* @cstate: The channel state |
|||
* @htlc: the htlc to remove |
|||
* |
|||
* This will remove the @index'th entry in cstate->side[dir].htlcs[], and credit |
|||
* the value of the HTLC to cstate->side[!dir]. |
|||
*/ |
|||
void cstate_fulfill_htlc(struct channel_state *cstate, const struct htlc *htlc); |
|||
|
|||
/**
|
|||
* approx_max_feerate: what's the most side could raise fee rate to? |
|||
* @cstate: The channel state |
|||
* @side: LOCAL or REMOTE |
|||
* |
|||
* This is not exact! To check if their offer is valid, use can_afford_feerate. |
|||
*/ |
|||
uint64_t approx_max_feerate(const struct channel_state *cstate, |
|||
enum side side); |
|||
|
|||
/**
|
|||
* can_afford_feerate: could this side pay for the fee if changed to fee_rate? |
|||
* @cstate: The channel state |
|||
* @fee_rate: the new fee rate proposed |
|||
* @side: LOCAL or REMOTE |
|||
*/ |
|||
bool can_afford_feerate(const struct channel_state *cstate, uint64_t fee_rate, |
|||
enum side side); |
|||
|
|||
/**
|
|||
* adjust_fee: Change fee rate. |
|||
* @cstate: The channel state |
|||
* @fee_rate: fee in satoshi per 1000 bytes. |
|||
*/ |
|||
void adjust_fee(struct channel_state *cstate, uint64_t fee_rate); |
|||
|
|||
/**
|
|||
* force_fee: Change fee to a specific value. |
|||
* @cstate: The channel state |
|||
* @fee: fee in satoshi. |
|||
* |
|||
* This is used for the close transaction, which specifies an exact fee. |
|||
* If the fee cannot be paid in full, this return false (but cstate will |
|||
* still be altered). |
|||
*/ |
|||
bool force_fee(struct channel_state *cstate, uint64_t fee); |
|||
|
|||
/**
|
|||
* fee_for_feerate: calculate the fee (in satoshi) for a given fee_rate. |
|||
* @txsize: transaction size in bytes. |
|||
* @fee_rate: satoshi per 1000 bytes. |
|||
*/ |
|||
uint64_t fee_by_feerate(size_t txsize, uint64_t fee_rate); |
|||
|
|||
/**
|
|||
* anchor_too_large: does anchor amount fit in 32-bits of millisatoshi. |
|||
* @anchor_satoshis: amount in satoshis |
|||
*/ |
|||
bool anchor_too_large(uint64_t anchor_satoshis); |
|||
|
|||
/* Routines to db to force HTLC changes out-of-order which may wrap. */ |
|||
void force_add_htlc(struct channel_state *cstate, const struct htlc *htlc); |
|||
void force_fail_htlc(struct channel_state *cstate, const struct htlc *htlc); |
|||
void force_fulfill_htlc(struct channel_state *cstate, const struct htlc *htlc); |
|||
bool balance_after_force(struct channel_state *cstate); |
|||
#endif /* LIGHTNING_DAEMON_CHANNEL_H */ |
|||
@ -1,225 +0,0 @@ |
|||
#include "bitcoin/locktime.h" |
|||
#include "bitcoin/pubkey.h" |
|||
#include "bitcoin/script.h" |
|||
#include "bitcoin/shadouble.h" |
|||
#include "bitcoin/tx.h" |
|||
#include "channel.h" |
|||
#include "commit_tx.h" |
|||
#include "htlc.h" |
|||
#include "lightningd.h" |
|||
#include "log.h" |
|||
#include "overflows.h" |
|||
#include "peer.h" |
|||
#include "peer_internal.h" |
|||
#include "permute_tx.h" |
|||
#include "remove_dust.h" |
|||
#include "utils.h" |
|||
#include <assert.h> |
|||
#include <inttypes.h> |
|||
|
|||
u8 *wscript_for_htlc(const tal_t *ctx, |
|||
const struct peer *peer, |
|||
const struct htlc *h, |
|||
const struct sha256 *rhash, |
|||
enum side side) |
|||
{ |
|||
const struct peer_visible_state *this_side, *other_side; |
|||
u8 *(*fn)(const tal_t *, |
|||
const struct pubkey *, const struct pubkey *, |
|||
const struct abs_locktime *, const struct rel_locktime *, |
|||
const struct sha256 *, const struct sha256 *); |
|||
|
|||
/* scripts are different for htlcs offered vs accepted */ |
|||
if (side == htlc_owner(h)) |
|||
fn = bitcoin_redeem_htlc_send; |
|||
else |
|||
fn = bitcoin_redeem_htlc_recv; |
|||
|
|||
if (side == LOCAL) { |
|||
this_side = &peer->local; |
|||
other_side = &peer->remote; |
|||
} else { |
|||
this_side = &peer->remote; |
|||
other_side = &peer->local; |
|||
} |
|||
|
|||
return fn(ctx, |
|||
&this_side->finalkey, &other_side->finalkey, |
|||
&h->expiry, &this_side->locktime, rhash, &h->rhash); |
|||
} |
|||
|
|||
static size_t count_htlcs(const struct htlc_map *htlcs, int flag) |
|||
{ |
|||
struct htlc_map_iter it; |
|||
struct htlc *h; |
|||
size_t n = 0; |
|||
|
|||
for (h = htlc_map_first(htlcs, &it); h; h = htlc_map_next(htlcs, &it)) { |
|||
if (htlc_has(h, flag)) |
|||
n++; |
|||
} |
|||
return n; |
|||
} |
|||
|
|||
u8 *commit_output_to_us(const tal_t *ctx, |
|||
const struct peer *peer, |
|||
const struct sha256 *rhash, |
|||
enum side side, |
|||
u8 **wscript) |
|||
{ |
|||
u8 *tmp; |
|||
if (!wscript) |
|||
wscript = &tmp; |
|||
|
|||
/* Our output to ourself is encumbered by delay. */ |
|||
if (side == LOCAL) { |
|||
*wscript = bitcoin_redeem_secret_or_delay(ctx, |
|||
&peer->local.finalkey, |
|||
&peer->remote.locktime, |
|||
&peer->remote.finalkey, |
|||
rhash); |
|||
return scriptpubkey_p2wsh(ctx, *wscript); |
|||
} else { |
|||
/* Their output to us is a simple p2wpkh */ |
|||
*wscript = NULL; |
|||
return scriptpubkey_p2wpkh(ctx, &peer->local.finalkey); |
|||
} |
|||
} |
|||
|
|||
u8 *commit_output_to_them(const tal_t *ctx, |
|||
const struct peer *peer, |
|||
const struct sha256 *rhash, |
|||
enum side side, |
|||
u8 **wscript) |
|||
{ |
|||
u8 *tmp; |
|||
if (!wscript) |
|||
wscript = &tmp; |
|||
|
|||
/* Their output to themselves is encumbered by delay. */ |
|||
if (side == REMOTE) { |
|||
*wscript = bitcoin_redeem_secret_or_delay(ctx, |
|||
&peer->remote.finalkey, |
|||
&peer->local.locktime, |
|||
&peer->local.finalkey, |
|||
rhash); |
|||
return scriptpubkey_p2wsh(ctx, *wscript); |
|||
} else { |
|||
/* Our output to them is a simple p2wpkh */ |
|||
*wscript = NULL; |
|||
return scriptpubkey_p2wpkh(ctx, &peer->remote.finalkey); |
|||
} |
|||
} |
|||
|
|||
/* Takes ownership of script. */ |
|||
static bool add_output(struct bitcoin_tx *tx, u8 *script, u64 amount, |
|||
size_t *output_count, |
|||
u64 *total) |
|||
{ |
|||
assert(*output_count < tal_count(tx->output)); |
|||
if (is_dust(amount)) |
|||
return false; |
|||
tx->output[*output_count].script = tal_steal(tx, script); |
|||
tx->output[*output_count].amount = amount; |
|||
(*output_count)++; |
|||
(*total) += amount; |
|||
return true; |
|||
} |
|||
|
|||
struct bitcoin_tx *create_commit_tx(const tal_t *ctx, |
|||
struct peer *peer, |
|||
const struct sha256 *rhash, |
|||
const struct channel_state *cstate, |
|||
enum side side, |
|||
bool *otherside_only) |
|||
{ |
|||
const tal_t *tmpctx = tal_tmpctx(ctx); |
|||
struct bitcoin_tx *tx; |
|||
uint64_t total = 0; |
|||
struct htlc_map_iter it; |
|||
struct htlc *h; |
|||
size_t output_count; |
|||
bool pays_to[2]; |
|||
int committed_flag = HTLC_FLAG(side,HTLC_F_COMMITTED); |
|||
|
|||
/* Now create commitment tx: one input, two outputs (plus htlcs) */ |
|||
tx = bitcoin_tx(ctx, 1, 2 + count_htlcs(&peer->htlcs, committed_flag)); |
|||
|
|||
log_debug(peer->log, "Creating commitment tx:"); |
|||
log_add_struct(peer->log, " rhash = %s", struct sha256, rhash); |
|||
log_add_struct(peer->log, " My finalkey = %s", struct pubkey, |
|||
&peer->local.finalkey); |
|||
log_add_struct(peer->log, " Their finalkey = %s", struct pubkey, |
|||
&peer->remote.finalkey); |
|||
log_add_struct(peer->log, " My locktime = %s", struct rel_locktime, |
|||
&peer->local.locktime); |
|||
log_add_struct(peer->log, " Their locktime = %s", struct rel_locktime, |
|||
&peer->remote.locktime); |
|||
|
|||
/* Our input spends the anchor tx output. */ |
|||
tx->input[0].txid = peer->anchor.txid; |
|||
tx->input[0].index = peer->anchor.index; |
|||
tx->input[0].amount = tal_dup(tx->input, u64, &peer->anchor.satoshis); |
|||
|
|||
output_count = 0; |
|||
pays_to[LOCAL] = add_output(tx, commit_output_to_us(tmpctx, peer, rhash, |
|||
side, NULL), |
|||
cstate->side[LOCAL].pay_msat / 1000, |
|||
&output_count, |
|||
&total); |
|||
if (pays_to[LOCAL]) |
|||
log_debug(peer->log, "Pays %u to local: %s", |
|||
cstate->side[LOCAL].pay_msat / 1000, |
|||
tal_hex(tmpctx, tx->output[output_count-1].script)); |
|||
else |
|||
log_debug(peer->log, "DOES NOT pay %u to local", |
|||
cstate->side[LOCAL].pay_msat / 1000); |
|||
pays_to[REMOTE] = add_output(tx, commit_output_to_them(tmpctx, peer, |
|||
rhash, side, |
|||
NULL), |
|||
cstate->side[REMOTE].pay_msat / 1000, |
|||
&output_count, |
|||
&total); |
|||
if (pays_to[REMOTE]) |
|||
log_debug(peer->log, "Pays %u to remote: %s", |
|||
cstate->side[REMOTE].pay_msat / 1000, |
|||
tal_hex(tmpctx, tx->output[output_count-1].script)); |
|||
else |
|||
log_debug(peer->log, "DOES NOT pay %u to remote", |
|||
cstate->side[REMOTE].pay_msat / 1000); |
|||
|
|||
/* If their tx doesn't pay to them, or our tx doesn't pay to us... */ |
|||
*otherside_only = !pays_to[side]; |
|||
|
|||
/* First two outputs done, now for the HTLCs. */ |
|||
for (h = htlc_map_first(&peer->htlcs, &it); |
|||
h; |
|||
h = htlc_map_next(&peer->htlcs, &it)) { |
|||
const u8 *wscript; |
|||
|
|||
if (!htlc_has(h, committed_flag)) |
|||
continue; |
|||
wscript = wscript_for_htlc(tmpctx, peer, h, rhash, side); |
|||
/* If we pay any HTLC, it's txout is not just to other side. */ |
|||
if (add_output(tx, scriptpubkey_p2wsh(tmpctx, wscript), |
|||
h->msatoshi / 1000, &output_count, &total)) { |
|||
*otherside_only = false; |
|||
log_debug(peer->log, "Pays %"PRIu64" to htlc %"PRIu64, |
|||
h->msatoshi / 1000, h->id); |
|||
log_add_struct(peer->log, " expiry %s", |
|||
struct abs_locktime, &h->expiry); |
|||
log_add_struct(peer->log, " rhash %s", struct sha256, |
|||
&h->rhash); |
|||
log_debug(peer->log, "Script: %s", |
|||
tal_hex(tmpctx, wscript)); |
|||
} else |
|||
log_debug(peer->log, "DOES NOT pay %"PRIu64" to htlc %"PRIu64, |
|||
h->msatoshi / 1000, h->id); |
|||
} |
|||
assert(total <= peer->anchor.satoshis); |
|||
|
|||
tal_resize(&tx->output, output_count); |
|||
permute_outputs(tx->output, tal_count(tx->output), NULL); |
|||
tal_free(tmpctx); |
|||
return tx; |
|||
} |
|||
@ -1,40 +0,0 @@ |
|||
#ifndef LIGHTNING_COMMIT_TX_H |
|||
#define LIGHTNING_COMMIT_TX_H |
|||
#include "config.h" |
|||
#include "htlc.h" |
|||
#include <ccan/tal/tal.h> |
|||
|
|||
struct channel_state; |
|||
struct sha256; |
|||
struct pubkey; |
|||
struct peer; |
|||
|
|||
u8 *wscript_for_htlc(const tal_t *ctx, |
|||
const struct peer *peer, |
|||
const struct htlc *h, |
|||
const struct sha256 *rhash, |
|||
enum side side); |
|||
|
|||
/* Returns scriptpubkey: *wscript is NULL if it's a direct p2wpkh. */ |
|||
u8 *commit_output_to_us(const tal_t *ctx, |
|||
const struct peer *peer, |
|||
const struct sha256 *rhash, |
|||
enum side side, |
|||
u8 **wscript); |
|||
|
|||
/* Returns scriptpubkey: *wscript is NULL if it's a direct p2wpkh. */ |
|||
u8 *commit_output_to_them(const tal_t *ctx, |
|||
const struct peer *peer, |
|||
const struct sha256 *rhash, |
|||
enum side side, |
|||
u8 **wscript); |
|||
|
|||
/* Create commitment tx to spend the anchor tx output; doesn't fill in
|
|||
* input scriptsig. */ |
|||
struct bitcoin_tx *create_commit_tx(const tal_t *ctx, |
|||
struct peer *peer, |
|||
const struct sha256 *rhash, |
|||
const struct channel_state *cstate, |
|||
enum side side, |
|||
bool *otherside_only); |
|||
#endif |
|||
@ -1,656 +0,0 @@ |
|||
#include "bitcoin/shadouble.h" |
|||
#include "bitcoin/signature.h" |
|||
#include "cryptopkt.h" |
|||
#include "lightning.pb-c.h" |
|||
#include "lightningd.h" |
|||
#include "log.h" |
|||
#include "names.h" |
|||
#include "peer.h" |
|||
#include "peer_internal.h" |
|||
#include "protobuf_convert.h" |
|||
#include "secrets.h" |
|||
#include "utils.h" |
|||
#include <ccan/build_assert/build_assert.h> |
|||
#include <ccan/crypto/sha256/sha256.h> |
|||
#include <ccan/endian/endian.h> |
|||
#include <ccan/mem/mem.h> |
|||
#include <ccan/short_types/short_types.h> |
|||
#include <ccan/structeq/structeq.h> |
|||
#include <inttypes.h> |
|||
#include <secp256k1.h> |
|||
#include <secp256k1_ecdh.h> |
|||
#include <sodium/crypto_aead_chacha20poly1305.h> |
|||
#include <sodium/randombytes.h> |
|||
|
|||
#define MAX_PKT_LEN (1024 * 1024) |
|||
|
|||
/* FIXME-OLD#1:
|
|||
`length` is a 4-byte little-endian field indicating the size of the unencrypted body. |
|||
*/ |
|||
|
|||
struct crypto_pkt { |
|||
le32 length; |
|||
u8 auth_tag[crypto_aead_chacha20poly1305_ABYTES]; |
|||
|
|||
/* ... contents... */ |
|||
u8 data[]; |
|||
}; |
|||
|
|||
/* Temporary structure for negotiation */ |
|||
struct key_negotiate { |
|||
struct lightningd_state *dstate; |
|||
|
|||
/* Our session secret key. */ |
|||
u8 seckey[32]; |
|||
|
|||
/* Our pubkey, their pubkey. */ |
|||
le32 keylen; |
|||
u8 our_sessionpubkey[33], their_sessionpubkey[33]; |
|||
|
|||
/* After DH key exchange, we create io_data to check auth. */ |
|||
struct io_data *iod; |
|||
|
|||
/* Logging structure we're using. */ |
|||
struct log *log; |
|||
|
|||
/* Did we expect a particular ID? */ |
|||
const struct pubkey *expected_id; |
|||
|
|||
/* Callback once it's all done. */ |
|||
struct io_plan *(*cb)(struct io_conn *conn, |
|||
struct lightningd_state *dstate, |
|||
struct io_data *iod, |
|||
struct log *log, |
|||
const struct pubkey *id, |
|||
void *arg); |
|||
void *arg; |
|||
}; |
|||
|
|||
struct enckey { |
|||
struct sha256 k; |
|||
}; |
|||
|
|||
|
|||
/* FIXME-OLD #1:
|
|||
* * sending-key: SHA256(shared-secret || sending-node-session-pubkey) |
|||
* * receiving-key: SHA256(shared-secret || receiving-node-session-pubkey) |
|||
*/ |
|||
static struct enckey enckey_from_secret(const unsigned char secret[32], |
|||
const unsigned char serial_pubkey[33]) |
|||
{ |
|||
struct sha256_ctx ctx; |
|||
struct enckey enckey; |
|||
|
|||
sha256_init(&ctx); |
|||
sha256_update(&ctx, memcheck(secret, 32), 32); |
|||
sha256_update(&ctx, memcheck(serial_pubkey, 33), 33); |
|||
sha256_done(&ctx, &enckey.k); |
|||
|
|||
return enckey; |
|||
} |
|||
|
|||
struct dir_state { |
|||
u64 nonce; |
|||
struct enckey enckey; |
|||
|
|||
/* Current packet (encrypted). */ |
|||
struct crypto_pkt *cpkt; |
|||
size_t pkt_len; |
|||
}; |
|||
|
|||
static void setup_crypto(struct dir_state *dir, |
|||
u8 shared_secret[32], u8 serial_pubkey[33]) |
|||
{ |
|||
/* FIXME-OLD #1: Nonces...MUST begin at 0 */ |
|||
dir->nonce = 0; |
|||
|
|||
dir->enckey = enckey_from_secret(shared_secret, serial_pubkey); |
|||
|
|||
dir->cpkt = NULL; |
|||
} |
|||
|
|||
struct io_data { |
|||
/* Stuff we need to keep around to talk to peer. */ |
|||
struct dir_state in, out; |
|||
|
|||
/* Callback once packet decrypted. */ |
|||
struct io_plan *(*cb)(struct io_conn *, struct peer *); |
|||
|
|||
/* Once peer is assigned, this is set. */ |
|||
struct peer *peer; |
|||
|
|||
/* Length we're currently reading. */ |
|||
struct crypto_pkt hdr_in; |
|||
}; |
|||
|
|||
static void *proto_tal_alloc(void *allocator_data, size_t size) |
|||
{ |
|||
return tal_arr(allocator_data, char, size); |
|||
} |
|||
|
|||
static void proto_tal_free(void *allocator_data, void *pointer) |
|||
{ |
|||
tal_free(pointer); |
|||
} |
|||
|
|||
static void le64_nonce(unsigned char *npub, u64 nonce) |
|||
{ |
|||
/* FIXME-OLD #1: Nonces are 64-bit little-endian numbers */ |
|||
le64 le_nonce = cpu_to_le64(nonce); |
|||
memcpy(npub, &le_nonce, sizeof(le_nonce)); |
|||
BUILD_ASSERT(crypto_aead_chacha20poly1305_NPUBBYTES == sizeof(le_nonce)); |
|||
} |
|||
|
|||
/* Encrypts data..data + len - 1 inclusive into data..data + len - 1 and
|
|||
* then writes the authentication tag at data+len. |
|||
* |
|||
* This increments nonce every time. |
|||
*/ |
|||
static void encrypt_in_place(void *data, size_t len, |
|||
u64 *nonce, const struct enckey *enckey) |
|||
{ |
|||
int ret; |
|||
unsigned long long clen; |
|||
unsigned char npub[crypto_aead_chacha20poly1305_NPUBBYTES]; |
|||
|
|||
le64_nonce(npub, *nonce); |
|||
ret = crypto_aead_chacha20poly1305_encrypt(data, &clen, |
|||
memcheck(data, len), len, |
|||
NULL, 0, NULL, |
|||
npub, enckey->k.u.u8); |
|||
assert(ret == 0); |
|||
assert(clen == len + crypto_aead_chacha20poly1305_ABYTES); |
|||
(*nonce)++; |
|||
} |
|||
|
|||
/* Checks authentication tag at data+len, then
|
|||
* decrypts data..data + len - 1 inclusive into data..data + len - 1. |
|||
* |
|||
* This increments nonce every time. |
|||
*/ |
|||
static bool decrypt_in_place(void *data, size_t len, |
|||
u64 *nonce, const struct enckey *enckey) |
|||
{ |
|||
int ret; |
|||
unsigned long long mlen; |
|||
unsigned char npub[crypto_aead_chacha20poly1305_NPUBBYTES]; |
|||
|
|||
le64_nonce(npub, *nonce); |
|||
mlen = len + crypto_aead_chacha20poly1305_ABYTES; |
|||
|
|||
ret = crypto_aead_chacha20poly1305_decrypt(data, &mlen, NULL, |
|||
memcheck(data, mlen), mlen, |
|||
NULL, 0, |
|||
npub, enckey->k.u.u8); |
|||
if (ret == 0) { |
|||
assert(mlen == len); |
|||
(*nonce)++; |
|||
return true; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
static Pkt *decrypt_body(const tal_t *ctx, struct io_data *iod, struct log *log) |
|||
{ |
|||
struct ProtobufCAllocator prototal; |
|||
Pkt *ret; |
|||
size_t data_len = le32_to_cpu(iod->hdr_in.length); |
|||
|
|||
if (!decrypt_in_place(iod->in.cpkt->data, data_len, |
|||
&iod->in.nonce, &iod->in.enckey)) { |
|||
/* Free encrypted packet. */ |
|||
iod->in.cpkt = tal_free(iod->in.cpkt); |
|||
log_unusual(log, "Body decryption failed"); |
|||
return NULL; |
|||
} |
|||
|
|||
/* De-protobuf it. */ |
|||
prototal.alloc = proto_tal_alloc; |
|||
prototal.free = proto_tal_free; |
|||
prototal.allocator_data = tal(ctx, char); |
|||
|
|||
ret = pkt__unpack(&prototal, data_len, iod->in.cpkt->data); |
|||
if (!ret) { |
|||
log_unusual(log, "Packet failed to unpack!"); |
|||
tal_free(prototal.allocator_data); |
|||
} else { |
|||
/* Make sure packet owns contents */ |
|||
tal_steal(ctx, ret); |
|||
tal_steal(ret, prototal.allocator_data); |
|||
|
|||
log_debug(log, "Received packet LEN=%zu, type=%s", |
|||
data_len, |
|||
ret->pkt_case == PKT__PKT_AUTH ? "PKT_AUTH" |
|||
: pkt_name(ret->pkt_case)); |
|||
} |
|||
|
|||
/* Free encrypted packet. */ |
|||
iod->in.cpkt = tal_free(iod->in.cpkt); |
|||
|
|||
return ret; |
|||
} |
|||
|
|||
static struct crypto_pkt *encrypt_pkt(struct io_data *iod, const Pkt *pkt, |
|||
size_t *totlen) |
|||
{ |
|||
struct crypto_pkt *cpkt; |
|||
size_t len; |
|||
|
|||
len = pkt__get_packed_size(pkt); |
|||
*totlen = sizeof(*cpkt) + len + crypto_aead_chacha20poly1305_ABYTES; |
|||
|
|||
cpkt = (struct crypto_pkt *)tal_arr(iod, char, *totlen); |
|||
cpkt->length = cpu_to_le32(len); |
|||
|
|||
/* Encrypt header. */ |
|||
encrypt_in_place(cpkt, sizeof(cpkt->length), |
|||
&iod->out.nonce, &iod->out.enckey); |
|||
|
|||
/* Encrypt body. */ |
|||
pkt__pack(pkt, cpkt->data); |
|||
encrypt_in_place(cpkt->data, len, &iod->out.nonce, &iod->out.enckey); |
|||
|
|||
return cpkt; |
|||
} |
|||
|
|||
static struct io_plan *recv_body(struct io_conn *conn, struct peer *peer) |
|||
{ |
|||
struct io_data *iod = peer->io_data; |
|||
|
|||
assert(!peer->inpkt); |
|||
|
|||
/* We have full packet. */ |
|||
peer->inpkt = decrypt_body(iod, iod, peer->log); |
|||
if (!peer->inpkt) |
|||
return io_close(conn); |
|||
|
|||
return iod->cb(conn, peer); |
|||
} |
|||
|
|||
static bool decrypt_header(struct log *log, struct io_data *iod, |
|||
size_t *body_len) |
|||
{ |
|||
/* We have length: Check it. */ |
|||
if (!decrypt_in_place(&iod->hdr_in.length, sizeof(iod->hdr_in.length), |
|||
&iod->in.nonce, &iod->in.enckey)) { |
|||
log_unusual(log, "Header decryption failed"); |
|||
return false; |
|||
} |
|||
log_debug(log, "Decrypted header len %u", |
|||
le32_to_cpu(iod->hdr_in.length)); |
|||
|
|||
/* FIXME-OLD #1: `length` MUST NOT exceed 1MB (1048576 bytes). */ |
|||
if (le32_to_cpu(iod->hdr_in.length) > MAX_PKT_LEN) { |
|||
log_unusual(log, |
|||
"Packet overlength: %"PRIu64, |
|||
le64_to_cpu(iod->hdr_in.length)); |
|||
return false; |
|||
} |
|||
|
|||
/* Allocate room for body, copy header. */ |
|||
*body_len = le32_to_cpu(iod->hdr_in.length) |
|||
+ crypto_aead_chacha20poly1305_ABYTES; |
|||
|
|||
iod->in.cpkt = (struct crypto_pkt *) |
|||
tal_arr(iod, char, sizeof(iod->hdr_in) + *body_len); |
|||
*iod->in.cpkt = iod->hdr_in; |
|||
return true; |
|||
} |
|||
|
|||
static struct io_plan *recv_header(struct io_conn *conn, struct peer *peer) |
|||
{ |
|||
struct io_data *iod = peer->io_data; |
|||
size_t body_len; |
|||
|
|||
if (!decrypt_header(peer->log, iod, &body_len)) |
|||
return io_close(conn); |
|||
|
|||
return io_read(conn, iod->in.cpkt->data, body_len, recv_body, peer); |
|||
} |
|||
|
|||
struct io_plan *peer_read_packet(struct io_conn *conn, |
|||
struct peer *peer, |
|||
struct io_plan *(*cb)(struct io_conn *, |
|||
struct peer *)) |
|||
{ |
|||
struct io_data *iod = peer->io_data; |
|||
|
|||
iod->cb = cb; |
|||
return io_read(conn, &iod->hdr_in, sizeof(iod->hdr_in), |
|||
recv_header, peer); |
|||
} |
|||
|
|||
/* Caller must free data! */ |
|||
struct io_plan *peer_write_packet(struct io_conn *conn, |
|||
struct peer *peer, |
|||
const Pkt *pkt, |
|||
struct io_plan *(*next)(struct io_conn *, |
|||
struct peer *)) |
|||
{ |
|||
struct io_data *iod = peer->io_data; |
|||
size_t totlen; |
|||
|
|||
/* We free previous packet here, rather than doing indirection
|
|||
* via io_write */ |
|||
tal_free(iod->out.cpkt); |
|||
|
|||
iod->out.cpkt = encrypt_pkt(iod, pkt, &totlen); |
|||
/* Free unencrypted packet. */ |
|||
tal_free(pkt); |
|||
|
|||
return io_write(conn, iod->out.cpkt, totlen, next, peer); |
|||
} |
|||
|
|||
static void *pkt_unwrap(Pkt *inpkt, struct log *log, Pkt__PktCase which) |
|||
{ |
|||
size_t i; |
|||
const ProtobufCMessage *base; |
|||
|
|||
if (inpkt->pkt_case != which) { |
|||
log_unusual(log, "Expected %u, got %u", |
|||
which, inpkt->pkt_case); |
|||
return NULL; |
|||
} |
|||
|
|||
/* It's a union, and each member starts with base. Pick one */ |
|||
base = &inpkt->error->base; |
|||
|
|||
/* Look for unknown fields. Remember, "It's OK to be odd!" */ |
|||
for (i = 0; i < base->n_unknown_fields; i++) { |
|||
log_debug(log, "Unknown field in %u: %u", |
|||
which, base->unknown_fields[i].tag); |
|||
/* Odd is OK */ |
|||
if (base->unknown_fields[i].tag & 1) |
|||
continue; |
|||
log_unusual(log, "Unknown field %u in %u", |
|||
base->unknown_fields[i].tag, which); |
|||
return NULL; |
|||
} |
|||
return inpkt->error; |
|||
} |
|||
|
|||
static bool check_proof(struct key_negotiate *neg, struct log *log, |
|||
Pkt *inpkt, |
|||
const struct pubkey *expected_id, |
|||
struct pubkey *id) |
|||
{ |
|||
struct sha256_double sha; |
|||
secp256k1_ecdsa_signature sig; |
|||
Authenticate *auth; |
|||
|
|||
auth = pkt_unwrap(inpkt, log, PKT__PKT_AUTH); |
|||
if (!auth) |
|||
return false; |
|||
|
|||
/* FIXME-OLD #1:
|
|||
* |
|||
* The receiving node MUST check that: |
|||
* |
|||
* 1. `node_id` is the expected value for the sending node. |
|||
*/ |
|||
if (!proto_to_pubkey(auth->node_id, id)) { |
|||
log_unusual(log, "Invalid auth id"); |
|||
return false; |
|||
} |
|||
|
|||
if (expected_id && !structeq(id, expected_id)) { |
|||
log_unusual(log, "Incorrect auth id"); |
|||
return false; |
|||
} |
|||
|
|||
/* FIXME-OLD #1:
|
|||
* |
|||
* 2. `session_sig` is a valid secp256k1 ECDSA signature encoded as |
|||
* a 32-byte big endian R value, followed by a 32-byte big |
|||
* endian S value. |
|||
*/ |
|||
if (!proto_to_signature(auth->session_sig, &sig)) { |
|||
log_unusual(log, "Invalid auth signature"); |
|||
return false; |
|||
} |
|||
|
|||
|
|||
/* FIXME-OLD #1:
|
|||
* |
|||
* 3. `session_sig` is the signature of the SHA256 of SHA256 of the |
|||
* its own sessionpubkey, using the secret key corresponding to |
|||
* the sender's `node_id`. |
|||
*/ |
|||
sha256_double(&sha, neg->our_sessionpubkey, |
|||
sizeof(neg->our_sessionpubkey)); |
|||
|
|||
if (!check_signed_hash(&sha, &sig, id)) { |
|||
log_unusual(log, "Bad auth signature"); |
|||
return false; |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
|
|||
static struct io_plan *recv_body_negotiate(struct io_conn *conn, |
|||
struct key_negotiate *neg) |
|||
{ |
|||
struct io_data *iod = neg->iod; |
|||
struct io_plan *plan; |
|||
Pkt *pkt; |
|||
struct pubkey id; |
|||
|
|||
/* We have full packet. */ |
|||
pkt = decrypt_body(neg, iod, neg->log); |
|||
if (!pkt) |
|||
return io_close(conn); |
|||
|
|||
if (!check_proof(neg, neg->log, pkt, neg->expected_id, &id)) |
|||
return io_close(conn); |
|||
|
|||
/* Steal so that the callback may not accidentally free it for us */ |
|||
tal_steal(NULL, neg); |
|||
|
|||
plan = neg->cb(conn, neg->dstate, neg->iod, neg->log, &id, neg->arg); |
|||
tal_free(neg); |
|||
return plan; |
|||
} |
|||
|
|||
static struct io_plan *recv_header_negotiate(struct io_conn *conn, |
|||
struct key_negotiate *neg) |
|||
{ |
|||
size_t body_len; |
|||
struct io_data *iod = neg->iod; |
|||
|
|||
if (!decrypt_header(neg->log, iod, &body_len)) |
|||
return io_close(conn); |
|||
|
|||
return io_read(conn, iod->in.cpkt->data, body_len, recv_body_negotiate, |
|||
neg); |
|||
} |
|||
|
|||
static struct io_plan *receive_proof(struct io_conn *conn, |
|||
struct key_negotiate *neg) |
|||
{ |
|||
return io_read(conn, &neg->iod->hdr_in, sizeof(neg->iod->hdr_in), |
|||
recv_header_negotiate, neg); |
|||
} |
|||
|
|||
/* Steals w onto the returned Pkt */ |
|||
static Pkt *pkt_wrap(const tal_t *ctx, void *w, Pkt__PktCase pkt_case) |
|||
{ |
|||
Pkt *pkt = tal(ctx, Pkt); |
|||
pkt__init(pkt); |
|||
pkt->pkt_case = pkt_case; |
|||
/* Union, so any will do */ |
|||
pkt->error = tal_steal(pkt, w); |
|||
return pkt; |
|||
} |
|||
|
|||
static Pkt *authenticate_pkt(const tal_t *ctx, |
|||
const struct pubkey *node_id, |
|||
const secp256k1_ecdsa_signature *sig) |
|||
{ |
|||
Authenticate *auth = tal(ctx, Authenticate); |
|||
authenticate__init(auth); |
|||
auth->node_id = pubkey_to_proto(auth, node_id); |
|||
auth->session_sig = signature_to_proto(auth, sig); |
|||
return pkt_wrap(ctx, auth, PKT__PKT_AUTH); |
|||
} |
|||
|
|||
static struct io_plan *keys_exchanged(struct io_conn *conn, |
|||
struct key_negotiate *neg) |
|||
{ |
|||
u8 shared_secret[32]; |
|||
struct pubkey sessionkey; |
|||
secp256k1_ecdsa_signature sig; |
|||
Pkt *auth; |
|||
size_t totlen; |
|||
|
|||
if (!pubkey_from_der(neg->their_sessionpubkey, |
|||
sizeof(neg->their_sessionpubkey), |
|||
&sessionkey)) { |
|||
log_unusual_blob(neg->log, "Bad sessionkey %s", |
|||
neg->their_sessionpubkey, |
|||
sizeof(neg->their_sessionpubkey)); |
|||
return io_close(conn); |
|||
} |
|||
|
|||
/* Derive shared secret. */ |
|||
if (!secp256k1_ecdh(secp256k1_ctx, shared_secret, |
|||
&sessionkey.pubkey, neg->seckey)) { |
|||
log_unusual(neg->log, "Bad ECDH"); |
|||
return io_close(conn); |
|||
} |
|||
|
|||
/* Each side combines with their OWN session key to SENDING crypto. */ |
|||
neg->iod = tal(neg, struct io_data); |
|||
setup_crypto(&neg->iod->in, shared_secret, neg->their_sessionpubkey); |
|||
setup_crypto(&neg->iod->out, shared_secret, neg->our_sessionpubkey); |
|||
|
|||
/* FIXME-OLD #1:
|
|||
* |
|||
* `session_sig` is the signature of the SHA256 of SHA256 of the its |
|||
* own sessionpubkey, using the secret key corresponding to the |
|||
* sender's `node_id`. |
|||
*/ |
|||
privkey_sign(neg->dstate, neg->their_sessionpubkey, |
|||
sizeof(neg->their_sessionpubkey), &sig); |
|||
|
|||
auth = authenticate_pkt(neg, &neg->dstate->id, &sig); |
|||
|
|||
neg->iod->out.cpkt = encrypt_pkt(neg->iod, auth, &totlen); |
|||
return io_write(conn, neg->iod->out.cpkt, totlen, receive_proof, neg); |
|||
} |
|||
|
|||
/* Read and ignore any extra bytes... */ |
|||
static struct io_plan *discard_extra(struct io_conn *conn, |
|||
struct key_negotiate *neg) |
|||
{ |
|||
size_t len = le32_to_cpu(neg->keylen); |
|||
|
|||
/* FIXME-OLD#1: Additional fields MAY be added, and MUST be
|
|||
* included in the `length` field. These MUST be ignored by |
|||
* implementations which do not understand them. */ |
|||
if (len > sizeof(neg->their_sessionpubkey)) { |
|||
char *discard; |
|||
|
|||
len -= sizeof(neg->their_sessionpubkey); |
|||
discard = tal_arr(neg, char, len); |
|||
log_unusual(neg->log, |
|||
"Ignoring %zu extra handshake bytes", |
|||
len); |
|||
return io_read(conn, discard, len, keys_exchanged, neg); |
|||
} |
|||
|
|||
return keys_exchanged(conn, neg); |
|||
} |
|||
|
|||
static struct io_plan *session_key_receive(struct io_conn *conn, |
|||
struct key_negotiate *neg) |
|||
{ |
|||
/* FIXME-OLD#1: The `length` field is the length after the field
|
|||
itself, and MUST be 33 or greater. */ |
|||
if (le32_to_cpu(neg->keylen) < sizeof(neg->their_sessionpubkey)) { |
|||
log_unusual(neg->log, "short session key length %u", |
|||
le32_to_cpu(neg->keylen)); |
|||
return io_close(conn); |
|||
} |
|||
|
|||
/* FIXME-OLD#1: `length` MUST NOT exceed 1MB (1048576 bytes). */ |
|||
if (le32_to_cpu(neg->keylen) > 1048576) { |
|||
log_unusual(neg->log, |
|||
"Oversize session key length %u", |
|||
le32_to_cpu(neg->keylen)); |
|||
return io_close(conn); |
|||
} |
|||
|
|||
log_debug(neg->log, "Session key length %u", le32_to_cpu(neg->keylen)); |
|||
|
|||
/* Now read their key. */ |
|||
return io_read(conn, neg->their_sessionpubkey, |
|||
sizeof(neg->their_sessionpubkey), discard_extra, neg); |
|||
} |
|||
|
|||
static struct io_plan *session_key_len_receive(struct io_conn *conn, |
|||
struct key_negotiate *neg) |
|||
{ |
|||
/* Read the amount of data they will send.. */ |
|||
return io_read(conn, &neg->keylen, sizeof(neg->keylen), |
|||
session_key_receive, neg); |
|||
} |
|||
|
|||
static void gen_sessionkey(u8 seckey[32], |
|||
secp256k1_pubkey *pubkey) |
|||
{ |
|||
do { |
|||
randombytes_buf(seckey, 32); |
|||
} while (!secp256k1_ec_pubkey_create(secp256k1_ctx, pubkey, seckey)); |
|||
} |
|||
|
|||
static struct io_plan *write_sessionkey(struct io_conn *conn, |
|||
struct key_negotiate *neg) |
|||
{ |
|||
return io_write(conn, neg->our_sessionpubkey, |
|||
sizeof(neg->our_sessionpubkey), |
|||
session_key_len_receive, neg); |
|||
} |
|||
|
|||
struct io_plan *peer_crypto_setup_(struct io_conn *conn, |
|||
struct lightningd_state *dstate, |
|||
const struct pubkey *id, |
|||
struct log *log, |
|||
struct io_plan *(*cb)(struct io_conn *conn, |
|||
struct lightningd_state *dstate, |
|||
struct io_data *iod, |
|||
struct log *log, |
|||
const struct pubkey *id, |
|||
void *arg), |
|||
void *arg) |
|||
{ |
|||
size_t outputlen; |
|||
secp256k1_pubkey sessionkey; |
|||
struct key_negotiate *neg; |
|||
|
|||
/* FIXME-OLD #1:
|
|||
* |
|||
* The 4-byte length for each message is encrypted separately |
|||
* (resulting in a 20 byte header when the authentication tag |
|||
* is appended) */ |
|||
BUILD_ASSERT(sizeof(struct crypto_pkt) == 20); |
|||
|
|||
/* We store negotiation state here. */ |
|||
neg = tal(conn, struct key_negotiate); |
|||
neg->cb = cb; |
|||
neg->arg = arg; |
|||
neg->dstate = dstate; |
|||
neg->expected_id = id; |
|||
neg->log = log; |
|||
|
|||
gen_sessionkey(neg->seckey, &sessionkey); |
|||
|
|||
outputlen = sizeof(neg->our_sessionpubkey); |
|||
secp256k1_ec_pubkey_serialize(secp256k1_ctx, |
|||
neg->our_sessionpubkey, &outputlen, |
|||
&sessionkey, |
|||
SECP256K1_EC_COMPRESSED); |
|||
assert(outputlen == sizeof(neg->our_sessionpubkey)); |
|||
neg->keylen = cpu_to_le32(sizeof(neg->our_sessionpubkey)); |
|||
return io_write(conn, &neg->keylen, sizeof(neg->keylen), |
|||
write_sessionkey, neg); |
|||
} |
|||
@ -1,48 +0,0 @@ |
|||
#ifndef LIGHTNING_DAEMON_CRYPTOPKT_H |
|||
#define LIGHTNING_DAEMON_CRYPTOPKT_H |
|||
#include "config.h" |
|||
#include "lightning.pb-c.h" |
|||
#include <ccan/io/io.h> |
|||
#include <ccan/typesafe_cb/typesafe_cb.h> |
|||
|
|||
struct io_data; |
|||
struct json_connecting; |
|||
struct lightningd_state; |
|||
struct log; |
|||
struct peer; |
|||
|
|||
struct io_plan *peer_crypto_setup_(struct io_conn *conn, |
|||
struct lightningd_state *dstate, |
|||
const struct pubkey *id, |
|||
struct log *log, |
|||
struct io_plan *(*cb)(struct io_conn *conn, |
|||
struct lightningd_state *dstate, |
|||
struct io_data *iod, |
|||
struct log *log, |
|||
const struct pubkey *id, |
|||
void *arg), |
|||
void *arg); |
|||
|
|||
#define peer_crypto_setup(conn, dstate, id, log_, cb, arg) \ |
|||
peer_crypto_setup_((conn), (dstate), (id), (log_), \ |
|||
typesafe_cb_preargs(struct io_plan *, void *, \ |
|||
(cb), (arg), \ |
|||
struct io_conn *, \ |
|||
struct lightningd_state *, \ |
|||
struct io_data *, \ |
|||
struct log *, \ |
|||
const struct pubkey *), \ |
|||
(arg)) |
|||
|
|||
/* Reads packet into peer->inpkt/peer->inpkt_len */ |
|||
struct io_plan *peer_read_packet(struct io_conn *conn, |
|||
struct peer *peer, |
|||
struct io_plan *(*cb)(struct io_conn *, |
|||
struct peer *)); |
|||
|
|||
struct io_plan *peer_write_packet(struct io_conn *conn, |
|||
struct peer *peer, |
|||
const Pkt *pkt, |
|||
struct io_plan *(*next)(struct io_conn *, |
|||
struct peer *)); |
|||
#endif /* LIGHTNING_DAEMON_CRYPTOPKT_H */ |
|||
File diff suppressed because it is too large
@ -1,76 +0,0 @@ |
|||
#ifndef LIGHTNING_DAEMON_DB_H |
|||
#define LIGHTNING_DAEMON_DB_H |
|||
#include "config.h" |
|||
#include "peer.h" |
|||
#include <stdbool.h> |
|||
|
|||
void db_init(struct lightningd_state *dstate); |
|||
|
|||
void db_start_transaction(struct peer *peer); |
|||
void db_abort_transaction(struct peer *peer); |
|||
const char *db_commit_transaction(struct peer *peer); |
|||
|
|||
void db_add_wallet_privkey(struct lightningd_state *dstate, |
|||
const struct privkey *privkey); |
|||
|
|||
bool db_add_peer_address(struct lightningd_state *dstate, |
|||
const struct peer_address *addr); |
|||
|
|||
/* Must NOT be inside transaction. */ |
|||
bool db_update_their_closing(struct peer *peer); |
|||
bool db_new_pay_command(struct lightningd_state *dstate, |
|||
const struct sha256 *rhash, |
|||
const struct pubkey *ids, |
|||
u64 msatoshi, |
|||
const struct htlc *htlc); |
|||
bool db_replace_pay_command(struct lightningd_state *dstate, |
|||
const struct sha256 *rhash, |
|||
const struct pubkey *ids, |
|||
u64 msatoshi, |
|||
const struct htlc *htlc); |
|||
bool db_new_invoice(struct lightningd_state *dstate, |
|||
u64 msatoshi, |
|||
const char *label, |
|||
const struct preimage *r); |
|||
|
|||
bool db_remove_invoice(struct lightningd_state *dstate, |
|||
const char *label); |
|||
|
|||
/* FIXME: save error handling until db_commit_transaction for calls
|
|||
* which have to be inside transaction anyway. */ |
|||
|
|||
/* Must be inside transaction. */ |
|||
void db_create_peer(struct peer *peer); |
|||
void db_set_visible_state(struct peer *peer); |
|||
void db_set_anchor(struct peer *peer); |
|||
void db_new_htlc(struct peer *peer, const struct htlc *htlc); |
|||
void db_new_feechange(struct peer *peer, const struct feechange *feechange); |
|||
void db_htlc_fulfilled(struct peer *peer, const struct htlc *htlc); |
|||
void db_htlc_failed(struct peer *peer, const struct htlc *htlc); |
|||
void db_update_htlc_state(struct peer *peer, const struct htlc *htlc, |
|||
enum htlc_state oldstate); |
|||
void db_complete_pay_command(struct lightningd_state *dstate, |
|||
const struct htlc *htlc); |
|||
void db_resolve_invoice(struct lightningd_state *dstate, |
|||
const char *label, u64 paid_num); |
|||
void db_update_feechange_state(struct peer *peer, |
|||
const struct feechange *f, |
|||
enum feechange_state oldstate); |
|||
void db_remove_feechange(struct peer *peer, const struct feechange *feechange, |
|||
enum feechange_state oldstate); |
|||
void db_new_commit_info(struct peer *peer, enum side side, |
|||
const struct sha256 *prev_rhash); |
|||
void db_remove_their_prev_revocation_hash(struct peer *peer); |
|||
void db_update_next_revocation_hash(struct peer *peer); |
|||
void db_save_shachain(struct peer *peer); |
|||
void db_update_state(struct peer *peer); |
|||
void db_begin_shutdown(struct peer *peer); |
|||
void db_set_our_closing_script(struct peer *peer); |
|||
void db_update_our_closing(struct peer *peer); |
|||
void db_set_their_closing_script(struct peer *peer); |
|||
|
|||
void db_add_commit_map(struct peer *peer, |
|||
const struct sha256_double *txid, u64 commit_num); |
|||
|
|||
void db_forget_peer(struct peer *peer); |
|||
#endif /* LIGHTNING_DAEMON_DB_H */ |
|||
@ -1,40 +0,0 @@ |
|||
#include "failure.h" |
|||
#include "protobuf_convert.h" |
|||
#include <ccan/tal/str/str.h> |
|||
|
|||
/* FIXME: Crypto! */ |
|||
const u8 *failinfo_create(const tal_t *ctx, |
|||
const struct pubkey *id, |
|||
u32 error_code, |
|||
const char *reason) |
|||
{ |
|||
FailInfo *f = tal(ctx, FailInfo); |
|||
u8 *arr; |
|||
|
|||
fail_info__init(f); |
|||
f->id = pubkey_to_proto(f, id); |
|||
f->error_code = error_code; |
|||
if (reason) |
|||
f->reason = tal_strdup(f, reason); |
|||
else |
|||
f->reason = NULL; |
|||
|
|||
arr = tal_arr(ctx, u8, fail_info__get_packed_size(f)); |
|||
fail_info__pack(f, arr); |
|||
tal_free(f); |
|||
return arr; |
|||
} |
|||
|
|||
FailInfo *failinfo_unwrap(const tal_t *ctx, const void *data, size_t len) |
|||
{ |
|||
struct ProtobufCAllocator *prototal = make_prototal(ctx); |
|||
FailInfo *f; |
|||
|
|||
f = fail_info__unpack(prototal, len, data); |
|||
if (f) |
|||
steal_from_prototal(ctx, prototal, f); |
|||
else |
|||
tal_free(prototal); |
|||
|
|||
return f; |
|||
} |
|||
@ -1,36 +0,0 @@ |
|||
#ifndef LIGHTNING_DAEMON_FAILURE_H |
|||
#define LIGHTNING_DAEMON_FAILURE_H |
|||
#include "config.h" |
|||
#include "lightning.pb-c.h" |
|||
#include <ccan/short_types/short_types.h> |
|||
#include <ccan/tal/tal.h> |
|||
#include <secp256k1.h> |
|||
|
|||
struct pubkey; |
|||
|
|||
enum fail_error { |
|||
BAD_REQUEST_400 = 400, |
|||
UNAUTHORIZED_401 = 401, |
|||
PAYMENT_REQUIRED_402 = 402, |
|||
FORBIDDEN_403 = 403, |
|||
NOT_FOUND_404 = 404, |
|||
METHOD_NOT_ALLOWED_405 = 405, |
|||
REQUEST_TIMEOUT_408 = 408, |
|||
GONE_410 = 410, |
|||
IM_A_TEAPOT_418 = 418, |
|||
INTERNAL_SERVER_ERROR_500 = 500, |
|||
NOT_IMPLEMENTED_501 = 501, |
|||
BAD_GATEWAY_502 = 502, |
|||
SERVICE_UNAVAILABLE_503 = 503, |
|||
GATEWAY_TIMEOUT_504 = 504, |
|||
VERSION_NOT_SUPPORTED_505 = 505 |
|||
}; |
|||
|
|||
const u8 *failinfo_create(const tal_t *ctx, |
|||
const struct pubkey *id, |
|||
enum fail_error error_code, |
|||
const char *reason); |
|||
|
|||
FailInfo *failinfo_unwrap(const tal_t *ctx, const void *data, size_t len); |
|||
|
|||
#endif /* LIGHTNING_DAEMON_FAILURE_H */ |
|||
@ -1,144 +0,0 @@ |
|||
#include "db.h" |
|||
#include "feechange.h" |
|||
#include "log.h" |
|||
#include "peer.h" |
|||
#include "peer_internal.h" |
|||
#include <ccan/array_size/array_size.h> |
|||
#include <inttypes.h> |
|||
#include "gen_feechange_state_names.h" |
|||
|
|||
/* This is the HTLC-like flags for each state. */ |
|||
static const int per_state_bits[] = { |
|||
[SENT_FEECHANGE] = HTLC_ADDING + HTLC_LOCAL_F_OWNER |
|||
+ HTLC_REMOTE_F_PENDING, |
|||
|
|||
[SENT_FEECHANGE_COMMIT] = HTLC_ADDING + HTLC_LOCAL_F_OWNER |
|||
+ HTLC_REMOTE_F_COMMITTED |
|||
+ HTLC_REMOTE_F_WAS_COMMITTED, |
|||
|
|||
[RCVD_FEECHANGE_REVOCATION] = HTLC_ADDING + HTLC_LOCAL_F_OWNER |
|||
+ HTLC_REMOTE_F_COMMITTED |
|||
+ HTLC_REMOTE_F_REVOKED |
|||
+ HTLC_LOCAL_F_PENDING |
|||
+ HTLC_REMOTE_F_WAS_COMMITTED, |
|||
|
|||
[RCVD_FEECHANGE_ACK_COMMIT] = HTLC_ADDING + HTLC_LOCAL_F_OWNER |
|||
+ HTLC_REMOTE_F_COMMITTED |
|||
+ HTLC_REMOTE_F_REVOKED |
|||
+ HTLC_LOCAL_F_COMMITTED |
|||
+ HTLC_LOCAL_F_WAS_COMMITTED |
|||
+ HTLC_REMOTE_F_WAS_COMMITTED, |
|||
|
|||
[SENT_FEECHANGE_ACK_REVOCATION] = HTLC_LOCAL_F_OWNER |
|||
+ HTLC_REMOTE_F_COMMITTED |
|||
+ HTLC_REMOTE_F_REVOKED |
|||
+ HTLC_LOCAL_F_COMMITTED |
|||
+ HTLC_LOCAL_F_REVOKED |
|||
+ HTLC_LOCAL_F_WAS_COMMITTED |
|||
+ HTLC_REMOTE_F_WAS_COMMITTED, |
|||
|
|||
[RCVD_FEECHANGE] = HTLC_ADDING + HTLC_REMOTE_F_OWNER |
|||
+ HTLC_LOCAL_F_PENDING, |
|||
|
|||
[RCVD_FEECHANGE_COMMIT] = HTLC_ADDING + HTLC_REMOTE_F_OWNER |
|||
+ HTLC_LOCAL_F_COMMITTED |
|||
+ HTLC_LOCAL_F_WAS_COMMITTED, |
|||
|
|||
[SENT_FEECHANGE_REVOCATION] = HTLC_ADDING + HTLC_REMOTE_F_OWNER |
|||
+ HTLC_LOCAL_F_COMMITTED |
|||
+ HTLC_LOCAL_F_REVOKED |
|||
+ HTLC_REMOTE_F_PENDING |
|||
+ HTLC_LOCAL_F_WAS_COMMITTED, |
|||
|
|||
[SENT_FEECHANGE_ACK_COMMIT] = HTLC_ADDING + HTLC_REMOTE_F_OWNER |
|||
+ HTLC_LOCAL_F_COMMITTED |
|||
+ HTLC_LOCAL_F_REVOKED |
|||
+ HTLC_REMOTE_F_COMMITTED |
|||
+ HTLC_LOCAL_F_WAS_COMMITTED |
|||
+ HTLC_REMOTE_F_WAS_COMMITTED, |
|||
|
|||
[RCVD_FEECHANGE_ACK_REVOCATION] = HTLC_REMOTE_F_OWNER |
|||
+ HTLC_LOCAL_F_COMMITTED |
|||
+ HTLC_LOCAL_F_REVOKED |
|||
+ HTLC_REMOTE_F_COMMITTED |
|||
+ HTLC_REMOTE_F_REVOKED |
|||
+ HTLC_LOCAL_F_WAS_COMMITTED |
|||
+ HTLC_REMOTE_F_WAS_COMMITTED, |
|||
}; |
|||
|
|||
int feechange_state_flags(enum feechange_state state) |
|||
{ |
|||
assert(state < ARRAY_SIZE(per_state_bits)); |
|||
assert(per_state_bits[state]); |
|||
return per_state_bits[state]; |
|||
} |
|||
|
|||
const char *feechange_state_name(enum feechange_state s) |
|||
{ |
|||
size_t i; |
|||
|
|||
for (i = 0; enum_feechange_state_names[i].name; i++) |
|||
if (enum_feechange_state_names[i].v == s) |
|||
return enum_feechange_state_names[i].name; |
|||
return "unknown"; |
|||
} |
|||
|
|||
enum feechange_state feechange_state_from_name(const char *name) |
|||
{ |
|||
size_t i; |
|||
|
|||
for (i = 0; enum_feechange_state_names[i].name; i++) |
|||
if (streq(enum_feechange_state_names[i].name, name)) |
|||
return enum_feechange_state_names[i].v; |
|||
return FEECHANGE_STATE_INVALID; |
|||
} |
|||
|
|||
struct feechange *new_feechange(struct peer *peer, |
|||
u64 fee_rate, |
|||
enum feechange_state state) |
|||
{ |
|||
struct feechange *f = tal(peer, struct feechange); |
|||
f->state = state; |
|||
f->fee_rate = fee_rate; |
|||
|
|||
return f; |
|||
} |
|||
|
|||
void feechange_changestate(struct peer *peer, |
|||
struct feechange *f, |
|||
enum feechange_state oldstate, |
|||
enum feechange_state newstate, |
|||
bool db_commit) |
|||
{ |
|||
peer_debug(peer, "feechange: %s->%s", |
|||
feechange_state_name(f->state), |
|||
feechange_state_name(newstate)); |
|||
assert(f->state == oldstate); |
|||
assert(peer->feechanges[f->state] == f); |
|||
|
|||
/* You can only go to consecutive states. */ |
|||
assert(newstate == f->state + 1); |
|||
|
|||
/* You can't change sides. */ |
|||
assert(feechange_side(f->state) == feechange_side(newstate)); |
|||
|
|||
f->state = newstate; |
|||
|
|||
/* We can have multiple dead feestates, but only one in any other */ |
|||
if (!feechange_is_dead(f)) |
|||
assert(!peer->feechanges[f->state]); |
|||
|
|||
peer->feechanges[oldstate] = NULL; |
|||
peer->feechanges[newstate] = f; |
|||
|
|||
if (db_commit) { |
|||
if (newstate == RCVD_FEECHANGE_COMMIT |
|||
|| newstate == SENT_FEECHANGE_COMMIT) |
|||
db_new_feechange(peer, f); |
|||
else if (newstate == RCVD_FEECHANGE_ACK_REVOCATION |
|||
|| newstate == SENT_FEECHANGE_ACK_REVOCATION) |
|||
db_remove_feechange(peer, f, oldstate); |
|||
else |
|||
db_update_feechange_state(peer, f, oldstate); |
|||
} |
|||
} |
|||
@ -1,52 +0,0 @@ |
|||
#ifndef LIGHTNING_DAEMON_FEECHANGE_H |
|||
#define LIGHTNING_DAEMON_FEECHANGE_H |
|||
#include "config.h" |
|||
#include "channel.h" |
|||
#include "feechange_state.h" |
|||
|
|||
struct peer; |
|||
|
|||
struct feechange { |
|||
/* What's the status */ |
|||
enum feechange_state state; |
|||
/* The rate. */ |
|||
u64 fee_rate; |
|||
}; |
|||
|
|||
static inline enum side feechange_side(enum feechange_state state) |
|||
{ |
|||
if (state <= SENT_FEECHANGE_ACK_REVOCATION) { |
|||
return LOCAL; |
|||
} else { |
|||
assert(state < FEECHANGE_STATE_INVALID); |
|||
return REMOTE; |
|||
} |
|||
} |
|||
|
|||
void feechange_changestate(struct peer *peer, |
|||
struct feechange *feechange, |
|||
enum feechange_state oldstate, |
|||
enum feechange_state newstate, |
|||
bool db_commit); |
|||
|
|||
struct feechange *new_feechange(struct peer *peer, |
|||
u64 fee_rate, |
|||
enum feechange_state state); |
|||
|
|||
const char *feechange_state_name(enum feechange_state s); |
|||
enum feechange_state feechange_state_from_name(const char *name); |
|||
|
|||
/* HTLC-add-style bitflags for each feechange state */ |
|||
int feechange_state_flags(enum feechange_state state); |
|||
|
|||
static inline bool feechange_has(const struct feechange *f, int flag) |
|||
{ |
|||
return feechange_state_flags(f->state) & flag; |
|||
} |
|||
|
|||
static inline bool feechange_is_dead(const struct feechange *feechange) |
|||
{ |
|||
return feechange->state == SENT_FEECHANGE_ACK_REVOCATION |
|||
|| feechange->state == RCVD_FEECHANGE_ACK_REVOCATION; |
|||
} |
|||
#endif /* LIGHTNING_DAEMON_FEECHANGE_H */ |
|||
@ -1,23 +0,0 @@ |
|||
#ifndef LIGHTNING_DAEMON_FEECHANGE_STATE_H |
|||
#define LIGHTNING_DAEMON_FEECHANGE_STATE_H |
|||
#include "config.h" |
|||
|
|||
/* Like HTLCs, but only adding; we never "remove" a feechange. */ |
|||
enum feechange_state { |
|||
/* When we add a new feechange, it goes in this order. */ |
|||
SENT_FEECHANGE, |
|||
SENT_FEECHANGE_COMMIT, |
|||
RCVD_FEECHANGE_REVOCATION, |
|||
RCVD_FEECHANGE_ACK_COMMIT, |
|||
SENT_FEECHANGE_ACK_REVOCATION, |
|||
|
|||
/* When they add a new feechange, it goes in this order. */ |
|||
RCVD_FEECHANGE, |
|||
RCVD_FEECHANGE_COMMIT, |
|||
SENT_FEECHANGE_REVOCATION, |
|||
SENT_FEECHANGE_ACK_COMMIT, |
|||
RCVD_FEECHANGE_ACK_REVOCATION, |
|||
|
|||
FEECHANGE_STATE_INVALID |
|||
}; |
|||
#endif /* LIGHTNING_DAEMON_FEECHANGE_STATE_H */ |
|||
@ -1,81 +0,0 @@ |
|||
#include "db.h" |
|||
#include "htlc.h" |
|||
#include "log.h" |
|||
#include "peer.h" |
|||
#include "peer_internal.h" |
|||
#include "type_to_string.h" |
|||
#include <bitcoin/preimage.h> |
|||
#include <ccan/tal/str/str.h> |
|||
#include <inttypes.h> |
|||
|
|||
void htlc_changestate(struct htlc *h, |
|||
enum htlc_state oldstate, |
|||
enum htlc_state newstate, |
|||
bool db_commit) |
|||
{ |
|||
peer_debug(h->peer, "htlc %"PRIu64": %s->%s", h->id, |
|||
htlc_state_name(h->state), htlc_state_name(newstate)); |
|||
assert(h->state == oldstate); |
|||
|
|||
/* You can only go to consecutive states. */ |
|||
assert(newstate == h->state + 1); |
|||
|
|||
/* You can't change sides. */ |
|||
assert((htlc_state_flags(h->state)&(HTLC_LOCAL_F_OWNER|HTLC_REMOTE_F_OWNER)) |
|||
== (htlc_state_flags(newstate)&(HTLC_LOCAL_F_OWNER|HTLC_REMOTE_F_OWNER))); |
|||
|
|||
h->state = newstate; |
|||
|
|||
if (db_commit) { |
|||
if (newstate == RCVD_ADD_COMMIT || newstate == SENT_ADD_COMMIT) { |
|||
db_new_htlc(h->peer, h); |
|||
return; |
|||
} |
|||
/* These never hit the database. */ |
|||
if (oldstate == RCVD_REMOVE_HTLC) |
|||
oldstate = SENT_ADD_ACK_REVOCATION; |
|||
else if (oldstate == SENT_REMOVE_HTLC) |
|||
oldstate = RCVD_ADD_ACK_REVOCATION; |
|||
db_update_htlc_state(h->peer, h, oldstate); |
|||
} |
|||
} |
|||
|
|||
void htlc_undostate(struct htlc *h, |
|||
enum htlc_state oldstate, |
|||
enum htlc_state newstate) |
|||
{ |
|||
log_debug(h->peer->log, "htlc %"PRIu64": %s->%s", h->id, |
|||
htlc_state_name(h->state), htlc_state_name(newstate)); |
|||
assert(h->state == oldstate); |
|||
|
|||
/* You can only return to previous state. */ |
|||
assert(newstate == h->state - 1); |
|||
|
|||
/* And must only be proposal, not commit. */ |
|||
assert(h->state == SENT_REMOVE_HTLC || h->state == RCVD_REMOVE_HTLC); |
|||
|
|||
/* You can't change sides. */ |
|||
assert((htlc_state_flags(h->state)&(HTLC_LOCAL_F_OWNER|HTLC_REMOTE_F_OWNER)) |
|||
== (htlc_state_flags(newstate)&(HTLC_LOCAL_F_OWNER|HTLC_REMOTE_F_OWNER))); |
|||
|
|||
h->state = newstate; |
|||
} |
|||
|
|||
static char *fmt_htlc(const tal_t *ctx, const struct htlc *h) |
|||
{ |
|||
return tal_fmt(ctx, "{ id=%"PRIu64 |
|||
" msatoshi=%"PRIu64 |
|||
" expiry=%s" |
|||
" rhash=%s" |
|||
" rval=%s" |
|||
" src=%s }", |
|||
h->id, h->msatoshi, |
|||
type_to_string(ctx, struct abs_locktime, &h->expiry), |
|||
type_to_string(ctx, struct sha256, &h->rhash), |
|||
h->r ? tal_hexstr(ctx, h->r, sizeof(*h->r)) |
|||
: "UNKNOWN", |
|||
h->src ? type_to_string(ctx, struct pubkey, |
|||
h->src->peer->id) |
|||
: "local"); |
|||
} |
|||
REGISTER_TYPE_TO_STRING(htlc, fmt_htlc); |
|||
@ -1,280 +0,0 @@ |
|||
#include "bitcoin/privkey.h" |
|||
#include "bitcoin/signature.h" |
|||
#include "daemon/chaintopology.h" |
|||
#include "daemon/irc_announce.h" |
|||
#include "daemon/lightningd.h" |
|||
#include "daemon/log.h" |
|||
#include "daemon/peer.h" |
|||
#include "daemon/peer_internal.h" |
|||
#include "daemon/routing.h" |
|||
#include "daemon/secrets.h" |
|||
#include "daemon/timeout.h" |
|||
#include "utils.h" |
|||
|
|||
#include <ccan/list/list.h> |
|||
#include <ccan/str/hex/hex.h> |
|||
|
|||
/* Sign a privmsg by prepending the signature to the message */ |
|||
static void sign_privmsg(struct ircstate *state, struct privmsg *msg) |
|||
{ |
|||
int siglen; |
|||
u8 der[72]; |
|||
secp256k1_ecdsa_signature sig; |
|||
privkey_sign(state->dstate, msg->msg, strlen(msg->msg), &sig); |
|||
siglen = signature_to_der(der, &sig); |
|||
msg->msg = tal_fmt(msg, "%s %s", tal_hexstr(msg, der, siglen), msg->msg); |
|||
} |
|||
|
|||
static bool announce_channel(const tal_t *ctx, struct ircstate *state, struct peer *p) |
|||
{ |
|||
char txid[65]; |
|||
struct privmsg *msg = talz(ctx, struct privmsg); |
|||
struct txlocator *loc = locate_tx(ctx, state->dstate->topology, &p->anchor.txid); |
|||
|
|||
if (loc == NULL) |
|||
return false; |
|||
|
|||
bitcoin_txid_to_hex(&p->anchor.txid, txid, sizeof(txid)); |
|||
msg->channel = "#lightning-nodes"; |
|||
msg->msg = tal_fmt( |
|||
msg, "CHAN %s %s %s %d %d %d %d %d", |
|||
pubkey_to_hexstr(msg, &state->dstate->id), |
|||
pubkey_to_hexstr(msg, p->id), |
|||
txid, |
|||
loc->blkheight, |
|||
loc->index, |
|||
state->dstate->config.fee_base, |
|||
state->dstate->config.fee_per_satoshi, |
|||
state->dstate->config.min_htlc_expiry |
|||
); |
|||
sign_privmsg(state, msg); |
|||
irc_send_msg(state, msg); |
|||
return true; |
|||
} |
|||
|
|||
/* Send an announcement for this node to the channel, including its
|
|||
* hostname, port and ID */ |
|||
static void announce_node(const tal_t *ctx, struct ircstate *state) |
|||
{ |
|||
char *hostname = state->dstate->external_ip; |
|||
int port = state->dstate->portnum; |
|||
struct privmsg *msg = talz(ctx, struct privmsg); |
|||
|
|||
if (hostname == NULL) { |
|||
//FIXME: log that we don't know our IP yet.
|
|||
return; |
|||
} |
|||
|
|||
msg->channel = "#lightning-nodes"; |
|||
msg->msg = tal_fmt( |
|||
msg, "NODE %s %s %d", |
|||
pubkey_to_hexstr(msg, &state->dstate->id), |
|||
hostname, |
|||
port |
|||
); |
|||
|
|||
sign_privmsg(state, msg); |
|||
irc_send_msg(state, msg); |
|||
} |
|||
|
|||
/* Announce the node's contact information and all of its channels */ |
|||
static void announce(struct ircstate *state) |
|||
{ |
|||
|
|||
tal_t *ctx = tal(state, tal_t); |
|||
struct peer *p; |
|||
|
|||
announce_node(ctx, state); |
|||
|
|||
list_for_each(&state->dstate->peers, p, list) { |
|||
|
|||
if (!state_is_normal(p->state)) |
|||
continue; |
|||
announce_channel(ctx, state, p); |
|||
} |
|||
tal_free(ctx); |
|||
|
|||
/* By default we announce every 6 hours, otherwise when someone joins */ |
|||
log_debug(state->log, "Setting long announce time: 6 hours"); |
|||
state->dstate->announce = new_reltimer(&state->dstate->timers, state, |
|||
time_from_sec(3600 * 6), |
|||
announce, state); |
|||
} |
|||
|
|||
/* Reconnect to IRC server upon disconnection. */ |
|||
static void handle_irc_disconnect(struct ircstate *state) |
|||
{ |
|||
/* Stop announcing. */ |
|||
state->dstate->announce = tal_free(state->dstate->announce); |
|||
new_reltimer(&state->dstate->timers, state, state->reconnect_timeout, |
|||
irc_connect, state); |
|||
} |
|||
|
|||
/* Verify a signed privmsg */ |
|||
static bool verify_signed_privmsg( |
|||
struct ircstate *istate, |
|||
const struct pubkey *pk, |
|||
const struct privmsg *msg) |
|||
{ |
|||
secp256k1_ecdsa_signature sig; |
|||
struct sha256_double hash; |
|||
const char *m = msg->msg + 1; |
|||
int siglen = strchr(m, ' ') - m; |
|||
const char *content = m + siglen + 1; |
|||
u8 *der = tal_hexdata(msg, m, siglen); |
|||
|
|||
siglen = hex_data_size(siglen); |
|||
if (der == NULL) |
|||
return false; |
|||
|
|||
if (!signature_from_der(der, siglen, &sig)) |
|||
return false; |
|||
sha256_double(&hash, content, strlen(content)); |
|||
return check_signed_hash(&hash, &sig, pk); |
|||
} |
|||
|
|||
static void handle_irc_channel_announcement( |
|||
struct ircstate *istate, |
|||
const struct privmsg *msg, |
|||
char **splits) |
|||
{ |
|||
struct pubkey *pk1 = talz(msg, struct pubkey); |
|||
struct pubkey *pk2 = talz(msg, struct pubkey); |
|||
struct sha256_double *txid = talz(msg, struct sha256_double); |
|||
int index; |
|||
bool ok = true; |
|||
int blkheight; |
|||
|
|||
ok &= pubkey_from_hexstr(splits[1], strlen(splits[1]), pk1); |
|||
ok &= pubkey_from_hexstr(splits[2], strlen(splits[2]), pk2); |
|||
ok &= bitcoin_txid_from_hex(splits[3], strlen(splits[3]), txid); |
|||
blkheight = atoi(splits[4]); |
|||
index = atoi(splits[5]); |
|||
if (!ok || index < 0 || blkheight < 0) { |
|||
log_debug(istate->dstate->base_log, "Unable to parse channel announcent."); |
|||
return; |
|||
} |
|||
|
|||
if (!verify_signed_privmsg(istate, pk1, msg)) { |
|||
log_debug(istate->log, |
|||
"Ignoring announcement from %s, signature check failed.", |
|||
splits[1]); |
|||
return; |
|||
} |
|||
|
|||
/*
|
|||
* FIXME Check in topology that the tx is in the block and |
|||
* that the endpoints match. |
|||
*/ |
|||
|
|||
add_connection(istate->dstate->rstate, pk1, pk2, atoi(splits[6]), |
|||
atoi(splits[7]), atoi(splits[8]), 6); |
|||
} |
|||
|
|||
static void handle_irc_node_announcement( |
|||
struct ircstate *istate, |
|||
const struct privmsg *msg, |
|||
char **splits) |
|||
{ |
|||
struct pubkey *pk = talz(msg, struct pubkey); |
|||
if (!pubkey_from_hexstr(splits[1], strlen(splits[1]), pk)) |
|||
return; |
|||
|
|||
if (!verify_signed_privmsg(istate, pk, msg)) { |
|||
log_debug(istate->log, "Ignoring node announcement from %s, signature check failed.", |
|||
splits[1]); |
|||
return; |
|||
} else if(splits[4] != NULL && strlen(splits[4]) > 64) { |
|||
log_debug(istate->log, "Ignoring node announcement from %s, alias too long", |
|||
splits[1]); |
|||
} |
|||
|
|||
struct node *node = add_node(istate->dstate->rstate, pk); |
|||
if (splits[4] != NULL){ |
|||
tal_free(node->alias); |
|||
node->alias = tal_hexdata(node, splits[4], strlen(splits[4])); |
|||
} |
|||
} |
|||
|
|||
/*
|
|||
* Handle an incoming message by checking if it is a channel |
|||
* announcement, parse it and add the channel to the topology if yes. |
|||
* |
|||
* The format for a valid announcement is: |
|||
* <sig> CHAN <pk1> <pk2> <anchor txid> <block height> <tx position> <base_fee> |
|||
* <proportional_fee> <locktime> |
|||
*/ |
|||
static void handle_irc_privmsg(struct ircstate *istate, const struct privmsg *msg) |
|||
{ |
|||
char **splits = tal_strsplit(msg, msg->msg + 1, " ", STR_NO_EMPTY); |
|||
int splitcount = tal_count(splits) - 1; |
|||
|
|||
if (splitcount < 2) |
|||
return; |
|||
|
|||
char *type = splits[1]; |
|||
|
|||
if (splitcount == 10 && streq(type, "CHAN")) |
|||
handle_irc_channel_announcement(istate, msg, splits + 1); |
|||
else if (splitcount >= 5 && streq(type, "NODE")) |
|||
handle_irc_node_announcement(istate, msg, splits + 1); |
|||
} |
|||
|
|||
static void handle_irc_command(struct ircstate *istate, const struct irccommand *cmd) |
|||
{ |
|||
struct lightningd_state *dstate = istate->dstate; |
|||
char **params = tal_strsplit(cmd, cmd->params, " ", STR_NO_EMPTY); |
|||
|
|||
if (streq(cmd->command, "338") && tal_count(params) >= 4) { |
|||
dstate->external_ip = tal_strdup( |
|||
istate->dstate, params[3]); |
|||
log_debug(dstate->base_log, "Detected my own IP as %s", dstate->external_ip); |
|||
|
|||
// Add our node to the node_map for completeness
|
|||
add_node(istate->dstate->rstate, &dstate->id); |
|||
} else if (streq(cmd->command, "JOIN")) { |
|||
unsigned int delay; |
|||
|
|||
/* Throw away any existing announce timer, and announce within
|
|||
* 60 seconds. */ |
|||
dstate->announce = tal_free(dstate->announce); |
|||
|
|||
delay = pseudorand(60000000); |
|||
log_debug(istate->log, "Setting new announce time %u sec", |
|||
delay / 1000000); |
|||
dstate->announce = new_reltimer(&dstate->timers, istate, |
|||
time_from_usec(delay), |
|||
announce, istate); |
|||
} |
|||
} |
|||
|
|||
static void handle_irc_connected(struct ircstate *istate) |
|||
{ |
|||
irc_send(istate, "JOIN", "#lightning-nodes"); |
|||
irc_send(istate, "WHOIS", "%s", istate->nick); |
|||
} |
|||
|
|||
void setup_irc_connection(struct lightningd_state *dstate) |
|||
{ |
|||
// Register callback
|
|||
irc_privmsg_cb = *handle_irc_privmsg; |
|||
irc_connect_cb = *handle_irc_connected; |
|||
irc_disconnect_cb = *handle_irc_disconnect; |
|||
irc_command_cb = *handle_irc_command; |
|||
|
|||
struct ircstate *state = talz(dstate, struct ircstate); |
|||
state->dstate = dstate; |
|||
state->server = "irc.lfnet.org"; |
|||
state->reconnect_timeout = time_from_sec(15); |
|||
state->log = new_log(state, state->dstate->log_book, "%s:irc", |
|||
log_prefix(state->dstate->base_log)); |
|||
|
|||
/* Truncate nick at 13 bytes, would be imposed by freenode anyway */ |
|||
state->nick = tal_fmt( |
|||
state, |
|||
"N%.12s", |
|||
pubkey_to_hexstr(state, &dstate->id) + 1); |
|||
|
|||
/* We will see our own JOIN message, which will trigger announce */ |
|||
irc_connect(state); |
|||
} |
|||
@ -1,9 +0,0 @@ |
|||
#ifndef LIGHTNING_DAEMON_IRC_ANNOUNCE_H |
|||
#define LIGHTNING_DAEMON_IRC_ANNOUNCE_H |
|||
#include "config.h" |
|||
#include "irc.h" |
|||
|
|||
// Main entrypoint for the lightning daemon
|
|||
void setup_irc_connection(struct lightningd_state *dstate); |
|||
|
|||
#endif /* LIGHTNING_DAEMON_IRC_ANNOUNCE_H */ |
|||
@ -1,174 +0,0 @@ |
|||
#include "bitcoind.h" |
|||
#include "chaintopology.h" |
|||
#include "db.h" |
|||
#include "invoice.h" |
|||
#include "irc_announce.h" |
|||
#include "jsonrpc.h" |
|||
#include "lightningd.h" |
|||
#include "log.h" |
|||
#include "options.h" |
|||
#include "p2p_announce.h" |
|||
#include "peer.h" |
|||
#include "routing.h" |
|||
#include "secrets.h" |
|||
#include "timeout.h" |
|||
#include "utils.h" |
|||
#include <bitcoin/chainparams.h> |
|||
#include <ccan/container_of/container_of.h> |
|||
#include <ccan/err/err.h> |
|||
#include <ccan/io/io.h> |
|||
#include <ccan/opt/opt.h> |
|||
#include <ccan/tal/grab_file/grab_file.h> |
|||
#include <ccan/tal/str/str.h> |
|||
#include <ccan/tal/tal.h> |
|||
#include <ccan/time/time.h> |
|||
#include <ccan/timer/timer.h> |
|||
#include <errno.h> |
|||
#include <inttypes.h> |
|||
#include <signal.h> |
|||
#include <unistd.h> |
|||
#include <version.h> |
|||
|
|||
static struct lightningd_state *lightningd_state(void) |
|||
{ |
|||
struct lightningd_state *dstate = tal(NULL, struct lightningd_state); |
|||
struct sha256_double unused; |
|||
|
|||
dstate->log_book = new_log_book(dstate, 20*1024*1024, LOG_INFORM); |
|||
dstate->base_log = new_log(dstate, dstate->log_book, |
|||
"lightningd(%u):", (int)getpid()); |
|||
|
|||
list_head_init(&dstate->peers); |
|||
list_head_init(&dstate->pay_commands); |
|||
dstate->portnum = 0; |
|||
dstate->testnet = true; |
|||
timers_init(&dstate->timers, time_mono()); |
|||
list_head_init(&dstate->wallet); |
|||
list_head_init(&dstate->addresses); |
|||
dstate->dev_never_routefail = false; |
|||
dstate->rstate = new_routing_state(dstate, dstate->base_log, &unused); |
|||
dstate->reexec = NULL; |
|||
dstate->external_ip = NULL; |
|||
dstate->announce = NULL; |
|||
dstate->invoices = invoices_init(dstate); |
|||
return dstate; |
|||
} |
|||
|
|||
static void json_lightningd_dev_broadcast(struct command *cmd, |
|||
const char *buffer, |
|||
const jsmntok_t *params) |
|||
{ |
|||
json_dev_broadcast(cmd, cmd->dstate->topology, buffer, params); |
|||
} |
|||
|
|||
static const struct json_command dev_broadcast_command = { |
|||
"dev-broadcast", |
|||
json_lightningd_dev_broadcast, |
|||
"Pretend we broadcast txs, but don't send to bitcoind", |
|||
"Returns an empty result on success (waits for flush if enabled)" |
|||
}; |
|||
AUTODATA(json_command, &dev_broadcast_command); |
|||
|
|||
int main(int argc, char *argv[]) |
|||
{ |
|||
struct lightningd_state *dstate = lightningd_state(); |
|||
|
|||
err_set_progname(argv[0]); |
|||
|
|||
if (!streq(protobuf_c_version(), PROTOBUF_C_VERSION)) |
|||
errx(1, "Compiled against protobuf %s, but have %s", |
|||
PROTOBUF_C_VERSION, protobuf_c_version()); |
|||
|
|||
secp256k1_ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY |
|||
| SECP256K1_CONTEXT_SIGN); |
|||
|
|||
dstate->topology = new_topology(dstate, dstate->base_log); |
|||
dstate->bitcoind = new_bitcoind(dstate, dstate->base_log); |
|||
dstate->bitcoind->chainparams = chainparams_for_network("regtest"); |
|||
|
|||
/* Handle options and config; move to .lightningd */ |
|||
register_opts(dstate); |
|||
handle_opts(dstate, argc, argv); |
|||
|
|||
/* Now we can set chain_hash properly. */ |
|||
dstate->rstate->chain_hash |
|||
= dstate->bitcoind->chainparams->genesis_blockhash; |
|||
|
|||
/* Activate crash log now we're in the right place. */ |
|||
crashlog_activate(dstate->base_log); |
|||
|
|||
/* Ignore SIGPIPE: we look at our write return values*/ |
|||
signal(SIGPIPE, SIG_IGN); |
|||
|
|||
/* Set up node ID and private key. */ |
|||
secrets_init(dstate); |
|||
new_node(dstate->rstate, &dstate->id); |
|||
|
|||
/* Read or create database. */ |
|||
db_init(dstate); |
|||
|
|||
/* Initialize block topology. */ |
|||
setup_topology(dstate->topology, dstate->bitcoind, &dstate->timers, |
|||
dstate->config.poll_time, |
|||
get_peer_min_block(dstate)); |
|||
|
|||
/* Create RPC socket (if any) */ |
|||
setup_jsonrpc(dstate, dstate->rpc_filename); |
|||
|
|||
/* Set up connections from peers (if dstate->portnum is set) */ |
|||
setup_listeners(dstate); |
|||
|
|||
/* set up IRC peer discovery */ |
|||
if (dstate->config.use_irc) |
|||
setup_irc_connection(dstate); |
|||
|
|||
/* set up P2P gossip protocol */ |
|||
setup_p2p_announce(dstate); |
|||
|
|||
log_info(dstate->base_log, "Hello world!"); |
|||
|
|||
/* If we loaded peers from database, reconnect now. */ |
|||
reconnect_peers(dstate); |
|||
|
|||
/* And send out anchors again if we're waiting. */ |
|||
rebroadcast_anchors(dstate); |
|||
|
|||
for (;;) { |
|||
struct timer *expired; |
|||
void *v = io_loop(&dstate->timers, &expired); |
|||
|
|||
/* We use io_break(dstate) to shut down. */ |
|||
if (v == dstate) |
|||
break; |
|||
|
|||
if (expired) |
|||
timer_expired(dstate, expired); |
|||
else |
|||
cleanup_peers(dstate); |
|||
} |
|||
|
|||
if (dstate->reexec) { |
|||
int fd; |
|||
|
|||
log_unusual(dstate->base_log, "Restart at user request"); |
|||
fflush(stdout); |
|||
fflush(stderr); |
|||
|
|||
/* Manually close all fds (or near enough!) */ |
|||
for (fd = 3; fd < 1024; fd++) |
|||
close(fd); |
|||
|
|||
if (dstate->dev_never_routefail) { |
|||
size_t n = tal_count(dstate->reexec); |
|||
tal_resizez(&dstate->reexec, n+1); |
|||
dstate->reexec[n-1] = "--dev-no-routefail"; |
|||
} |
|||
execvp(dstate->reexec[0], dstate->reexec); |
|||
fatal("Exec '%s' failed: %s", |
|||
dstate->reexec[0], strerror(errno)); |
|||
} |
|||
|
|||
tal_free(dstate); |
|||
opt_free_table(); |
|||
return 0; |
|||
} |
|||
@ -1,36 +0,0 @@ |
|||
#include "names.h" |
|||
#include <ccan/str/str.h> |
|||
/* Indented for 'check-source' because it has to be included after names.h */ |
|||
#include "daemon/gen_state_names.h" |
|||
#include "daemon/gen_pkt_names.h" |
|||
|
|||
const char *state_name(enum state s) |
|||
{ |
|||
size_t i; |
|||
|
|||
for (i = 0; enum_state_names[i].name; i++) |
|||
if (enum_state_names[i].v == s) |
|||
return enum_state_names[i].name; |
|||
return "unknown"; |
|||
} |
|||
|
|||
enum state name_to_state(const char *name) |
|||
{ |
|||
size_t i; |
|||
|
|||
for (i = 0; enum_state_names[i].name; i++) |
|||
if (streq(name, enum_state_names[i].name)) |
|||
return enum_state_names[i].v; |
|||
|
|||
return STATE_MAX; |
|||
} |
|||
|
|||
const char *pkt_name(Pkt__PktCase pkt) |
|||
{ |
|||
size_t i; |
|||
|
|||
for (i = 0; enum_PktCase_names[i].name; i++) |
|||
if (enum_PktCase_names[i].v == pkt) |
|||
return enum_PktCase_names[i].name; |
|||
return "unknown"; |
|||
} |
|||
@ -1,10 +0,0 @@ |
|||
#ifndef LIGHTNING_NAMES_H |
|||
#define LIGHTNING_NAMES_H |
|||
#include "config.h" |
|||
#include "lightning.pb-c.h" |
|||
#include "state_types.h" |
|||
|
|||
const char *state_name(enum state s); |
|||
enum state name_to_state(const char *name); |
|||
const char *pkt_name(Pkt__PktCase pkt); |
|||
#endif /* LIGHTNING_NAMES_H */ |
|||
@ -1,80 +0,0 @@ |
|||
#include "commit_tx.h" |
|||
#include "output_to_htlc.h" |
|||
#include "peer.h" |
|||
#include "peer_internal.h" |
|||
|
|||
/* FIXME: Array makes this O(n^2). Use a hash table. */ |
|||
struct wscript_by_wpkh { |
|||
struct htlc *h; |
|||
const u8 *wscript; |
|||
struct sha256 hash; |
|||
}; |
|||
|
|||
struct htlc_output_map { |
|||
struct wscript_by_wpkh *wpkh; |
|||
}; |
|||
|
|||
struct htlc_output_map *get_htlc_output_map(const tal_t *ctx, |
|||
const struct peer *peer, |
|||
const struct sha256 *rhash, |
|||
enum side side, |
|||
unsigned int commit_num) |
|||
{ |
|||
struct htlc_map_iter it; |
|||
struct htlc *h; |
|||
size_t i; |
|||
struct htlc_output_map *omap = tal(ctx, struct htlc_output_map); |
|||
|
|||
/* FIXME: use commit_num to filter htlcs. */ |
|||
if (side == LOCAL) |
|||
assert(commit_num <= peer->local.commit->commit_num); |
|||
else |
|||
assert(commit_num <= peer->remote.commit->commit_num); |
|||
|
|||
omap->wpkh = tal_arr(omap, struct wscript_by_wpkh, |
|||
htlc_map_count(&peer->htlcs)); |
|||
|
|||
for (i = 0, h = htlc_map_first(&peer->htlcs, &it); |
|||
h; |
|||
h = htlc_map_next(&peer->htlcs, &it)) { |
|||
omap->wpkh[i].h = h; |
|||
omap->wpkh[i].wscript = wscript_for_htlc(omap, peer, h, rhash, |
|||
side); |
|||
sha256(&omap->wpkh[i].hash, |
|||
omap->wpkh[i].wscript, |
|||
tal_count(omap->wpkh[i].wscript)); |
|||
i++; |
|||
} |
|||
tal_resize(&omap->wpkh, i); |
|||
return omap; |
|||
} |
|||
|
|||
static struct wscript_by_wpkh *get_wpkh(struct htlc_output_map *omap, |
|||
const u8 *script) |
|||
{ |
|||
size_t i; |
|||
|
|||
if (!is_p2wsh(script)) |
|||
return NULL; |
|||
|
|||
for (i = 0; i < tal_count(omap->wpkh); i++) { |
|||
if (!memcmp(script + 2, omap->wpkh[i].hash.u.u8, |
|||
sizeof(omap->wpkh[i].hash))) |
|||
return &omap->wpkh[i]; |
|||
} |
|||
return NULL; |
|||
} |
|||
|
|||
/* Which wscript does this pay to? */ |
|||
struct htlc *txout_get_htlc(struct htlc_output_map *omap, |
|||
const u8 *script, |
|||
const u8 **wscript) |
|||
{ |
|||
struct wscript_by_wpkh *wpkh = get_wpkh(omap, script); |
|||
|
|||
if (wpkh) { |
|||
*wscript = wpkh->wscript; |
|||
return wpkh->h; |
|||
} |
|||
return NULL; |
|||
} |
|||
@ -1,20 +0,0 @@ |
|||
#ifndef LIGHTNING_DAEMON_OUTPUT_TO_HTLC_H |
|||
#define LIGHTNING_DAEMON_OUTPUT_TO_HTLC_H |
|||
#include "config.h" |
|||
#include "htlc.h" |
|||
|
|||
struct peer; |
|||
struct sha256; |
|||
|
|||
/* Get a map of HTLCs (including at least those at the given commit_num). */ |
|||
struct htlc_output_map *get_htlc_output_map(const tal_t *ctx, |
|||
const struct peer *peer, |
|||
const struct sha256 *rhash, |
|||
enum side side, |
|||
unsigned int commit_num); |
|||
|
|||
/* If this scriptPubkey pays to a HTLC, get the full wscript */ |
|||
struct htlc *txout_get_htlc(struct htlc_output_map *omap, |
|||
const u8 *script, const u8 **wscript); |
|||
|
|||
#endif /* LIGHTNING_DAEMON_OUTPUT_TO_HTLC_H */ |
|||
@ -1,231 +0,0 @@ |
|||
#include "daemon/broadcast.h" |
|||
#include "daemon/chaintopology.h" |
|||
#include "daemon/log.h" |
|||
#include "daemon/p2p_announce.h" |
|||
#include "daemon/packets.h" |
|||
#include "daemon/peer.h" |
|||
#include "daemon/peer_internal.h" |
|||
#include "daemon/routing.h" |
|||
#include "daemon/secrets.h" |
|||
#include "daemon/timeout.h" |
|||
#include "utils.h" |
|||
|
|||
#include <ccan/tal/str/str.h> |
|||
#include <ccan/tal/tal.h> |
|||
#include <secp256k1.h> |
|||
|
|||
static void broadcast_channel_update(struct lightningd_state *dstate, struct peer *peer) |
|||
{ |
|||
struct txlocator *loc; |
|||
u8 *serialized; |
|||
secp256k1_ecdsa_signature signature; |
|||
struct short_channel_id short_channel_id; |
|||
u32 timestamp = time_now().ts.tv_sec; |
|||
const tal_t *tmpctx = tal_tmpctx(dstate); |
|||
|
|||
loc = locate_tx(tmpctx, dstate->topology, &peer->anchor.txid); |
|||
short_channel_id.blocknum = loc->blkheight; |
|||
short_channel_id.txnum = loc->index; |
|||
short_channel_id.outnum = peer->anchor.index; |
|||
|
|||
/* Avoid triggering memcheck */ |
|||
memset(&signature, 0, sizeof(signature)); |
|||
|
|||
serialized = towire_channel_update(tmpctx, &signature, |
|||
&dstate->rstate->chain_hash, |
|||
&short_channel_id, |
|||
timestamp, |
|||
pubkey_cmp(&dstate->id, peer->id) > 0, |
|||
dstate->config.min_htlc_expiry, |
|||
//FIXME(cdecker) Make the minimum HTLC configurable
|
|||
1, |
|||
dstate->config.fee_base, |
|||
dstate->config.fee_per_satoshi); |
|||
privkey_sign(dstate, serialized + 66, tal_count(serialized) - 66, |
|||
&signature); |
|||
serialized = towire_channel_update(tmpctx, &signature, |
|||
&dstate->rstate->chain_hash, |
|||
&short_channel_id, |
|||
timestamp, |
|||
pubkey_cmp(&dstate->id, peer->id) > 0, |
|||
dstate->config.min_htlc_expiry, |
|||
1, |
|||
dstate->config.fee_base, |
|||
dstate->config.fee_per_satoshi); |
|||
u8 *tag = tal_arr(tmpctx, u8, 0); |
|||
towire_short_channel_id(&tag, &short_channel_id); |
|||
queue_broadcast(dstate->rstate->broadcasts, WIRE_CHANNEL_UPDATE, tag, serialized); |
|||
tal_free(tmpctx); |
|||
} |
|||
|
|||
static void broadcast_node_announcement(struct lightningd_state *dstate) |
|||
{ |
|||
u8 *serialized; |
|||
secp256k1_ecdsa_signature signature; |
|||
static const u8 rgb_color[3]; |
|||
static const u8 alias[32]; |
|||
u32 timestamp = time_now().ts.tv_sec; |
|||
const tal_t *tmpctx = tal_tmpctx(dstate); |
|||
u8 *address; |
|||
|
|||
/* Are we listening for incoming connections at all? */ |
|||
if (!dstate->external_ip || !dstate->portnum) { |
|||
tal_free(tmpctx); |
|||
return; |
|||
} |
|||
|
|||
/* Avoid triggering memcheck */ |
|||
memset(&signature, 0, sizeof(signature)); |
|||
|
|||
address = write_ip(tmpctx, dstate->external_ip, dstate->portnum); |
|||
serialized = towire_node_announcement(tmpctx, &signature, |
|||
NULL, |
|||
timestamp, |
|||
&dstate->id, rgb_color, alias, |
|||
address); |
|||
privkey_sign(dstate, serialized + 66, tal_count(serialized) - 66, |
|||
&signature); |
|||
serialized = towire_node_announcement(tmpctx, &signature, |
|||
NULL, |
|||
timestamp, |
|||
&dstate->id, rgb_color, alias, |
|||
address); |
|||
u8 *tag = tal_arr(tmpctx, u8, 0); |
|||
towire_pubkey(&tag, &dstate->id); |
|||
queue_broadcast(dstate->rstate->broadcasts, WIRE_NODE_ANNOUNCEMENT, tag, |
|||
serialized); |
|||
tal_free(tmpctx); |
|||
} |
|||
|
|||
static void broadcast_channel_announcement(struct lightningd_state *dstate, struct peer *peer) |
|||
{ |
|||
struct txlocator *loc; |
|||
struct short_channel_id short_channel_id; |
|||
secp256k1_ecdsa_signature node_signature[2]; |
|||
secp256k1_ecdsa_signature bitcoin_signature[2]; |
|||
const struct pubkey *node_id[2]; |
|||
const struct pubkey *bitcoin_key[2]; |
|||
secp256k1_ecdsa_signature *my_node_signature; |
|||
secp256k1_ecdsa_signature *my_bitcoin_signature; |
|||
u8 *serialized; |
|||
const tal_t *tmpctx = tal_tmpctx(dstate); |
|||
|
|||
loc = locate_tx(tmpctx, dstate->topology, &peer->anchor.txid); |
|||
|
|||
short_channel_id.blocknum = loc->blkheight; |
|||
short_channel_id.txnum = loc->index; |
|||
short_channel_id.outnum = peer->anchor.index; |
|||
|
|||
/* Set all sigs to zero */ |
|||
memset(node_signature, 0, sizeof(node_signature)); |
|||
memset(bitcoin_signature, 0, sizeof(bitcoin_signature)); |
|||
|
|||
//FIXME(cdecker) Copy remote stored signatures into place
|
|||
if (pubkey_cmp(&dstate->id, peer->id) > 0) { |
|||
node_id[0] = peer->id; |
|||
node_id[1] = &dstate->id; |
|||
bitcoin_key[0] = peer->id; |
|||
bitcoin_key[1] = &dstate->id; |
|||
my_node_signature = &node_signature[1]; |
|||
my_bitcoin_signature = &bitcoin_signature[1]; |
|||
} else { |
|||
node_id[1] = peer->id; |
|||
node_id[0] = &dstate->id; |
|||
bitcoin_key[1] = peer->id; |
|||
bitcoin_key[0] = &dstate->id; |
|||
my_node_signature = &node_signature[0]; |
|||
my_bitcoin_signature = &bitcoin_signature[0]; |
|||
} |
|||
|
|||
/* Sign the node_id with the bitcoin_key, proves delegation */ |
|||
serialized = tal_arr(tmpctx, u8, 0); |
|||
towire_pubkey(&serialized, &dstate->id); |
|||
privkey_sign(dstate, serialized, tal_count(serialized), my_bitcoin_signature); |
|||
|
|||
/* BOLT #7:
|
|||
* |
|||
* The creating node MUST compute the double-SHA256 hash `h` of the |
|||
* message, starting at offset 256, up to the end of the message. |
|||
*/ |
|||
serialized = towire_channel_announcement(tmpctx, &node_signature[0], |
|||
&node_signature[1], |
|||
&bitcoin_signature[0], |
|||
&bitcoin_signature[1], |
|||
NULL, |
|||
&dstate->rstate->chain_hash, |
|||
&short_channel_id, |
|||
node_id[0], |
|||
node_id[1], |
|||
bitcoin_key[0], |
|||
bitcoin_key[1]); |
|||
privkey_sign(dstate, serialized + 256, tal_count(serialized) - 256, my_node_signature); |
|||
|
|||
serialized = towire_channel_announcement(tmpctx, &node_signature[0], |
|||
&node_signature[1], |
|||
&bitcoin_signature[0], |
|||
&bitcoin_signature[1], |
|||
NULL, |
|||
&dstate->rstate->chain_hash, |
|||
&short_channel_id, |
|||
node_id[0], |
|||
node_id[1], |
|||
bitcoin_key[0], |
|||
bitcoin_key[1]); |
|||
u8 *tag = tal_arr(tmpctx, u8, 0); |
|||
towire_short_channel_id(&tag, &short_channel_id); |
|||
queue_broadcast(dstate->rstate->broadcasts, WIRE_CHANNEL_ANNOUNCEMENT, |
|||
tag, serialized); |
|||
tal_free(tmpctx); |
|||
} |
|||
|
|||
static void announce(struct lightningd_state *dstate) |
|||
{ |
|||
struct peer *p; |
|||
int nchan = 0; |
|||
|
|||
new_reltimer(&dstate->timers, dstate, time_from_sec(5*60*60), announce, dstate); |
|||
|
|||
list_for_each(&dstate->peers, p, list) { |
|||
if (state_is_normal(p->state)) { |
|||
broadcast_channel_announcement(dstate, p); |
|||
broadcast_channel_update(dstate, p); |
|||
nchan += 1; |
|||
} |
|||
} |
|||
|
|||
/* No point in broadcasting our node if we don't have a channel */ |
|||
if (nchan > 0) |
|||
broadcast_node_announcement(dstate); |
|||
} |
|||
|
|||
void announce_channel(struct lightningd_state *dstate, struct peer *peer) |
|||
{ |
|||
broadcast_channel_announcement(dstate, peer); |
|||
broadcast_channel_update(dstate, peer); |
|||
broadcast_node_announcement(dstate); |
|||
|
|||
} |
|||
|
|||
static void process_broadcast_queue(struct lightningd_state *dstate) |
|||
{ |
|||
struct peer *p; |
|||
struct queued_message *msg; |
|||
new_reltimer(&dstate->timers, dstate, time_from_sec(30), process_broadcast_queue, dstate); |
|||
list_for_each(&dstate->peers, p, list) { |
|||
if (!state_is_normal(p->state)) |
|||
continue; |
|||
msg = next_broadcast_message(dstate->rstate->broadcasts, |
|||
&p->broadcast_index); |
|||
while (msg != NULL) { |
|||
queue_pkt_nested(p, msg->type, msg->payload); |
|||
msg = next_broadcast_message(dstate->rstate->broadcasts, |
|||
&p->broadcast_index); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void setup_p2p_announce(struct lightningd_state *dstate) |
|||
{ |
|||
new_reltimer(&dstate->timers, dstate, time_from_sec(5*60*60), announce, dstate); |
|||
new_reltimer(&dstate->timers, dstate, time_from_sec(30), process_broadcast_queue, dstate); |
|||
} |
|||
@ -1,15 +0,0 @@ |
|||
#ifndef LIGHTNING_DAEMON_P2P_ANNOUNCE_H |
|||
#define LIGHTNING_DAEMON_P2P_ANNOUNCE_H |
|||
#include "config.h" |
|||
#include "daemon/broadcast.h" |
|||
#include "daemon/lightningd.h" |
|||
#include "daemon/routing.h" |
|||
#include "lightningd.h" |
|||
#include "wire/gen_peer_wire.h" |
|||
|
|||
void setup_p2p_announce(struct lightningd_state *dstate); |
|||
|
|||
/* Used to announce the existence of a channel and the endpoints */ |
|||
void announce_channel(struct lightningd_state *dstate, struct peer *peer); |
|||
|
|||
#endif /* LIGHTNING_DAEMON_P2P_ANNOUNCE_H */ |
|||
@ -1,599 +0,0 @@ |
|||
#include "bitcoin/preimage.h" |
|||
#include "bitcoin/script.h" |
|||
#include "bitcoin/tx.h" |
|||
#include "chaintopology.h" |
|||
#include "close_tx.h" |
|||
#include "commit_tx.h" |
|||
#include "cryptopkt.h" |
|||
#include "htlc.h" |
|||
#include "lightningd.h" |
|||
#include "log.h" |
|||
#include "names.h" |
|||
#include "packets.h" |
|||
#include "peer.h" |
|||
#include "peer_internal.h" |
|||
#include "protobuf_convert.h" |
|||
#include "secrets.h" |
|||
#include "state.h" |
|||
#include "utils.h" |
|||
#include <ccan/array_size/array_size.h> |
|||
#include <ccan/crypto/sha256/sha256.h> |
|||
#include <ccan/io/io.h> |
|||
#include <ccan/mem/mem.h> |
|||
#include <ccan/ptrint/ptrint.h> |
|||
#include <ccan/str/hex/hex.h> |
|||
#include <ccan/structeq/structeq.h> |
|||
#include <ccan/tal/str/str.h> |
|||
#include <inttypes.h> |
|||
|
|||
/* Wrap (and own!) member inside Pkt */ |
|||
static Pkt *make_pkt(const tal_t *ctx, Pkt__PktCase type, const void *msg) |
|||
{ |
|||
Pkt *pkt = tal(ctx, Pkt); |
|||
|
|||
pkt__init(pkt); |
|||
pkt->pkt_case = type; |
|||
/* This is a union, so doesn't matter which we assign. */ |
|||
pkt->error = (Error *)tal_steal(pkt, msg); |
|||
|
|||
/* This makes sure all packets are valid. */ |
|||
#ifndef NDEBUG |
|||
{ |
|||
size_t len; |
|||
u8 *packed; |
|||
Pkt *cpy; |
|||
|
|||
len = pkt__get_packed_size(pkt); |
|||
packed = tal_arr(pkt, u8, len); |
|||
pkt__pack(pkt, packed); |
|||
cpy = pkt__unpack(NULL, len, memcheck(packed, len)); |
|||
assert(cpy); |
|||
pkt__free_unpacked(cpy, NULL); |
|||
tal_free(packed); |
|||
} |
|||
#endif |
|||
return pkt; |
|||
} |
|||
|
|||
static void queue_raw_pkt(struct peer *peer, Pkt *pkt) |
|||
{ |
|||
size_t n = tal_count(peer->outpkt); |
|||
tal_resize(&peer->outpkt, n+1); |
|||
peer->outpkt[n] = pkt; |
|||
|
|||
log_debug(peer->log, "Queued pkt %s (order=%"PRIu64")", |
|||
pkt_name(pkt->pkt_case), peer->order_counter); |
|||
|
|||
/* In case it was waiting for output. */ |
|||
io_wake(peer); |
|||
} |
|||
|
|||
static void queue_pkt(struct peer *peer, Pkt__PktCase type, const void *msg) |
|||
{ |
|||
queue_raw_pkt(peer, make_pkt(peer, type, msg)); |
|||
} |
|||
|
|||
void queue_pkt_open(struct peer *peer, bool offer_anchor) |
|||
{ |
|||
OpenChannel *o = tal(peer, OpenChannel); |
|||
|
|||
open_channel__init(o); |
|||
o->revocation_hash = sha256_to_proto(o, &peer->local.commit->revocation_hash); |
|||
o->next_revocation_hash = sha256_to_proto(o, &peer->local.next_revocation_hash); |
|||
o->commit_key = pubkey_to_proto(o, &peer->local.commitkey); |
|||
o->final_key = pubkey_to_proto(o, &peer->local.finalkey); |
|||
o->delay = tal(o, Locktime); |
|||
locktime__init(o->delay); |
|||
o->delay->locktime_case = LOCKTIME__LOCKTIME_BLOCKS; |
|||
o->delay->blocks = rel_locktime_to_blocks(&peer->local.locktime); |
|||
o->initial_fee_rate = peer->local.commit_fee_rate; |
|||
if (offer_anchor) |
|||
o->anch = OPEN_CHANNEL__ANCHOR_OFFER__WILL_CREATE_ANCHOR; |
|||
else |
|||
o->anch = OPEN_CHANNEL__ANCHOR_OFFER__WONT_CREATE_ANCHOR; |
|||
o->min_depth = peer->local.mindepth; |
|||
queue_pkt(peer, PKT__PKT_OPEN, o); |
|||
} |
|||
|
|||
void queue_pkt_anchor(struct peer *peer) |
|||
{ |
|||
OpenAnchor *a = tal(peer, OpenAnchor); |
|||
|
|||
open_anchor__init(a); |
|||
a->txid = sha256_to_proto(a, &peer->anchor.txid.sha); |
|||
a->output_index = peer->anchor.index; |
|||
a->amount = peer->anchor.satoshis; |
|||
|
|||
queue_pkt(peer, PKT__PKT_OPEN_ANCHOR, a); |
|||
} |
|||
|
|||
void queue_pkt_open_commit_sig(struct peer *peer) |
|||
{ |
|||
OpenCommitSig *s = tal(peer, OpenCommitSig); |
|||
|
|||
open_commit_sig__init(s); |
|||
|
|||
s->sig = signature_to_proto(s, peer->remote.commit->sig); |
|||
|
|||
queue_pkt(peer, PKT__PKT_OPEN_COMMIT_SIG, s); |
|||
} |
|||
|
|||
void queue_pkt_open_complete(struct peer *peer) |
|||
{ |
|||
OpenComplete *o = tal(peer, OpenComplete); |
|||
|
|||
open_complete__init(o); |
|||
queue_pkt(peer, PKT__PKT_OPEN_COMPLETE, o); |
|||
} |
|||
|
|||
void queue_pkt_htlc_add(struct peer *peer, struct htlc *htlc) |
|||
{ |
|||
UpdateAddHtlc *u = tal(peer, UpdateAddHtlc); |
|||
|
|||
update_add_htlc__init(u); |
|||
|
|||
u->id = htlc->id; |
|||
u->amount_msat = htlc->msatoshi; |
|||
u->r_hash = sha256_to_proto(u, &htlc->rhash); |
|||
u->expiry = abs_locktime_to_proto(u, &htlc->expiry); |
|||
u->route = tal(u, Routing); |
|||
routing__init(u->route); |
|||
u->route->info.data = tal_dup_arr(u, u8, |
|||
htlc->routing, |
|||
tal_count(htlc->routing), |
|||
0); |
|||
u->route->info.len = tal_count(u->route->info.data); |
|||
|
|||
queue_pkt(peer, PKT__PKT_UPDATE_ADD_HTLC, u); |
|||
} |
|||
|
|||
void queue_pkt_htlc_fulfill(struct peer *peer, struct htlc *htlc) |
|||
{ |
|||
UpdateFulfillHtlc *f = tal(peer, UpdateFulfillHtlc); |
|||
|
|||
update_fulfill_htlc__init(f); |
|||
f->id = htlc->id; |
|||
f->r = preimage_to_proto(f, htlc->r); |
|||
|
|||
queue_pkt(peer, PKT__PKT_UPDATE_FULFILL_HTLC, f); |
|||
} |
|||
|
|||
void queue_pkt_htlc_fail(struct peer *peer, struct htlc *htlc) |
|||
{ |
|||
UpdateFailHtlc *f = tal(peer, UpdateFailHtlc); |
|||
|
|||
update_fail_htlc__init(f); |
|||
f->id = htlc->id; |
|||
|
|||
f->reason = tal(f, FailReason); |
|||
fail_reason__init(f->reason); |
|||
f->reason->info.len = tal_count(htlc->fail); |
|||
f->reason->info.data = tal_dup_arr(f->reason, u8, |
|||
htlc->fail, f->reason->info.len, 0); |
|||
|
|||
queue_pkt(peer, PKT__PKT_UPDATE_FAIL_HTLC, f); |
|||
} |
|||
|
|||
void queue_pkt_feechange(struct peer *peer, u64 feerate) |
|||
{ |
|||
UpdateFee *f = tal(peer, UpdateFee); |
|||
|
|||
update_fee__init(f); |
|||
f->fee_rate = feerate; |
|||
|
|||
queue_pkt(peer, PKT__PKT_UPDATE_FEE, f); |
|||
} |
|||
|
|||
/* OK, we're sending a signature for their pending changes. */ |
|||
void queue_pkt_commit(struct peer *peer, const secp256k1_ecdsa_signature *sig) |
|||
{ |
|||
UpdateCommit *u = tal(peer, UpdateCommit); |
|||
|
|||
/* Now send message */ |
|||
update_commit__init(u); |
|||
if (sig) |
|||
u->sig = signature_to_proto(u, sig); |
|||
else |
|||
u->sig = NULL; |
|||
|
|||
queue_pkt(peer, PKT__PKT_UPDATE_COMMIT, u); |
|||
} |
|||
|
|||
|
|||
/* Send a preimage for the old commit tx. The one we've just committed to is
|
|||
* in peer->local.commit. */ |
|||
void queue_pkt_revocation(struct peer *peer, |
|||
const struct sha256 *preimage, |
|||
const struct sha256 *next_hash) |
|||
{ |
|||
UpdateRevocation *u = tal(peer, UpdateRevocation); |
|||
|
|||
update_revocation__init(u); |
|||
|
|||
u->revocation_preimage = sha256_to_proto(u, preimage); |
|||
u->next_revocation_hash = sha256_to_proto(u, next_hash); |
|||
queue_pkt(peer, PKT__PKT_UPDATE_REVOCATION, u); |
|||
} |
|||
|
|||
/* Send a serialized nested packet. */ |
|||
void queue_pkt_nested(struct peer *peer, |
|||
int type, |
|||
const u8 *nested_pkt) |
|||
{ |
|||
NestedPkt *pb = tal(peer, NestedPkt); |
|||
nested_pkt__init(pb); |
|||
pb->type = type; |
|||
pb->inner_pkt.len = tal_count(nested_pkt); |
|||
pb->inner_pkt.data = tal_dup_arr(pb, u8, nested_pkt, pb->inner_pkt.len, 0); |
|||
queue_pkt(peer, PKT__PKT_NESTED, pb); |
|||
} |
|||
|
|||
Pkt *pkt_err(struct peer *peer, const char *msg, ...) |
|||
{ |
|||
Error *e = tal(peer, Error); |
|||
va_list ap; |
|||
|
|||
error__init(e); |
|||
va_start(ap, msg); |
|||
e->problem = tal_vfmt(e, msg, ap); |
|||
va_end(ap); |
|||
|
|||
log_unusual(peer->log, "Sending PKT_ERROR: %s", e->problem); |
|||
return make_pkt(peer, PKT__PKT_ERROR, e); |
|||
} |
|||
|
|||
Pkt *pkt_init(struct peer *peer, u64 ack) |
|||
{ |
|||
Init *i = tal(peer, Init); |
|||
init__init(i); |
|||
i->ack = ack; |
|||
/* FIXME-OLD #2:
|
|||
* |
|||
* A node SHOULD set the `features` field of the `init` |
|||
* message to a bitset representing features it supports. |
|||
*/ |
|||
/* No features yet! */ |
|||
return make_pkt(peer, PKT__PKT_INIT, i); |
|||
} |
|||
|
|||
void queue_pkt_err(struct peer *peer, Pkt *err) |
|||
{ |
|||
queue_raw_pkt(peer, err); |
|||
} |
|||
|
|||
void queue_pkt_close_shutdown(struct peer *peer) |
|||
{ |
|||
CloseShutdown *c = tal(peer, CloseShutdown); |
|||
|
|||
close_shutdown__init(c); |
|||
c->scriptpubkey.data = tal_dup_arr(c, u8, |
|||
peer->closing.our_script, |
|||
tal_count(peer->closing.our_script), |
|||
0); |
|||
c->scriptpubkey.len = tal_count(c->scriptpubkey.data); |
|||
|
|||
queue_pkt(peer, PKT__PKT_CLOSE_SHUTDOWN, c); |
|||
} |
|||
|
|||
void queue_pkt_close_signature(struct peer *peer) |
|||
{ |
|||
CloseSignature *c = tal(peer, CloseSignature); |
|||
struct bitcoin_tx *close_tx; |
|||
secp256k1_ecdsa_signature our_close_sig; |
|||
|
|||
close_signature__init(c); |
|||
close_tx = peer_create_close_tx(c, peer, peer->closing.our_fee); |
|||
|
|||
peer_sign_mutual_close(peer, close_tx, &our_close_sig); |
|||
c->sig = signature_to_proto(c, &our_close_sig); |
|||
c->close_fee = peer->closing.our_fee; |
|||
log_info(peer->log, "queue_pkt_close_signature: offered close fee %" |
|||
PRIu64, c->close_fee); |
|||
|
|||
queue_pkt(peer, PKT__PKT_CLOSE_SIGNATURE, c); |
|||
} |
|||
|
|||
Pkt *pkt_err_unexpected(struct peer *peer, const Pkt *pkt) |
|||
{ |
|||
return pkt_err(peer, "Unexpected packet %s", pkt_name(pkt->pkt_case)); |
|||
} |
|||
|
|||
/* Process various packets: return an error packet on failure. */ |
|||
Pkt *accept_pkt_open(struct peer *peer, const Pkt *pkt, |
|||
struct sha256 *revocation_hash, |
|||
struct sha256 *next_revocation_hash) |
|||
{ |
|||
struct rel_locktime locktime; |
|||
const OpenChannel *o = pkt->open; |
|||
u64 feerate = get_feerate(peer->dstate->topology); |
|||
|
|||
if (!proto_to_rel_locktime(o->delay, &locktime)) |
|||
return pkt_err(peer, "Invalid delay"); |
|||
if (o->delay->locktime_case != LOCKTIME__LOCKTIME_BLOCKS) |
|||
return pkt_err(peer, "Delay in seconds not accepted"); |
|||
if (o->delay->blocks > peer->dstate->config.locktime_max) |
|||
return pkt_err(peer, "Delay %u too great", o->delay->blocks); |
|||
if (o->min_depth > peer->dstate->config.anchor_confirms_max) |
|||
return pkt_err(peer, "min_depth %u too great", o->min_depth); |
|||
if (o->initial_fee_rate |
|||
< feerate * peer->dstate->config.commitment_fee_min_percent / 100) |
|||
return pkt_err(peer, "Commitment fee %u below %"PRIu64" x %u%%", |
|||
o->initial_fee_rate, feerate, |
|||
peer->dstate->config.commitment_fee_min_percent); |
|||
if (peer->dstate->config.commitment_fee_max_percent != 0 |
|||
&& (o->initial_fee_rate |
|||
> feerate * peer->dstate->config.commitment_fee_max_percent/100)) |
|||
return pkt_err(peer, "Commitment fee %u above %"PRIu64" x %u%%", |
|||
o->initial_fee_rate, feerate, |
|||
peer->dstate->config.commitment_fee_max_percent); |
|||
if (o->anch == OPEN_CHANNEL__ANCHOR_OFFER__WILL_CREATE_ANCHOR) |
|||
peer->remote.offer_anchor = true; |
|||
else if (o->anch == OPEN_CHANNEL__ANCHOR_OFFER__WONT_CREATE_ANCHOR) |
|||
peer->remote.offer_anchor = false; |
|||
else |
|||
return pkt_err(peer, "Unknown offer anchor value %u", |
|||
o->anch); |
|||
|
|||
if (peer->remote.offer_anchor == peer->local.offer_anchor) |
|||
return pkt_err(peer, "Exactly one side can offer anchor (we %s)", |
|||
peer->local.offer_anchor ? "do" : "don't"); |
|||
|
|||
if (!proto_to_rel_locktime(o->delay, &peer->remote.locktime)) |
|||
return pkt_err(peer, "Malformed locktime"); |
|||
peer->remote.mindepth = o->min_depth; |
|||
peer->remote.commit_fee_rate = o->initial_fee_rate; |
|||
if (!proto_to_pubkey(o->commit_key, &peer->remote.commitkey)) |
|||
return pkt_err(peer, "Bad commitkey"); |
|||
if (!proto_to_pubkey(o->final_key, &peer->remote.finalkey)) |
|||
return pkt_err(peer, "Bad finalkey"); |
|||
|
|||
proto_to_sha256(o->revocation_hash, revocation_hash); |
|||
proto_to_sha256(o->next_revocation_hash, next_revocation_hash); |
|||
return NULL; |
|||
} |
|||
|
|||
Pkt *accept_pkt_anchor(struct peer *peer, const Pkt *pkt) |
|||
{ |
|||
const OpenAnchor *a = pkt->open_anchor; |
|||
|
|||
/* They must be offering anchor for us to try accepting */ |
|||
assert(!peer->local.offer_anchor); |
|||
assert(peer->remote.offer_anchor); |
|||
|
|||
if (anchor_too_large(a->amount)) |
|||
return pkt_err(peer, "Anchor millisatoshis exceeds 32 bits"); |
|||
|
|||
proto_to_sha256(a->txid, &peer->anchor.txid.sha); |
|||
peer->anchor.index = a->output_index; |
|||
peer->anchor.satoshis = a->amount; |
|||
return NULL; |
|||
} |
|||
|
|||
Pkt *accept_pkt_open_commit_sig(struct peer *peer, const Pkt *pkt, |
|||
secp256k1_ecdsa_signature *sig) |
|||
{ |
|||
const OpenCommitSig *s = pkt->open_commit_sig; |
|||
|
|||
if (!proto_to_signature(s->sig, sig)) |
|||
return pkt_err(peer, "Malformed signature"); |
|||
return NULL; |
|||
} |
|||
|
|||
Pkt *accept_pkt_open_complete(struct peer *peer, const Pkt *pkt) |
|||
{ |
|||
return NULL; |
|||
} |
|||
|
|||
/*
|
|||
* We add changes to both our staging cstate (as they did when they sent |
|||
* it) and theirs (as they will when we ack it). |
|||
*/ |
|||
Pkt *accept_pkt_htlc_add(struct peer *peer, const Pkt *pkt, struct htlc **h) |
|||
{ |
|||
const UpdateAddHtlc *u = pkt->update_add_htlc; |
|||
struct sha256 rhash; |
|||
struct abs_locktime expiry; |
|||
|
|||
/* FIXME-OLD #2:
|
|||
* |
|||
* `amount_msat` MUST BE greater than 0. |
|||
*/ |
|||
if (u->amount_msat == 0) |
|||
return pkt_err(peer, "Invalid amount_msat"); |
|||
|
|||
proto_to_sha256(u->r_hash, &rhash); |
|||
if (!proto_to_abs_locktime(u->expiry, &expiry)) |
|||
return pkt_err(peer, "Invalid HTLC expiry"); |
|||
|
|||
if (abs_locktime_is_seconds(&expiry)) |
|||
return pkt_err(peer, "HTLC expiry in seconds not supported!"); |
|||
|
|||
/* FIXME-OLD #2:
|
|||
* |
|||
* A node MUST NOT add a HTLC if it would result in it |
|||
* offering more than 300 HTLCs in the remote commitment transaction. |
|||
*/ |
|||
if (peer->remote.staging_cstate->side[REMOTE].num_htlcs == 300) |
|||
return pkt_err(peer, "Too many HTLCs"); |
|||
|
|||
/* FIXME-OLD #2:
|
|||
* |
|||
* A node MUST set `id` to a unique identifier for this HTLC |
|||
* amongst all past or future `update_add_htlc` messages. |
|||
*/ |
|||
/* Note that it's not *our* problem if they do this, it's
|
|||
* theirs (future confusion). Nonetheless, we detect and |
|||
* error for them. */ |
|||
if (htlc_get(&peer->htlcs, u->id, REMOTE)) |
|||
return pkt_err(peer, "HTLC id %"PRIu64" clashes for you", u->id); |
|||
|
|||
/* FIXME-OLD #2:
|
|||
* |
|||
* ...and the receiving node MUST add the HTLC addition to the |
|||
* unacked changeset for its local commitment. */ |
|||
*h = peer_new_htlc(peer, u->id, u->amount_msat, &rhash, |
|||
abs_locktime_to_blocks(&expiry), |
|||
u->route->info.data, u->route->info.len, |
|||
NULL, RCVD_ADD_HTLC); |
|||
return NULL; |
|||
} |
|||
|
|||
static Pkt *find_commited_htlc(struct peer *peer, uint64_t id, |
|||
struct htlc **local_htlc) |
|||
{ |
|||
*local_htlc = htlc_get(&peer->htlcs, id, LOCAL); |
|||
|
|||
/* FIXME-OLD #2:
|
|||
* |
|||
* A node MUST check that `id` corresponds to an HTLC in its |
|||
* current commitment transaction, and MUST fail the |
|||
* connection if it does not. |
|||
*/ |
|||
if (!(*local_htlc)) |
|||
return pkt_err(peer, "Did not find HTLC %"PRIu64, id); |
|||
|
|||
if ((*local_htlc)->state != SENT_ADD_ACK_REVOCATION) |
|||
return pkt_err(peer, "HTLC %"PRIu64" state %s", id, |
|||
htlc_state_name((*local_htlc)->state)); |
|||
|
|||
return NULL; |
|||
} |
|||
|
|||
Pkt *accept_pkt_htlc_fail(struct peer *peer, const Pkt *pkt, struct htlc **h, |
|||
u8 **fail) |
|||
{ |
|||
const UpdateFailHtlc *f = pkt->update_fail_htlc; |
|||
Pkt *err; |
|||
|
|||
err = find_commited_htlc(peer, f->id, h); |
|||
if (err) |
|||
return err; |
|||
|
|||
if ((*h)->r) |
|||
return pkt_err(peer, "HTLC %"PRIu64" already fulfilled", |
|||
(*h)->id); |
|||
|
|||
*fail = tal_dup_arr(*h, u8, f->reason->info.data, f->reason->info.len,0); |
|||
return NULL; |
|||
} |
|||
|
|||
Pkt *accept_pkt_htlc_fulfill(struct peer *peer, const Pkt *pkt, struct htlc **h, |
|||
struct preimage *r) |
|||
{ |
|||
const UpdateFulfillHtlc *f = pkt->update_fulfill_htlc; |
|||
struct sha256 rhash; |
|||
Pkt *err; |
|||
|
|||
err = find_commited_htlc(peer, f->id, h); |
|||
if (err) |
|||
return err; |
|||
|
|||
/* Now, it must solve the HTLC rhash puzzle. */ |
|||
proto_to_preimage(f->r, r); |
|||
sha256(&rhash, r, sizeof(*r)); |
|||
|
|||
if (!structeq(&rhash, &(*h)->rhash)) |
|||
return pkt_err(peer, "Invalid r for %"PRIu64, f->id); |
|||
|
|||
return NULL; |
|||
} |
|||
|
|||
Pkt *accept_pkt_update_fee(struct peer *peer, const Pkt *pkt, u64 *feerate) |
|||
{ |
|||
const UpdateFee *f = pkt->update_fee; |
|||
|
|||
*feerate = f->fee_rate; |
|||
return NULL; |
|||
} |
|||
|
|||
Pkt *accept_pkt_commit(struct peer *peer, const Pkt *pkt, |
|||
secp256k1_ecdsa_signature *sig) |
|||
{ |
|||
const UpdateCommit *c = pkt->update_commit; |
|||
|
|||
if (!c->sig && sig) |
|||
return pkt_err(peer, "Expected signature"); |
|||
|
|||
if (!sig && c->sig) |
|||
return pkt_err(peer, "Unexpected signature"); |
|||
|
|||
if (!sig && !c->sig) |
|||
return NULL; |
|||
|
|||
if (!proto_to_signature(c->sig, sig)) |
|||
return pkt_err(peer, "Malformed signature"); |
|||
return NULL; |
|||
} |
|||
|
|||
Pkt *accept_pkt_revocation(struct peer *peer, const Pkt *pkt) |
|||
{ |
|||
const UpdateRevocation *r = pkt->update_revocation; |
|||
struct sha256 h, preimage; |
|||
|
|||
assert(peer->their_prev_revocation_hash); |
|||
proto_to_sha256(r->revocation_preimage, &preimage); |
|||
|
|||
/* FIXME-OLD #2:
|
|||
* |
|||
* The receiver of `update_revocation` MUST check that the |
|||
* SHA256 hash of `revocation_preimage` matches the previous commitment |
|||
* transaction, and MUST fail if it does not. |
|||
*/ |
|||
sha256(&h, &preimage, sizeof(preimage)); |
|||
if (!structeq(&h, peer->their_prev_revocation_hash)) { |
|||
log_unusual(peer->log, "Incorrect preimage for %"PRIu64, |
|||
peer->remote.commit->commit_num - 1); |
|||
return pkt_err(peer, "complete preimage incorrect"); |
|||
} |
|||
|
|||
// save revocation preimages in shachain
|
|||
if (!shachain_add_hash(&peer->their_preimages, |
|||
0xFFFFFFFFFFFFFFFFL |
|||
- (peer->remote.commit->commit_num - 1), |
|||
&preimage)) |
|||
return pkt_err(peer, "preimage not next in shachain"); |
|||
|
|||
log_debug(peer->log, "Got revocation preimage %"PRIu64, |
|||
peer->remote.commit->commit_num - 1); |
|||
|
|||
/* Clear the previous revocation hash. */ |
|||
peer->their_prev_revocation_hash |
|||
= tal_free(peer->their_prev_revocation_hash); |
|||
|
|||
/* Save next revocation hash. */ |
|||
proto_to_sha256(r->next_revocation_hash, |
|||
&peer->remote.next_revocation_hash); |
|||
return NULL; |
|||
} |
|||
|
|||
Pkt *accept_pkt_close_shutdown(struct peer *peer, const Pkt *pkt) |
|||
{ |
|||
const CloseShutdown *c = pkt->close_shutdown; |
|||
|
|||
peer->closing.their_script = tal_dup_arr(peer, u8, |
|||
c->scriptpubkey.data, |
|||
c->scriptpubkey.len, 0); |
|||
|
|||
/* FIXME-OLD #2:
|
|||
* |
|||
* 1. `OP_DUP` `OP_HASH160` `20` 20-bytes `OP_EQUALVERIFY` `OP_CHECKSIG` |
|||
* (pay to pubkey hash), OR |
|||
* 2. `OP_HASH160` `20` 20-bytes `OP_EQUAL` (pay to script hash), OR |
|||
* 3. `OP_0` `20` 20-bytes (version 0 pay to witness pubkey), OR |
|||
* 4. `OP_0` `32` 32-bytes (version 0 pay to witness script hash) |
|||
* |
|||
* A node receiving `close_shutdown` SHOULD fail the connection |
|||
* `script_pubkey` is not one of those forms. |
|||
*/ |
|||
if (!is_p2pkh(peer->closing.their_script) |
|||
&& !is_p2sh(peer->closing.their_script) |
|||
&& !is_p2wpkh(peer->closing.their_script) |
|||
&& !is_p2wsh(peer->closing.their_script)) { |
|||
log_broken_blob(peer->log, "Bad script_pubkey %s", |
|||
peer->closing.their_script, |
|||
tal_count(peer->closing.their_script)); |
|||
return pkt_err(peer, "Bad script_pubkey"); |
|||
} |
|||
|
|||
return NULL; |
|||
} |
|||
@ -1,478 +0,0 @@ |
|||
#include "chaintopology.h" |
|||
#include "db.h" |
|||
#include "failure.h" |
|||
#include "jsonrpc.h" |
|||
#include "lightningd.h" |
|||
#include "log.h" |
|||
#include "pay.h" |
|||
#include "peer.h" |
|||
#include "peer_internal.h" |
|||
#include "routing.h" |
|||
#include "sphinx.h" |
|||
#include <bitcoin/preimage.h> |
|||
#include <ccan/str/hex/hex.h> |
|||
#include <ccan/structeq/structeq.h> |
|||
#include <inttypes.h> |
|||
#include <sodium/randombytes.h> |
|||
|
|||
/* Outstanding "pay" commands. */ |
|||
struct pay_command { |
|||
struct list_node list; |
|||
struct sha256 rhash; |
|||
u64 msatoshi; |
|||
const struct pubkey *ids; |
|||
/* Set if this is in progress. */ |
|||
struct htlc *htlc; |
|||
/* Preimage if this succeeded. */ |
|||
const struct preimage *rval; |
|||
struct command *cmd; |
|||
}; |
|||
static void json_pay_success(struct command *cmd, const struct preimage *rval) |
|||
{ |
|||
struct json_result *response; |
|||
|
|||
response = new_json_result(cmd); |
|||
json_object_start(response, NULL); |
|||
json_add_hex(response, "preimage", rval, sizeof(*rval)); |
|||
json_object_end(response); |
|||
command_success(cmd, response); |
|||
} |
|||
|
|||
static void handle_json(struct command *cmd, const struct htlc *htlc, |
|||
const FailInfo *f) |
|||
{ |
|||
struct pubkey id; |
|||
const char *idstr = "INVALID"; |
|||
|
|||
if (htlc->r) { |
|||
json_pay_success(cmd, htlc->r); |
|||
return; |
|||
} |
|||
|
|||
if (!f) { |
|||
command_fail(cmd, "failed (bad message)"); |
|||
return; |
|||
} |
|||
|
|||
if (proto_to_pubkey(f->id, &id)) |
|||
idstr = pubkey_to_hexstr(cmd, &id); |
|||
|
|||
command_fail(cmd, |
|||
"failed: error code %u node %s reason %s", |
|||
f->error_code, idstr, f->reason ? f->reason : "unknown"); |
|||
} |
|||
|
|||
static void check_routing_failure(struct lightningd_state *dstate, |
|||
const struct pay_command *pc, |
|||
const FailInfo *f) |
|||
{ |
|||
size_t i; |
|||
struct pubkey id; |
|||
|
|||
if (!f) |
|||
return; |
|||
|
|||
/* FIXME: We remove route on *any* failure. */ |
|||
log_debug(dstate->base_log, "Seeking route for fail code %u", |
|||
f->error_code); |
|||
if (!proto_to_pubkey(f->id, &id)) { |
|||
log_add(dstate->base_log, " - bad node"); |
|||
return; |
|||
} |
|||
|
|||
log_add_struct(dstate->base_log, " node %s", struct pubkey, &id); |
|||
|
|||
/* Don't remove route if it's last node (obviously) */ |
|||
for (i = 0; i+1 < tal_count(pc->ids); i++) { |
|||
if (structeq(&pc->ids[i], &id)) { |
|||
remove_connection(dstate->rstate, &pc->ids[i], &pc->ids[i+1]); |
|||
return; |
|||
} |
|||
} |
|||
|
|||
if (structeq(&pc->ids[i], &id)) |
|||
log_debug(dstate->base_log, "Final node: ignoring"); |
|||
else |
|||
log_debug(dstate->base_log, "Node not on route: ignoring"); |
|||
} |
|||
|
|||
void complete_pay_command(struct lightningd_state *dstate, |
|||
const struct htlc *htlc) |
|||
{ |
|||
struct pay_command *i; |
|||
|
|||
list_for_each(&dstate->pay_commands, i, list) { |
|||
if (i->htlc == htlc) { |
|||
FailInfo *f = NULL; |
|||
|
|||
db_complete_pay_command(dstate, htlc); |
|||
|
|||
if (htlc->r) |
|||
i->rval = tal_dup(i, struct preimage, htlc->r); |
|||
else { |
|||
f = failinfo_unwrap(i->cmd, htlc->fail, |
|||
tal_count(htlc->fail)); |
|||
check_routing_failure(dstate, i, f); |
|||
} |
|||
|
|||
/* No longer connected to live HTLC. */ |
|||
i->htlc = NULL; |
|||
|
|||
/* Can be NULL if JSON RPC goes away. */ |
|||
if (i->cmd) |
|||
handle_json(i->cmd, htlc, f); |
|||
return; |
|||
} |
|||
} |
|||
|
|||
/* Can happen with testing low-level commands. */ |
|||
log_unusual(dstate->base_log, "No command for HTLC %"PRIu64" %s", |
|||
htlc->id, htlc->r ? "fulfill" : "fail"); |
|||
} |
|||
|
|||
/* When JSON RPC goes away, cmd is freed: detach from any running paycommand */ |
|||
static void remove_cmd_from_pc(struct command *cmd) |
|||
{ |
|||
struct pay_command *pc; |
|||
|
|||
list_for_each(&cmd->dstate->pay_commands, pc, list) { |
|||
if (pc->cmd == cmd) { |
|||
pc->cmd = NULL; |
|||
return; |
|||
} |
|||
} |
|||
/* We can reach here, in the case where another pay command
|
|||
* re-uses the pc->cmd before we get around to cleaning up. */ |
|||
} |
|||
|
|||
static struct pay_command *find_pay_command(struct lightningd_state *dstate, |
|||
const struct sha256 *rhash) |
|||
{ |
|||
struct pay_command *pc; |
|||
|
|||
list_for_each(&dstate->pay_commands, pc, list) { |
|||
if (structeq(rhash, &pc->rhash)) |
|||
return pc; |
|||
} |
|||
return NULL; |
|||
} |
|||
|
|||
/* For database restore. */ |
|||
bool pay_add(struct lightningd_state *dstate, |
|||
const struct sha256 *rhash, |
|||
u64 msatoshi, |
|||
const struct pubkey *ids, |
|||
struct htlc *htlc, |
|||
const u8 *fail UNNEEDED, |
|||
const struct preimage *r) |
|||
{ |
|||
struct pay_command *pc; |
|||
|
|||
if (find_pay_command(dstate, rhash)) |
|||
return false; |
|||
|
|||
pc = tal(dstate, struct pay_command); |
|||
pc->rhash = *rhash; |
|||
pc->msatoshi = msatoshi; |
|||
pc->ids = tal_dup_arr(pc, struct pubkey, ids, tal_count(ids), 0); |
|||
pc->htlc = htlc; |
|||
if (r) |
|||
pc->rval = tal_dup(pc, struct preimage, r); |
|||
else |
|||
pc->rval = NULL; |
|||
pc->cmd = NULL; |
|||
|
|||
list_add_tail(&dstate->pay_commands, &pc->list); |
|||
return true; |
|||
} |
|||
|
|||
static void json_add_route(struct json_result *response, |
|||
const struct pubkey *id, |
|||
u64 amount, unsigned int delay) |
|||
{ |
|||
json_object_start(response, NULL); |
|||
json_add_pubkey(response, "id", id); |
|||
json_add_u64(response, "msatoshi", amount); |
|||
json_add_num(response, "delay", delay); |
|||
json_object_end(response); |
|||
} |
|||
|
|||
static void json_getroute(struct command *cmd, |
|||
const char *buffer, const jsmntok_t *params) |
|||
{ |
|||
struct pubkey id; |
|||
jsmntok_t *idtok, *msatoshitok, *riskfactortok; |
|||
struct json_result *response; |
|||
size_t i; |
|||
u64 msatoshi; |
|||
double riskfactor; |
|||
|
|||
if (!json_get_params(buffer, params, |
|||
"id", &idtok, |
|||
"msatoshi", &msatoshitok, |
|||
"riskfactor", &riskfactortok, |
|||
NULL)) { |
|||
command_fail(cmd, "Need id, msatoshi and riskfactor"); |
|||
return; |
|||
} |
|||
|
|||
if (!pubkey_from_hexstr(buffer + idtok->start, |
|||
idtok->end - idtok->start, &id)) { |
|||
command_fail(cmd, "Invalid id"); |
|||
return; |
|||
} |
|||
|
|||
if (!json_tok_u64(buffer, msatoshitok, &msatoshi)) { |
|||
command_fail(cmd, "'%.*s' is not a valid number", |
|||
(int)(msatoshitok->end - msatoshitok->start), |
|||
buffer + msatoshitok->start); |
|||
return; |
|||
} |
|||
|
|||
if (!json_tok_double(buffer, riskfactortok, &riskfactor)) { |
|||
command_fail(cmd, "'%.*s' is not a valid double", |
|||
(int)(riskfactortok->end - riskfactortok->start), |
|||
buffer + riskfactortok->start); |
|||
return; |
|||
} |
|||
|
|||
struct route_hop *hops = get_route(cmd, cmd->dstate->rstate, &cmd->dstate->id, &id, msatoshi, riskfactor); |
|||
|
|||
if (!hops) { |
|||
command_fail(cmd, "no route found"); |
|||
return; |
|||
} |
|||
|
|||
response = new_json_result(cmd); |
|||
json_object_start(response, NULL); |
|||
json_array_start(response, "route"); |
|||
for (i = 0; i < tal_count(hops); i++) |
|||
json_add_route(response, |
|||
&hops[i].nodeid, hops[i].amount, hops[i].delay); |
|||
json_array_end(response); |
|||
json_object_end(response); |
|||
command_success(cmd, response); |
|||
} |
|||
|
|||
static const struct json_command getroute_command = { |
|||
"getroute", |
|||
json_getroute, |
|||
"Return route to {id} for {msatoshi}, using {riskfactor}", |
|||
"Returns a {route} array of {id} {msatoshi} {delay}: msatoshi and delay (in blocks) is cumulative." |
|||
}; |
|||
AUTODATA(json_command, &getroute_command); |
|||
|
|||
static void json_sendpay(struct command *cmd, |
|||
const char *buffer, const jsmntok_t *params) |
|||
{ |
|||
struct pubkey *ids; |
|||
jsmntok_t *routetok, *rhashtok; |
|||
const jsmntok_t *t, *end; |
|||
unsigned int delay; |
|||
size_t n_hops; |
|||
struct sha256 rhash; |
|||
struct peer *peer; |
|||
struct pay_command *pc; |
|||
bool replacing = false; |
|||
const u8 *onion; |
|||
u8 sessionkey[32]; |
|||
enum fail_error error_code; |
|||
const char *err; |
|||
struct hoppayload *hoppayloads; |
|||
u64 amount, lastamount; |
|||
struct onionpacket *packet; |
|||
|
|||
if (!json_get_params(buffer, params, |
|||
"route", &routetok, |
|||
"rhash", &rhashtok, |
|||
NULL)) { |
|||
command_fail(cmd, "Need route and rhash"); |
|||
return; |
|||
} |
|||
|
|||
if (!hex_decode(buffer + rhashtok->start, |
|||
rhashtok->end - rhashtok->start, |
|||
&rhash, sizeof(rhash))) { |
|||
command_fail(cmd, "'%.*s' is not a valid sha256 hash", |
|||
(int)(rhashtok->end - rhashtok->start), |
|||
buffer + rhashtok->start); |
|||
return; |
|||
} |
|||
|
|||
if (routetok->type != JSMN_ARRAY) { |
|||
command_fail(cmd, "'%.*s' is not an array", |
|||
(int)(routetok->end - routetok->start), |
|||
buffer + routetok->start); |
|||
return; |
|||
} |
|||
|
|||
end = json_next(routetok); |
|||
n_hops = 0; |
|||
ids = tal_arr(cmd, struct pubkey, n_hops); |
|||
hoppayloads = tal_arr(cmd, struct hoppayload, 0); |
|||
for (t = routetok + 1; t < end; t = json_next(t)) { |
|||
const jsmntok_t *amttok, *idtok, *delaytok; |
|||
|
|||
if (t->type != JSMN_OBJECT) { |
|||
command_fail(cmd, "route %zu '%.*s' is not an object", |
|||
n_hops, |
|||
(int)(t->end - t->start), |
|||
buffer + t->start); |
|||
return; |
|||
} |
|||
amttok = json_get_member(buffer, t, "msatoshi"); |
|||
idtok = json_get_member(buffer, t, "id"); |
|||
delaytok = json_get_member(buffer, t, "delay"); |
|||
if (!amttok || !idtok || !delaytok) { |
|||
command_fail(cmd, "route %zu needs msatoshi/id/delay", |
|||
n_hops); |
|||
return; |
|||
} |
|||
|
|||
if (n_hops == 0) { |
|||
/* What we will send */ |
|||
if (!json_tok_u64(buffer, amttok, &amount)) { |
|||
command_fail(cmd, "route %zu invalid msatoshi", n_hops); |
|||
return; |
|||
} |
|||
lastamount = amount; |
|||
} else{ |
|||
/* What that hop will forward */ |
|||
tal_resize(&hoppayloads, n_hops); |
|||
memset(&hoppayloads[n_hops-1], 0, sizeof(struct hoppayload)); |
|||
if (!json_tok_u64(buffer, amttok, &hoppayloads[n_hops-1].amt_to_forward)) { |
|||
command_fail(cmd, "route %zu invalid msatoshi", n_hops); |
|||
return; |
|||
} |
|||
/* FIXME: Populate outgoing_cltv_value */ |
|||
lastamount = hoppayloads[n_hops-1].amt_to_forward; |
|||
} |
|||
|
|||
tal_resize(&ids, n_hops+1); |
|||
memset(&ids[n_hops], 0, sizeof(ids[n_hops])); |
|||
if (!pubkey_from_hexstr(buffer + idtok->start, |
|||
idtok->end - idtok->start, |
|||
&ids[n_hops])) { |
|||
command_fail(cmd, "route %zu invalid id", n_hops); |
|||
return; |
|||
} |
|||
/* Only need first delay. */ |
|||
if (n_hops == 0 && !json_tok_number(buffer, delaytok, &delay)) { |
|||
command_fail(cmd, "route %zu invalid delay", n_hops); |
|||
return; |
|||
} |
|||
n_hops++; |
|||
} |
|||
|
|||
/* Add payload for final hop */ |
|||
tal_resize(&hoppayloads, n_hops); |
|||
memset(&hoppayloads[n_hops-1], 0, sizeof(struct hoppayload)); |
|||
|
|||
if (n_hops == 0) { |
|||
command_fail(cmd, "Empty route"); |
|||
return; |
|||
} |
|||
|
|||
pc = find_pay_command(cmd->dstate, &rhash); |
|||
if (pc) { |
|||
replacing = true; |
|||
log_debug(cmd->dstate->base_log, "json_sendpay: found previous"); |
|||
if (pc->htlc) { |
|||
log_add(cmd->dstate->base_log, "... still in progress"); |
|||
command_fail(cmd, "still in progress"); |
|||
return; |
|||
} |
|||
if (pc->rval) { |
|||
size_t old_nhops = tal_count(pc->ids); |
|||
log_add(cmd->dstate->base_log, "... succeeded"); |
|||
/* Must match successful payment parameters. */ |
|||
if (pc->msatoshi != lastamount) { |
|||
command_fail(cmd, |
|||
"already succeeded with amount %" |
|||
PRIu64, pc->msatoshi); |
|||
return; |
|||
} |
|||
if (!structeq(&pc->ids[old_nhops-1], &ids[n_hops-1])) { |
|||
char *previd; |
|||
previd = pubkey_to_hexstr(cmd, |
|||
&pc->ids[old_nhops-1]); |
|||
command_fail(cmd, |
|||
"already succeeded to %s", |
|||
previd); |
|||
return; |
|||
} |
|||
json_pay_success(cmd, pc->rval); |
|||
return; |
|||
} |
|||
log_add(cmd->dstate->base_log, "... retrying"); |
|||
} |
|||
|
|||
peer = find_peer(cmd->dstate, &ids[0]); |
|||
if (!peer) { |
|||
command_fail(cmd, "no connection to first peer found"); |
|||
return; |
|||
} |
|||
|
|||
randombytes_buf(&sessionkey, sizeof(sessionkey)); |
|||
|
|||
/* Onion will carry us from first peer onwards. */ |
|||
packet = create_onionpacket(cmd, ids, hoppayloads, sessionkey, |
|||
rhash.u.u8, sizeof(struct sha256)); |
|||
onion = serialize_onionpacket(cmd, packet); |
|||
|
|||
if (pc) |
|||
pc->ids = tal_free(pc->ids); |
|||
else |
|||
pc = tal(cmd->dstate, struct pay_command); |
|||
pc->cmd = cmd; |
|||
pc->rhash = rhash; |
|||
pc->rval = NULL; |
|||
pc->ids = tal_steal(pc, ids); |
|||
pc->msatoshi = lastamount; |
|||
|
|||
/* Expiry for HTLCs is absolute. And add one to give some margin. */ |
|||
err = command_htlc_add(peer, amount, |
|||
delay + get_block_height(cmd->dstate->topology) |
|||
+ 1, |
|||
&rhash, NULL, |
|||
onion, &error_code, &pc->htlc); |
|||
if (err) { |
|||
command_fail(cmd, "could not add htlc: %u: %s", error_code, err); |
|||
tal_free(pc); |
|||
return; |
|||
} |
|||
|
|||
if (replacing) { |
|||
if (!db_replace_pay_command(cmd->dstate, &pc->rhash, |
|||
pc->ids, pc->msatoshi, |
|||
pc->htlc)) { |
|||
command_fail(cmd, "database error"); |
|||
/* We could reconnect, but db error is *bad*. */ |
|||
peer_fail(peer, __func__); |
|||
tal_free(pc); |
|||
return; |
|||
} |
|||
} else { |
|||
if (!db_new_pay_command(cmd->dstate, &pc->rhash, |
|||
pc->ids, pc->msatoshi, |
|||
pc->htlc)) { |
|||
command_fail(cmd, "database error"); |
|||
/* We could reconnect, but db error is *bad*. */ |
|||
peer_fail(peer, __func__); |
|||
tal_free(pc); |
|||
return; |
|||
} |
|||
} |
|||
|
|||
/* Wait until we get response. */ |
|||
list_add_tail(&cmd->dstate->pay_commands, &pc->list); |
|||
tal_add_destructor(cmd, remove_cmd_from_pc); |
|||
} |
|||
|
|||
static const struct json_command sendpay_command = { |
|||
"sendpay", |
|||
json_sendpay, |
|||
"Send along {route} in return for preimage of {rhash}", |
|||
"Returns the {preimage} on success" |
|||
}; |
|||
AUTODATA(json_command, &sendpay_command); |
|||
@ -1,19 +0,0 @@ |
|||
#ifndef LIGHTNING_DAEMON_PAY_H |
|||
#define LIGHTNING_DAEMON_PAY_H |
|||
#include "config.h" |
|||
|
|||
struct htlc; |
|||
struct lightningd_state; |
|||
struct preimage; |
|||
|
|||
void complete_pay_command(struct lightningd_state *dstate, |
|||
const struct htlc *htlc); |
|||
|
|||
bool pay_add(struct lightningd_state *dstate, |
|||
const struct sha256 *rhash, |
|||
u64 msatoshi, |
|||
const struct pubkey *ids, |
|||
struct htlc *htlc, |
|||
const u8 *fail, |
|||
const struct preimage *r); |
|||
#endif /* LIGHTNING_DAEMON_PAY_H */ |
|||
File diff suppressed because it is too large
@ -1,91 +0,0 @@ |
|||
#ifndef LIGHTNING_DAEMON_PEER_H |
|||
#define LIGHTNING_DAEMON_PEER_H |
|||
#include "config.h" |
|||
#include "bitcoin/locktime.h" |
|||
#include "bitcoin/privkey.h" |
|||
#include "bitcoin/pubkey.h" |
|||
#include "bitcoin/script.h" |
|||
#include "bitcoin/shadouble.h" |
|||
#include "channel.h" |
|||
#include "failure.h" |
|||
#include "feechange.h" |
|||
#include "htlc.h" |
|||
#include "lightning.pb-c.h" |
|||
#include "netaddr.h" |
|||
#include "protobuf_convert.h" |
|||
#include "state.h" |
|||
#include "wire/gen_peer_wire.h" |
|||
#include <ccan/crypto/sha256/sha256.h> |
|||
#include <ccan/crypto/shachain/shachain.h> |
|||
#include <ccan/list/list.h> |
|||
#include <ccan/time/time.h> |
|||
|
|||
struct log; |
|||
struct lightningd_state; |
|||
struct peer; |
|||
|
|||
/* Mapping for id -> network address. */ |
|||
struct peer_address { |
|||
struct list_node list; |
|||
struct pubkey id; |
|||
struct netaddr addr; |
|||
}; |
|||
|
|||
void setup_listeners(struct lightningd_state *dstate); |
|||
|
|||
void peer_debug(struct peer *peer, const char *fmt, ...) |
|||
PRINTF_FMT(2,3); |
|||
|
|||
struct peer *find_peer(struct lightningd_state *dstate, const struct pubkey *id); |
|||
struct peer *find_peer_by_pkhash(struct lightningd_state *dstate, const u8 *pkhash); |
|||
|
|||
struct peer *new_peer(struct lightningd_state *dstate, |
|||
struct log *log, |
|||
enum state state, |
|||
bool offer_anchor); |
|||
|
|||
/* Populates very first peer->{local,remote}.commit->{tx,cstate} */ |
|||
bool setup_first_commit(struct peer *peer); |
|||
|
|||
/* Whenever we send a signature, remember the txid -> commit_num mapping */ |
|||
void peer_add_their_commit(struct peer *peer, |
|||
const struct sha256_double *txid, u64 commit_num); |
|||
|
|||
/* Allocate a new commit_info struct. */ |
|||
struct commit_info *new_commit_info(const tal_t *ctx, u64 commit_num); |
|||
|
|||
/* Freeing removes from map, too */ |
|||
struct htlc *peer_new_htlc(struct peer *peer, |
|||
u64 id, |
|||
u64 msatoshi, |
|||
const struct sha256 *rhash, |
|||
u32 expiry, |
|||
const u8 *route, |
|||
size_t route_len, |
|||
struct htlc *src, |
|||
enum htlc_state state); |
|||
|
|||
const char *command_htlc_add(struct peer *peer, u64 msatoshi, |
|||
unsigned int expiry, |
|||
const struct sha256 *rhash, |
|||
struct htlc *src, |
|||
const u8 *route, |
|||
enum fail_error *error_code, |
|||
struct htlc **htlc); |
|||
|
|||
/* Peer has an issue, breakdown and fail. */ |
|||
void peer_fail(struct peer *peer, const char *caller); |
|||
|
|||
void peer_watch_anchor(struct peer *peer, int depth); |
|||
|
|||
struct bitcoin_tx *peer_create_close_tx(const tal_t *ctx, |
|||
struct peer *peer, u64 fee); |
|||
|
|||
u32 get_peer_min_block(struct lightningd_state *dstate); |
|||
|
|||
void debug_dump_peers(struct lightningd_state *dstate); |
|||
|
|||
void reconnect_peers(struct lightningd_state *dstate); |
|||
void rebroadcast_anchors(struct lightningd_state *dstate); |
|||
void cleanup_peers(struct lightningd_state *dstate); |
|||
#endif /* LIGHTNING_DAEMON_PEER_H */ |
|||
@ -1,210 +0,0 @@ |
|||
/* This header holds structure definitions for struct peer, which must
|
|||
* not be exposed to ../lightningd/ */ |
|||
#ifndef LIGHTNING_DAEMON_PEER_INTERNAL_H |
|||
#define LIGHTNING_DAEMON_PEER_INTERNAL_H |
|||
#include "config.h" |
|||
|
|||
struct anchor_input { |
|||
struct sha256_double txid; |
|||
unsigned int index; |
|||
/* Amount of input (satoshis), and output (satoshis) */ |
|||
u64 in_amount, out_amount; |
|||
/* Wallet entry to use to spend. */ |
|||
struct pubkey walletkey; |
|||
}; |
|||
|
|||
/* Information we remember for their commitment txs which we signed.
|
|||
* |
|||
* Given the commit_num, we can use shachain to derive the revocation preimage |
|||
* (if we've received it yet: we might have not, for the last). |
|||
*/ |
|||
struct their_commit { |
|||
struct list_node list; |
|||
|
|||
struct sha256_double txid; |
|||
u64 commit_num; |
|||
}; |
|||
|
|||
struct commit_info { |
|||
/* Commit number (0 == from open) */ |
|||
u64 commit_num; |
|||
/* Revocation hash. */ |
|||
struct sha256 revocation_hash; |
|||
/* Commit tx & txid */ |
|||
struct bitcoin_tx *tx; |
|||
struct sha256_double txid; |
|||
/* Channel state for this tx. */ |
|||
struct channel_state *cstate; |
|||
/* Other side's signature for last commit tx (if known) */ |
|||
secp256k1_ecdsa_signature *sig; |
|||
/* Order which commit was sent (theirs) / revocation was sent (ours) */ |
|||
s64 order; |
|||
}; |
|||
|
|||
struct peer_visible_state { |
|||
/* Is this side funding the channel? */ |
|||
bool offer_anchor; |
|||
/* Key for commitment tx inputs, then key for commitment tx outputs */ |
|||
struct pubkey commitkey, finalkey; |
|||
/* How long to they want the other's outputs locked (blocks) */ |
|||
struct rel_locktime locktime; |
|||
/* Minimum depth of anchor before channel usable. */ |
|||
unsigned int mindepth; |
|||
/* Commitment fee they're offering (satoshi). */ |
|||
u64 commit_fee_rate; |
|||
/* Revocation hash for next commit tx. */ |
|||
struct sha256 next_revocation_hash; |
|||
/* Commit txs: last one is current. */ |
|||
struct commit_info *commit; |
|||
|
|||
/* cstate to generate next commitment tx. */ |
|||
struct channel_state *staging_cstate; |
|||
}; |
|||
|
|||
struct peer { |
|||
/* dstate->peers list */ |
|||
struct list_node list; |
|||
|
|||
/* State in state machine. */ |
|||
enum state state; |
|||
|
|||
/* Network connection. */ |
|||
struct io_conn *conn; |
|||
|
|||
/* Are we connected now? (Crypto handshake completed). */ |
|||
bool connected; |
|||
|
|||
/* If we're doing an open, this is the command which triggered it */ |
|||
struct command *open_jsoncmd; |
|||
|
|||
/* If we're doing a commit, this is the command which triggered it */ |
|||
struct command *commit_jsoncmd; |
|||
|
|||
/* Global state. */ |
|||
struct lightningd_state *dstate; |
|||
|
|||
/* Their ID. */ |
|||
struct pubkey *id; |
|||
|
|||
/* Order counter for transmission of revocations/commitments. */ |
|||
s64 order_counter; |
|||
|
|||
/* Current received packet. */ |
|||
Pkt *inpkt; |
|||
|
|||
/* Queue of output packets. */ |
|||
Pkt **outpkt; |
|||
|
|||
/* Their commitments we have signed (which could appear on chain). */ |
|||
struct list_head their_commits; |
|||
|
|||
/* Number of commitment signatures we've received. */ |
|||
u64 their_commitsigs; |
|||
|
|||
/* Anchor tx output */ |
|||
struct { |
|||
struct sha256_double txid; |
|||
unsigned int index; |
|||
u64 satoshis; |
|||
u8 *witnessscript; |
|||
|
|||
/* Minimum possible depth for anchor */ |
|||
unsigned int min_depth; |
|||
|
|||
/* If we're creating anchor, this tells us where to source it */ |
|||
struct anchor_input *input; |
|||
|
|||
/* If we created it, we keep entire tx. */ |
|||
const struct bitcoin_tx *tx; |
|||
|
|||
/* Depth to trigger anchor if still opening, or -1. */ |
|||
int ok_depth; |
|||
|
|||
/* Did we create anchor? */ |
|||
bool ours; |
|||
} anchor; |
|||
|
|||
struct { |
|||
/* Their signature for our current commit sig. */ |
|||
secp256k1_ecdsa_signature theirsig; |
|||
/* The watch we have on a live commit tx. */ |
|||
struct txwatch *watch; |
|||
} cur_commit; |
|||
|
|||
/* Counter to make unique HTLC ids. */ |
|||
u64 htlc_id_counter; |
|||
|
|||
/* Mutual close info. */ |
|||
struct { |
|||
/* Our last suggested closing fee. */ |
|||
u64 our_fee; |
|||
/* If they've offered a signature, these are set: */ |
|||
secp256k1_ecdsa_signature *their_sig; |
|||
/* If their_sig is non-NULL, this is the fee. */ |
|||
u64 their_fee; |
|||
/* scriptPubKey we/they want for closing. */ |
|||
u8 *our_script, *their_script; |
|||
/* Last sent (in case we need to retransmit) */ |
|||
s64 shutdown_order, closing_order; |
|||
/* How many closing sigs have we receieved? */ |
|||
u32 sigs_in; |
|||
} closing; |
|||
|
|||
/* If we're closing on-chain */ |
|||
struct { |
|||
/* Everything (watches, resolved[], etc) tal'ed off this:
|
|||
* The commit which spends the anchor tx. */ |
|||
const struct bitcoin_tx *tx; |
|||
struct sha256_double txid; |
|||
|
|||
/* If >= 0, indicates which txout is to us and to them. */ |
|||
int to_us_idx, to_them_idx; |
|||
/* Maps what txouts are HTLCs (NULL implies to_us/them_idx). */ |
|||
struct htlc **htlcs; |
|||
/* Witness scripts for each output (where appropriate) */ |
|||
const u8 **wscripts; |
|||
/* The tx which resolves each txout. */ |
|||
const struct bitcoin_tx **resolved; |
|||
} onchain; |
|||
|
|||
/* All HTLCs. */ |
|||
struct htlc_map htlcs; |
|||
|
|||
/* We only track one feechange per state: last one counts. */ |
|||
struct feechange *feechanges[FEECHANGE_STATE_INVALID]; |
|||
|
|||
/* Current ongoing packetflow */ |
|||
struct io_data *io_data; |
|||
|
|||
/* What happened. */ |
|||
struct log *log; |
|||
|
|||
/* Things we're watching for (see watches.c) */ |
|||
struct list_head watches; |
|||
|
|||
/* Timeout for collecting changes before sending commit. */ |
|||
struct oneshot *commit_timer; |
|||
|
|||
/* Private keys for dealing with this peer. */ |
|||
struct peer_secrets *secrets; |
|||
|
|||
/* Our route connection to peer: NULL until we are in normal mode. */ |
|||
struct node_connection *nc; |
|||
|
|||
/* For testing. */ |
|||
bool fake_close; |
|||
bool output_enabled; |
|||
|
|||
/* Stuff we have in common. */ |
|||
struct peer_visible_state local, remote; |
|||
|
|||
/* If we have sent a new commit tx, but not received their revocation */ |
|||
struct sha256 *their_prev_revocation_hash; |
|||
|
|||
/* this is where we will store their revocation preimages*/ |
|||
struct shachain their_preimages; |
|||
|
|||
/* High water mark for the staggered broadcast */ |
|||
u64 broadcast_index; |
|||
}; |
|||
#endif /* LIGHTNING_DAEMON_PEER_INTERNAL_H */ |
|||
@ -1,169 +0,0 @@ |
|||
#include "jsonrpc.h" |
|||
#include "lightningd.h" |
|||
#include "log.h" |
|||
#include "routing.h" |
|||
|
|||
static void json_add_route(struct command *cmd, |
|||
const char *buffer, const jsmntok_t *params) |
|||
{ |
|||
jsmntok_t *srctok, *dsttok, *basetok, *vartok, *delaytok, *minblockstok; |
|||
struct pubkey src, dst; |
|||
u32 base, var, delay, minblocks; |
|||
|
|||
if (!json_get_params(buffer, params, |
|||
"src", &srctok, |
|||
"dst", &dsttok, |
|||
"base", &basetok, |
|||
"var", &vartok, |
|||
"delay", &delaytok, |
|||
"minblocks", &minblockstok, |
|||
NULL)) { |
|||
command_fail(cmd, "Need src, dst, base, var, delay & minblocks"); |
|||
return; |
|||
} |
|||
|
|||
if (!pubkey_from_hexstr(buffer + srctok->start, |
|||
srctok->end - srctok->start, &src)) { |
|||
command_fail(cmd, "src %.*s not valid", |
|||
srctok->end - srctok->start, |
|||
buffer + srctok->start); |
|||
return; |
|||
} |
|||
|
|||
if (!pubkey_from_hexstr(buffer + dsttok->start, |
|||
dsttok->end - dsttok->start, &dst)) { |
|||
command_fail(cmd, "dst %.*s not valid", |
|||
dsttok->end - dsttok->start, |
|||
buffer + dsttok->start); |
|||
return; |
|||
} |
|||
|
|||
if (!json_tok_number(buffer, basetok, &base) |
|||
|| !json_tok_number(buffer, vartok, &var) |
|||
|| !json_tok_number(buffer, delaytok, &delay) |
|||
|| !json_tok_number(buffer, minblockstok, &minblocks)) { |
|||
command_fail(cmd, |
|||
"base, var, delay and minblocks must be numbers"); |
|||
return; |
|||
} |
|||
|
|||
add_connection(cmd->dstate->rstate, &src, &dst, base, var, delay, minblocks); |
|||
command_success(cmd, null_response(cmd)); |
|||
} |
|||
|
|||
static const struct json_command dev_add_route_command = { |
|||
"dev-add-route", |
|||
json_add_route, |
|||
"Add route from {src} to {dst}, {base} rate in msatoshi, {var} rate in msatoshi, {delay} blocks delay and {minblocks} minimum timeout", |
|||
"Returns an empty result on success" |
|||
}; |
|||
AUTODATA(json_command, &dev_add_route_command); |
|||
|
|||
static void json_getchannels(struct command *cmd, |
|||
const char *buffer, const jsmntok_t *params) |
|||
{ |
|||
struct json_result *response = new_json_result(cmd); |
|||
struct node_map_iter it; |
|||
struct node *n; |
|||
struct node_map *nodes = cmd->dstate->rstate->nodes; |
|||
struct node_connection *c; |
|||
int num_conn, i; |
|||
|
|||
json_object_start(response, NULL); |
|||
json_array_start(response, "channels"); |
|||
for (n = node_map_first(nodes, &it); n; n = node_map_next(nodes, &it)) { |
|||
num_conn = tal_count(n->out); |
|||
for (i = 0; i < num_conn; i++){ |
|||
c = n->out[i]; |
|||
json_object_start(response, NULL); |
|||
json_add_pubkey(response, "from", &n->id); |
|||
json_add_pubkey(response, "to", &c->dst->id); |
|||
json_add_num(response, "base_fee", c->base_fee); |
|||
json_add_num(response, "proportional_fee", c->proportional_fee); |
|||
json_add_num(response, "expiry", c->delay); |
|||
json_add_bool(response, "active", c->active); |
|||
json_object_end(response); |
|||
} |
|||
} |
|||
json_array_end(response); |
|||
json_object_end(response); |
|||
command_success(cmd, response); |
|||
} |
|||
|
|||
static const struct json_command getchannels_command = { |
|||
"getchannels", |
|||
json_getchannels, |
|||
"List all known channels.", |
|||
"Returns a 'channels' array with all known channels including their fees." |
|||
}; |
|||
AUTODATA(json_command, &getchannels_command); |
|||
|
|||
static void json_routefail(struct command *cmd, |
|||
const char *buffer, const jsmntok_t *params) |
|||
{ |
|||
jsmntok_t *enabletok; |
|||
bool enable; |
|||
|
|||
if (!json_get_params(buffer, params, |
|||
"enable", &enabletok, |
|||
NULL)) { |
|||
command_fail(cmd, "Need enable"); |
|||
return; |
|||
} |
|||
|
|||
if (!json_tok_bool(buffer, enabletok, &enable)) { |
|||
command_fail(cmd, "enable must be true or false"); |
|||
return; |
|||
} |
|||
|
|||
log_debug(cmd->dstate->base_log, "dev-routefail: routefail %s", |
|||
enable ? "enabled" : "disabled"); |
|||
cmd->dstate->dev_never_routefail = !enable; |
|||
|
|||
command_success(cmd, null_response(cmd)); |
|||
} |
|||
static const struct json_command dev_routefail_command = { |
|||
"dev-routefail", |
|||
json_routefail, |
|||
"FAIL htlcs that we can't route if {enable}", |
|||
"Returns an empty result on success" |
|||
}; |
|||
AUTODATA(json_command, &dev_routefail_command); |
|||
|
|||
static void json_getnodes(struct command *cmd, |
|||
const char *buffer, const jsmntok_t *params) |
|||
{ |
|||
struct json_result *response = new_json_result(cmd); |
|||
struct node *n; |
|||
struct node_map_iter i; |
|||
size_t j; |
|||
|
|||
n = node_map_first(cmd->dstate->rstate->nodes, &i); |
|||
|
|||
json_object_start(response, NULL); |
|||
json_array_start(response, "nodes"); |
|||
|
|||
while (n != NULL) { |
|||
json_object_start(response, NULL); |
|||
json_add_pubkey(response, "nodeid", &n->id); |
|||
json_array_start(response, "addresses"); |
|||
for (j=0; j<tal_count(n->addresses); j++) { |
|||
json_add_address(response, NULL, &n->addresses[j]); |
|||
} |
|||
json_array_end(response); |
|||
json_object_end(response); |
|||
n = node_map_next(cmd->dstate->rstate->nodes, &i); |
|||
} |
|||
|
|||
json_array_end(response); |
|||
json_object_end(response); |
|||
command_success(cmd, response); |
|||
} |
|||
|
|||
static const struct json_command getnodes_command = { |
|||
"getnodes", |
|||
json_getnodes, |
|||
"List all known nodes in the network.", |
|||
"Returns a 'nodes' array" |
|||
}; |
|||
AUTODATA(json_command, &getnodes_command); |
|||
@ -1,251 +0,0 @@ |
|||
#include "bitcoin/privkey.h" |
|||
#include "bitcoin/shadouble.h" |
|||
#include "bitcoin/signature.h" |
|||
#include "lightningd.h" |
|||
#include "log.h" |
|||
#include "peer.h" |
|||
#include "peer_internal.h" |
|||
#include "secrets.h" |
|||
#include "utils.h" |
|||
#include <ccan/crypto/sha256/sha256.h> |
|||
#include <ccan/crypto/shachain/shachain.h> |
|||
#include <ccan/mem/mem.h> |
|||
#include <ccan/noerr/noerr.h> |
|||
#include <ccan/read_write_all/read_write_all.h> |
|||
#include <ccan/short_types/short_types.h> |
|||
#include <ccan/tal/str/str.h> |
|||
#include <errno.h> |
|||
#include <fcntl.h> |
|||
#include <secp256k1.h> |
|||
#include <sodium/randombytes.h> |
|||
#include <sys/stat.h> |
|||
#include <sys/types.h> |
|||
#include <unistd.h> |
|||
|
|||
void privkey_sign(struct lightningd_state *dstate, const void *src, size_t len, |
|||
secp256k1_ecdsa_signature *sig) |
|||
{ |
|||
struct sha256_double h; |
|||
|
|||
sha256_double(&h, memcheck(src, len), len); |
|||
sign_hash(dstate->privkey, &h, sig); |
|||
} |
|||
|
|||
struct peer_secrets { |
|||
/* Two private keys, one for commit txs, one for final output. */ |
|||
struct privkey commit, final; |
|||
/* Seed from which we generate revocation hashes. */ |
|||
struct sha256 revocation_seed; |
|||
}; |
|||
|
|||
void peer_sign_theircommit(const struct peer *peer, |
|||
struct bitcoin_tx *commit, |
|||
secp256k1_ecdsa_signature *sig) |
|||
{ |
|||
/* Commit tx only has one input: that of the anchor. */ |
|||
sign_tx_input(commit, 0, |
|||
NULL, |
|||
peer->anchor.witnessscript, |
|||
&peer->secrets->commit, |
|||
&peer->local.commitkey, |
|||
sig); |
|||
} |
|||
|
|||
void peer_sign_ourcommit(const struct peer *peer, |
|||
struct bitcoin_tx *commit, |
|||
secp256k1_ecdsa_signature *sig) |
|||
{ |
|||
/* Commit tx only has one input: that of the anchor. */ |
|||
sign_tx_input(commit, 0, |
|||
NULL, |
|||
peer->anchor.witnessscript, |
|||
&peer->secrets->commit, |
|||
&peer->local.commitkey, |
|||
sig); |
|||
} |
|||
|
|||
void peer_sign_spend(const struct peer *peer, |
|||
struct bitcoin_tx *spend, |
|||
const u8 *commit_witnessscript, |
|||
secp256k1_ecdsa_signature *sig) |
|||
{ |
|||
/* Spend tx only has one input: that of the commit tx. */ |
|||
sign_tx_input(spend, 0, |
|||
NULL, |
|||
commit_witnessscript, |
|||
&peer->secrets->final, |
|||
&peer->local.finalkey, |
|||
sig); |
|||
} |
|||
|
|||
void peer_sign_htlc_refund(const struct peer *peer, |
|||
struct bitcoin_tx *spend, |
|||
const u8 *htlc_witnessscript, |
|||
secp256k1_ecdsa_signature *sig) |
|||
{ |
|||
/* Spend tx only has one input: that of the commit tx. */ |
|||
sign_tx_input(spend, 0, |
|||
NULL, |
|||
htlc_witnessscript, |
|||
&peer->secrets->final, |
|||
&peer->local.finalkey, |
|||
sig); |
|||
} |
|||
|
|||
void peer_sign_htlc_fulfill(const struct peer *peer, |
|||
struct bitcoin_tx *spend, |
|||
const u8 *htlc_witnessscript, |
|||
secp256k1_ecdsa_signature *sig) |
|||
{ |
|||
/* Spend tx only has one input: that of the commit tx. */ |
|||
sign_tx_input(spend, 0, |
|||
NULL, |
|||
htlc_witnessscript, |
|||
&peer->secrets->final, |
|||
&peer->local.finalkey, |
|||
sig); |
|||
} |
|||
|
|||
void peer_sign_mutual_close(const struct peer *peer, |
|||
struct bitcoin_tx *close, |
|||
secp256k1_ecdsa_signature *sig) |
|||
{ |
|||
sign_tx_input(close, 0, |
|||
NULL, |
|||
peer->anchor.witnessscript, |
|||
&peer->secrets->commit, |
|||
&peer->local.commitkey, |
|||
sig); |
|||
} |
|||
|
|||
void peer_sign_steal_input(const struct peer *peer, |
|||
struct bitcoin_tx *spend, |
|||
size_t i, |
|||
const u8 *witnessscript, |
|||
secp256k1_ecdsa_signature *sig) |
|||
{ |
|||
/* Spend tx only has one input: that of the commit tx. */ |
|||
sign_tx_input(spend, i, |
|||
NULL, |
|||
witnessscript, |
|||
&peer->secrets->final, |
|||
&peer->local.finalkey, |
|||
sig); |
|||
} |
|||
|
|||
static void new_keypair(struct lightningd_state *dstate, |
|||
struct privkey *privkey, struct pubkey *pubkey) |
|||
{ |
|||
do { |
|||
randombytes_buf(privkey->secret.data, |
|||
sizeof(privkey->secret.data)); |
|||
} while (!pubkey_from_privkey(privkey, pubkey)); |
|||
} |
|||
|
|||
void peer_secrets_init(struct peer *peer) |
|||
{ |
|||
peer->secrets = tal(peer, struct peer_secrets); |
|||
|
|||
new_keypair(peer->dstate, &peer->secrets->commit, &peer->local.commitkey); |
|||
new_keypair(peer->dstate, &peer->secrets->final, &peer->local.finalkey); |
|||
randombytes_buf(peer->secrets->revocation_seed.u.u8, sizeof(peer->secrets->revocation_seed.u.u8)); |
|||
} |
|||
|
|||
void peer_get_revocation_preimage(const struct peer *peer, u64 index, |
|||
struct sha256 *preimage) |
|||
{ |
|||
// generate hashes in reverse order, otherwise the first hash gives away everything
|
|||
shachain_from_seed(&peer->secrets->revocation_seed, 0xFFFFFFFFFFFFFFFFL - index, preimage); |
|||
} |
|||
|
|||
void peer_get_revocation_hash(const struct peer *peer, u64 index, |
|||
struct sha256 *rhash) |
|||
{ |
|||
struct sha256 preimage; |
|||
|
|||
peer_get_revocation_preimage(peer, index, &preimage); |
|||
sha256(rhash, preimage.u.u8, sizeof(preimage.u.u8)); |
|||
} |
|||
|
|||
const char *peer_secrets_for_db(const tal_t *ctx, struct peer *peer) |
|||
{ |
|||
const struct peer_secrets *ps = peer->secrets; |
|||
return tal_fmt(ctx, "x'%s', x'%s', x'%s'", |
|||
tal_hexstr(ctx, &ps->commit, sizeof(ps->commit)), |
|||
tal_hexstr(ctx, &ps->final, sizeof(ps->final)), |
|||
tal_hexstr(ctx, &ps->revocation_seed, |
|||
sizeof(ps->revocation_seed))); |
|||
} |
|||
|
|||
void peer_set_secrets_from_db(struct peer *peer, |
|||
const void *commit_privkey, |
|||
size_t commit_privkey_len, |
|||
const void *final_privkey, |
|||
size_t final_privkey_len, |
|||
const void *revocation_seed, |
|||
size_t revocation_seed_len) |
|||
{ |
|||
struct peer_secrets *ps = tal(peer, struct peer_secrets); |
|||
|
|||
assert(!peer->secrets); |
|||
peer->secrets = ps; |
|||
|
|||
if (commit_privkey_len != sizeof(ps->commit) |
|||
|| final_privkey_len != sizeof(ps->final) |
|||
|| revocation_seed_len != sizeof(ps->revocation_seed)) |
|||
fatal("peer_set_secrets_from_db: bad lengths %zu/%zu/%zu", |
|||
commit_privkey_len, final_privkey_len, |
|||
revocation_seed_len); |
|||
|
|||
memcpy(&ps->commit, commit_privkey, commit_privkey_len); |
|||
memcpy(&ps->final, final_privkey, final_privkey_len); |
|||
memcpy(&ps->revocation_seed, revocation_seed, revocation_seed_len); |
|||
|
|||
if (!pubkey_from_privkey(&ps->commit, &peer->local.commitkey)) |
|||
fatal("peer_set_secrets_from_db:bad commit privkey"); |
|||
if (!pubkey_from_privkey(&ps->final, &peer->local.finalkey)) |
|||
fatal("peer_set_secrets_from_db:bad final privkey"); |
|||
} |
|||
|
|||
void secrets_init(struct lightningd_state *dstate) |
|||
{ |
|||
int fd; |
|||
|
|||
dstate->privkey = tal(dstate, struct privkey); |
|||
|
|||
fd = open("privkey", O_RDONLY); |
|||
if (fd < 0) { |
|||
if (errno != ENOENT) |
|||
fatal("Failed to open privkey: %s", strerror(errno)); |
|||
|
|||
log_unusual(dstate->base_log, "Creating privkey file"); |
|||
new_keypair(dstate, dstate->privkey, &dstate->id); |
|||
|
|||
fd = open("privkey", O_CREAT|O_EXCL|O_WRONLY, 0400); |
|||
if (fd < 0) |
|||
fatal("Failed to create privkey file: %s", |
|||
strerror(errno)); |
|||
if (!write_all(fd, &dstate->privkey->secret, |
|||
sizeof(dstate->privkey->secret))) { |
|||
unlink_noerr("privkey"); |
|||
fatal("Failed to write to privkey file: %s", |
|||
strerror(errno)); |
|||
} |
|||
if (fsync(fd) != 0) |
|||
fatal("Failed to sync to privkey file: %s", |
|||
strerror(errno)); |
|||
close(fd); |
|||
|
|||
fd = open("privkey", O_RDONLY); |
|||
if (fd < 0) |
|||
fatal("Failed to reopen privkey: %s", strerror(errno)); |
|||
} |
|||
if (!read_all(fd, &dstate->privkey->secret, |
|||
sizeof(dstate->privkey->secret))) |
|||
fatal("Failed to read privkey: %s", strerror(errno)); |
|||
close(fd); |
|||
if (!pubkey_from_privkey(dstate->privkey, &dstate->id)) |
|||
fatal("Invalid privkey"); |
|||
|
|||
log_info_struct(dstate->base_log, "ID: %s", struct pubkey, &dstate->id); |
|||
} |
|||
@ -1,68 +0,0 @@ |
|||
#ifndef LIGHTNING_DAEMON_SECRETS_H |
|||
#define LIGHTNING_DAEMON_SECRETS_H |
|||
/* Routines to handle private keys. */ |
|||
#include "config.h" |
|||
#include <ccan/short_types/short_types.h> |
|||
#include <ccan/tal/tal.h> |
|||
#include <secp256k1.h> |
|||
|
|||
struct peer; |
|||
struct lightningd_state; |
|||
struct sha256; |
|||
|
|||
void privkey_sign(struct lightningd_state *dstate, const void *src, size_t len, |
|||
secp256k1_ecdsa_signature *sig); |
|||
|
|||
void peer_sign_theircommit(const struct peer *peer, |
|||
struct bitcoin_tx *commit, |
|||
secp256k1_ecdsa_signature *sig); |
|||
|
|||
void peer_sign_ourcommit(const struct peer *peer, |
|||
struct bitcoin_tx *commit, |
|||
secp256k1_ecdsa_signature *sig); |
|||
|
|||
void peer_sign_spend(const struct peer *peer, |
|||
struct bitcoin_tx *spend, |
|||
const u8 *commit_witnessscript, |
|||
secp256k1_ecdsa_signature *sig); |
|||
|
|||
void peer_sign_htlc_refund(const struct peer *peer, |
|||
struct bitcoin_tx *spend, |
|||
const u8 *htlc_witnessscript, |
|||
secp256k1_ecdsa_signature *sig); |
|||
|
|||
void peer_sign_htlc_fulfill(const struct peer *peer, |
|||
struct bitcoin_tx *spend, |
|||
const u8 *htlc_witnessscript, |
|||
secp256k1_ecdsa_signature *sig); |
|||
|
|||
void peer_sign_mutual_close(const struct peer *peer, |
|||
struct bitcoin_tx *close, |
|||
secp256k1_ecdsa_signature *sig); |
|||
|
|||
void peer_sign_steal_input(const struct peer *peer, |
|||
struct bitcoin_tx *spend, |
|||
size_t i, |
|||
const u8 *witnessscript, |
|||
secp256k1_ecdsa_signature *sig); |
|||
|
|||
const char *peer_secrets_for_db(const tal_t *ctx, struct peer *peer); |
|||
|
|||
void peer_set_secrets_from_db(struct peer *peer, |
|||
const void *commit_privkey, |
|||
size_t commit_privkey_len, |
|||
const void *final_privkey, |
|||
size_t final_privkey_len, |
|||
const void *revocation_seed, |
|||
size_t revocation_seed_len); |
|||
|
|||
void peer_secrets_init(struct peer *peer); |
|||
|
|||
void peer_get_revocation_hash(const struct peer *peer, u64 index, |
|||
struct sha256 *rhash); |
|||
void peer_get_revocation_preimage(const struct peer *peer, u64 index, |
|||
struct sha256 *preimage); |
|||
|
|||
void secrets_init(struct lightningd_state *dstate); |
|||
|
|||
#endif /* LIGHTNING_DAEMON_SECRETS_H */ |
|||
@ -1,479 +0,0 @@ |
|||
#include "sphinx.h" |
|||
#include "utils.h" |
|||
#include <assert.h> |
|||
|
|||
#include <bitcoin/address.h> |
|||
|
|||
#include <ccan/crypto/ripemd160/ripemd160.h> |
|||
#include <ccan/crypto/sha256/sha256.h> |
|||
#include <ccan/mem/mem.h> |
|||
|
|||
#include <err.h> |
|||
|
|||
#include <secp256k1_ecdh.h> |
|||
|
|||
#include <sodium/crypto_auth_hmacsha256.h> |
|||
#include <sodium/crypto_stream_chacha20.h> |
|||
|
|||
#define BLINDING_FACTOR_SIZE 32 |
|||
#define SHARED_SECRET_SIZE 32 |
|||
#define NUM_STREAM_BYTES ((2 * NUM_MAX_HOPS + 2) * SECURITY_PARAMETER) |
|||
#define KEY_LEN 32 |
|||
|
|||
struct hop_params { |
|||
u8 secret[SHARED_SECRET_SIZE]; |
|||
u8 blind[BLINDING_FACTOR_SIZE]; |
|||
secp256k1_pubkey ephemeralkey; |
|||
}; |
|||
|
|||
struct keyset { |
|||
u8 pi[KEY_LEN]; |
|||
u8 mu[KEY_LEN]; |
|||
u8 rho[KEY_LEN]; |
|||
u8 gamma[KEY_LEN]; |
|||
}; |
|||
|
|||
/* Small helper to append data to a buffer and update the position
|
|||
* into the buffer |
|||
*/ |
|||
static void write_buffer(u8 *dst, const void *src, const size_t len, int *pos) |
|||
{ |
|||
memcpy(dst + *pos, src, len); |
|||
*pos += len; |
|||
} |
|||
|
|||
/* Read len bytes from the source at position pos into dst and update
|
|||
* the position pos accordingly. |
|||
*/ |
|||
static void read_buffer(void *dst, const u8 *src, const size_t len, int *pos) |
|||
{ |
|||
memcpy(dst, src + *pos, len); |
|||
*pos += len; |
|||
} |
|||
|
|||
u8 *serialize_onionpacket( |
|||
const tal_t *ctx, |
|||
const struct onionpacket *m) |
|||
{ |
|||
u8 *dst = tal_arr(ctx, u8, TOTAL_PACKET_SIZE); |
|||
|
|||
u8 der[33]; |
|||
size_t outputlen = 33; |
|||
int p = 0; |
|||
|
|||
secp256k1_ec_pubkey_serialize(secp256k1_ctx, |
|||
der, |
|||
&outputlen, |
|||
&m->ephemeralkey, |
|||
SECP256K1_EC_COMPRESSED); |
|||
|
|||
write_buffer(dst, &m->version, 1, &p); |
|||
write_buffer(dst, der, outputlen, &p); |
|||
write_buffer(dst, m->mac, sizeof(m->mac), &p); |
|||
write_buffer(dst, m->routinginfo, ROUTING_INFO_SIZE, &p); |
|||
write_buffer(dst, m->hoppayloads, TOTAL_HOP_PAYLOAD_SIZE, &p); |
|||
return dst; |
|||
} |
|||
|
|||
struct onionpacket *parse_onionpacket( |
|||
const tal_t *ctx, |
|||
const void *src, |
|||
const size_t srclen |
|||
) |
|||
{ |
|||
struct onionpacket *m; |
|||
int p = 0; |
|||
u8 rawEphemeralkey[33]; |
|||
|
|||
if (srclen != TOTAL_PACKET_SIZE) |
|||
return NULL; |
|||
|
|||
m = talz(ctx, struct onionpacket); |
|||
|
|||
read_buffer(&m->version, src, 1, &p); |
|||
if (m->version != 0x01) { |
|||
// FIXME add logging
|
|||
return tal_free(m); |
|||
} |
|||
read_buffer(rawEphemeralkey, src, 33, &p); |
|||
|
|||
if (secp256k1_ec_pubkey_parse(secp256k1_ctx, &m->ephemeralkey, rawEphemeralkey, 33) != 1) |
|||
return tal_free(m); |
|||
|
|||
read_buffer(&m->mac, src, 20, &p); |
|||
read_buffer(&m->routinginfo, src, ROUTING_INFO_SIZE, &p); |
|||
read_buffer(&m->hoppayloads, src, TOTAL_HOP_PAYLOAD_SIZE, &p); |
|||
return m; |
|||
} |
|||
|
|||
static struct hoppayload *parse_hoppayload(const tal_t *ctx, u8 *src) |
|||
{ |
|||
int p = 0; |
|||
struct hoppayload *result = talz(ctx, struct hoppayload); |
|||
|
|||
read_buffer(&result->realm, src, sizeof(result->realm), &p); |
|||
read_buffer(&result->amt_to_forward, |
|||
src, sizeof(result->amt_to_forward), &p); |
|||
read_buffer(&result->outgoing_cltv_value, |
|||
src, sizeof(result->outgoing_cltv_value), &p); |
|||
read_buffer(&result->unused_with_v0_version_on_header, |
|||
src, sizeof(result->unused_with_v0_version_on_header), &p); |
|||
return result; |
|||
} |
|||
|
|||
static void serialize_hoppayload(u8 *dst, struct hoppayload *hp) |
|||
{ |
|||
int p = 0; |
|||
|
|||
write_buffer(dst, &hp->realm, sizeof(hp->realm), &p); |
|||
write_buffer(dst, &hp->amt_to_forward, sizeof(hp->amt_to_forward), &p); |
|||
write_buffer(dst, &hp->outgoing_cltv_value, |
|||
sizeof(hp->outgoing_cltv_value), &p); |
|||
write_buffer(dst, &hp->unused_with_v0_version_on_header, |
|||
sizeof(hp->unused_with_v0_version_on_header), &p); |
|||
} |
|||
|
|||
|
|||
static void xorbytes(uint8_t *d, const uint8_t *a, const uint8_t *b, size_t len) |
|||
{ |
|||
size_t i; |
|||
|
|||
for (i = 0; i < len; i++) |
|||
d[i] = a[i] ^ b[i]; |
|||
} |
|||
|
|||
/*
|
|||
* Generate a pseudo-random byte stream of length `dstlen` from key `k` and |
|||
* store it in `dst`. `dst must be at least `dstlen` bytes long. |
|||
*/ |
|||
static void generate_cipher_stream(void *dst, const u8 *k, size_t dstlen) |
|||
{ |
|||
u8 nonce[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; |
|||
|
|||
crypto_stream_chacha20(dst, dstlen, nonce, k); |
|||
} |
|||
|
|||
static bool compute_hmac( |
|||
void *dst, |
|||
const void *src, |
|||
size_t len, |
|||
const void *key, |
|||
size_t keylen) |
|||
{ |
|||
crypto_auth_hmacsha256_state state; |
|||
|
|||
crypto_auth_hmacsha256_init(&state, key, keylen); |
|||
crypto_auth_hmacsha256_update(&state, memcheck(src, len), len); |
|||
crypto_auth_hmacsha256_final(&state, dst); |
|||
return true; |
|||
} |
|||
|
|||
static void compute_packet_hmac(const struct onionpacket *packet, |
|||
const u8 *assocdata, const size_t assocdatalen, |
|||
u8 *mukey, u8 *hmac) |
|||
{ |
|||
u8 mactemp[ROUTING_INFO_SIZE + TOTAL_HOP_PAYLOAD_SIZE + assocdatalen]; |
|||
u8 mac[32]; |
|||
int pos = 0; |
|||
|
|||
write_buffer(mactemp, packet->routinginfo, ROUTING_INFO_SIZE, &pos); |
|||
write_buffer(mactemp, packet->hoppayloads, TOTAL_HOP_PAYLOAD_SIZE, &pos); |
|||
write_buffer(mactemp, assocdata, assocdatalen, &pos); |
|||
|
|||
compute_hmac(mac, mactemp, sizeof(mactemp), mukey, KEY_LEN); |
|||
memcpy(hmac, mac, 20); |
|||
} |
|||
|
|||
static bool generate_key(void *k, const char *t, u8 tlen, const u8 *s) |
|||
{ |
|||
return compute_hmac(k, s, KEY_LEN, t, tlen); |
|||
} |
|||
|
|||
static bool generate_header_padding( |
|||
void *dst, size_t dstlen, |
|||
const size_t hopsize, |
|||
const char *keytype, |
|||
size_t keytypelen, |
|||
const u8 numhops, |
|||
struct hop_params *params |
|||
) |
|||
{ |
|||
int i; |
|||
u8 cipher_stream[(NUM_MAX_HOPS + 1) * hopsize]; |
|||
u8 key[KEY_LEN]; |
|||
|
|||
memset(dst, 0, dstlen); |
|||
for (i = 1; i < numhops; i++) { |
|||
if (!generate_key(&key, keytype, keytypelen, params[i - 1].secret)) |
|||
return false; |
|||
|
|||
generate_cipher_stream(cipher_stream, key, sizeof(cipher_stream)); |
|||
int pos = ((NUM_MAX_HOPS - i) + 1) * hopsize; |
|||
xorbytes(dst, dst, cipher_stream + pos, sizeof(cipher_stream) - pos); |
|||
} |
|||
return true; |
|||
} |
|||
|
|||
static void compute_blinding_factor(const secp256k1_pubkey *key, |
|||
const u8 sharedsecret[SHARED_SECRET_SIZE], |
|||
u8 res[BLINDING_FACTOR_SIZE]) |
|||
{ |
|||
struct sha256_ctx ctx; |
|||
u8 der[33]; |
|||
size_t outputlen = 33; |
|||
struct sha256 temp; |
|||
|
|||
secp256k1_ec_pubkey_serialize(secp256k1_ctx, der, &outputlen, key, |
|||
SECP256K1_EC_COMPRESSED); |
|||
sha256_init(&ctx); |
|||
sha256_update(&ctx, der, sizeof(der)); |
|||
sha256_update(&ctx, sharedsecret, SHARED_SECRET_SIZE); |
|||
sha256_done(&ctx, &temp); |
|||
memcpy(res, &temp, 32); |
|||
} |
|||
|
|||
static bool blind_group_element( |
|||
secp256k1_pubkey *blindedelement, |
|||
const secp256k1_pubkey *pubkey, |
|||
const u8 blind[BLINDING_FACTOR_SIZE]) |
|||
{ |
|||
/* tweak_mul is inplace so copy first. */ |
|||
if (pubkey != blindedelement) |
|||
*blindedelement = *pubkey; |
|||
if (secp256k1_ec_pubkey_tweak_mul(secp256k1_ctx, blindedelement, blind) != 1) |
|||
return false; |
|||
return true; |
|||
} |
|||
|
|||
static bool create_shared_secret( |
|||
u8 *secret, |
|||
const secp256k1_pubkey *pubkey, |
|||
const u8 *sessionkey) |
|||
{ |
|||
|
|||
if (secp256k1_ecdh(secp256k1_ctx, secret, pubkey, sessionkey) != 1) |
|||
return false; |
|||
return true; |
|||
} |
|||
|
|||
bool onion_shared_secret( |
|||
u8 *secret, |
|||
const struct onionpacket *packet, |
|||
const struct privkey *privkey) |
|||
{ |
|||
return create_shared_secret(secret, &packet->ephemeralkey, |
|||
privkey->secret.data); |
|||
} |
|||
|
|||
static void generate_key_set(const u8 secret[SHARED_SECRET_SIZE], |
|||
struct keyset *keys) |
|||
{ |
|||
generate_key(keys->rho, "rho", 3, secret); |
|||
generate_key(keys->pi, "pi", 2, secret); |
|||
generate_key(keys->mu, "mu", 2, secret); |
|||
generate_key(keys->gamma, "gamma", 5, secret); |
|||
} |
|||
|
|||
static struct hop_params *generate_hop_params( |
|||
const tal_t *ctx, |
|||
const u8 *sessionkey, |
|||
struct pubkey path[]) |
|||
{ |
|||
int i, j, num_hops = tal_count(path); |
|||
secp256k1_pubkey temp; |
|||
u8 blind[BLINDING_FACTOR_SIZE]; |
|||
struct hop_params *params = tal_arr(ctx, struct hop_params, num_hops); |
|||
|
|||
/* Initialize the first hop with the raw information */ |
|||
if (secp256k1_ec_pubkey_create( |
|||
secp256k1_ctx, ¶ms[0].ephemeralkey, sessionkey) != 1) |
|||
return NULL; |
|||
|
|||
if (!create_shared_secret( |
|||
params[0].secret, &path[0].pubkey, sessionkey)) |
|||
return NULL; |
|||
|
|||
compute_blinding_factor( |
|||
¶ms[0].ephemeralkey, params[0].secret, |
|||
params[0].blind); |
|||
|
|||
/* Recursively compute all following ephemeral public keys,
|
|||
* secrets and blinding factors |
|||
*/ |
|||
for (i = 1; i < num_hops; i++) { |
|||
if (!blind_group_element( |
|||
¶ms[i].ephemeralkey, |
|||
¶ms[i - 1].ephemeralkey, |
|||
params[i - 1].blind)) |
|||
return NULL; |
|||
|
|||
/* Blind this hop's point with all previous blinding factors
|
|||
* Order is indifferent, multiplication is commutative. |
|||
*/ |
|||
memcpy(&blind, sessionkey, 32); |
|||
temp = path[i].pubkey; |
|||
if (!blind_group_element(&temp, &temp, blind)) |
|||
return NULL; |
|||
for (j = 0; j < i; j++) |
|||
if (!blind_group_element( |
|||
&temp, |
|||
&temp, |
|||
params[j].blind)) |
|||
return NULL; |
|||
|
|||
/* Now hash temp and store it. This requires us to
|
|||
* DER-serialize first and then skip the sign byte. |
|||
*/ |
|||
u8 der[33]; |
|||
size_t outputlen = 33; |
|||
secp256k1_ec_pubkey_serialize( |
|||
secp256k1_ctx, der, &outputlen, &temp, |
|||
SECP256K1_EC_COMPRESSED); |
|||
struct sha256 h; |
|||
sha256(&h, der, sizeof(der)); |
|||
memcpy(¶ms[i].secret, &h, sizeof(h)); |
|||
|
|||
compute_blinding_factor( |
|||
¶ms[i].ephemeralkey, |
|||
params[i].secret, params[i].blind); |
|||
} |
|||
return params; |
|||
} |
|||
|
|||
struct onionpacket *create_onionpacket( |
|||
const tal_t *ctx, |
|||
struct pubkey *path, |
|||
struct hoppayload hoppayloads[], |
|||
const u8 *sessionkey, |
|||
const u8 *assocdata, |
|||
const size_t assocdatalen |
|||
) |
|||
{ |
|||
struct onionpacket *packet = talz(ctx, struct onionpacket); |
|||
int i, num_hops = tal_count(path); |
|||
u8 filler[2 * (num_hops - 1) * SECURITY_PARAMETER]; |
|||
u8 hopfiller[(num_hops - 1) * HOP_PAYLOAD_SIZE]; |
|||
struct keyset keys; |
|||
struct bitcoin_address nextaddr; |
|||
u8 nexthmac[SECURITY_PARAMETER]; |
|||
u8 stream[ROUTING_INFO_SIZE], hopstream[TOTAL_HOP_PAYLOAD_SIZE]; |
|||
struct hop_params *params = generate_hop_params(ctx, sessionkey, path); |
|||
u8 binhoppayloads[tal_count(path)][HOP_PAYLOAD_SIZE]; |
|||
|
|||
for (i = 0; i < num_hops; i++) |
|||
serialize_hoppayload(binhoppayloads[i], &hoppayloads[i]); |
|||
|
|||
if (!params) |
|||
return NULL; |
|||
packet->version = 1; |
|||
memset(&nextaddr, 0, 20); |
|||
memset(nexthmac, 0, 20); |
|||
memset(packet->routinginfo, 0, ROUTING_INFO_SIZE); |
|||
|
|||
generate_header_padding(filler, sizeof(filler), 2 * SECURITY_PARAMETER, |
|||
"rho", 3, num_hops, params); |
|||
generate_header_padding(hopfiller, sizeof(hopfiller), HOP_PAYLOAD_SIZE, |
|||
"gamma", 5, num_hops, params); |
|||
|
|||
for (i = num_hops - 1; i >= 0; i--) { |
|||
generate_key_set(params[i].secret, &keys); |
|||
generate_cipher_stream(stream, keys.rho, ROUTING_INFO_SIZE); |
|||
|
|||
/* Rightshift mix-header by 2*SECURITY_PARAMETER */ |
|||
memmove(packet->routinginfo + 2 * SECURITY_PARAMETER, packet->routinginfo, |
|||
ROUTING_INFO_SIZE - 2 * SECURITY_PARAMETER); |
|||
memcpy(packet->routinginfo, &nextaddr, SECURITY_PARAMETER); |
|||
memcpy(packet->routinginfo + SECURITY_PARAMETER, nexthmac, SECURITY_PARAMETER); |
|||
xorbytes(packet->routinginfo, packet->routinginfo, stream, ROUTING_INFO_SIZE); |
|||
|
|||
/* Rightshift hop-payloads and obfuscate */ |
|||
memmove(packet->hoppayloads + HOP_PAYLOAD_SIZE, packet->hoppayloads, |
|||
TOTAL_HOP_PAYLOAD_SIZE - HOP_PAYLOAD_SIZE); |
|||
memcpy(packet->hoppayloads, binhoppayloads[i], HOP_PAYLOAD_SIZE); |
|||
generate_cipher_stream(hopstream, keys.gamma, TOTAL_HOP_PAYLOAD_SIZE); |
|||
xorbytes(packet->hoppayloads, packet->hoppayloads, hopstream, |
|||
TOTAL_HOP_PAYLOAD_SIZE); |
|||
|
|||
if (i == num_hops - 1) { |
|||
size_t len = (NUM_MAX_HOPS - num_hops + 1) * 2 * SECURITY_PARAMETER; |
|||
memcpy(packet->routinginfo + len, filler, sizeof(filler)); |
|||
len = (NUM_MAX_HOPS - num_hops + 1) * HOP_PAYLOAD_SIZE; |
|||
memcpy(packet->hoppayloads + len, hopfiller, sizeof(hopfiller)); |
|||
} |
|||
|
|||
compute_packet_hmac(packet, assocdata, assocdatalen, keys.mu, |
|||
nexthmac); |
|||
pubkey_to_hash160(&path[i], &nextaddr.addr); |
|||
} |
|||
memcpy(packet->mac, nexthmac, sizeof(nexthmac)); |
|||
memcpy(&packet->ephemeralkey, ¶ms[0].ephemeralkey, sizeof(secp256k1_pubkey)); |
|||
return packet; |
|||
} |
|||
|
|||
/*
|
|||
* Given a onionpacket msg extract the information for the current |
|||
* node and unwrap the remainder so that the node can forward it. |
|||
*/ |
|||
struct route_step *process_onionpacket( |
|||
const tal_t *ctx, |
|||
const struct onionpacket *msg, |
|||
const u8 *shared_secret, |
|||
const u8 *assocdata, |
|||
const size_t assocdatalen |
|||
) |
|||
{ |
|||
struct route_step *step = talz(ctx, struct route_step); |
|||
u8 hmac[20]; |
|||
struct keyset keys; |
|||
u8 paddedhoppayloads[TOTAL_HOP_PAYLOAD_SIZE + HOP_PAYLOAD_SIZE]; |
|||
u8 hopstream[TOTAL_HOP_PAYLOAD_SIZE + HOP_PAYLOAD_SIZE]; |
|||
u8 blind[BLINDING_FACTOR_SIZE]; |
|||
u8 stream[NUM_STREAM_BYTES]; |
|||
u8 paddedheader[ROUTING_INFO_SIZE + 2 * SECURITY_PARAMETER]; |
|||
|
|||
step->next = talz(step, struct onionpacket); |
|||
step->next->version = msg->version; |
|||
generate_key_set(shared_secret, &keys); |
|||
|
|||
compute_packet_hmac(msg, assocdata, assocdatalen, keys.mu, hmac); |
|||
|
|||
if (memcmp(msg->mac, hmac, sizeof(hmac)) != 0) { |
|||
warnx("Computed MAC does not match expected MAC, the message was modified."); |
|||
return tal_free(step); |
|||
} |
|||
|
|||
//FIXME:store seen secrets to avoid replay attacks
|
|||
generate_cipher_stream(stream, keys.rho, sizeof(stream)); |
|||
|
|||
memset(paddedheader, 0, sizeof(paddedheader)); |
|||
memcpy(paddedheader, msg->routinginfo, ROUTING_INFO_SIZE); |
|||
xorbytes(paddedheader, paddedheader, stream, sizeof(stream)); |
|||
|
|||
/* Extract the per-hop payload */ |
|||
generate_cipher_stream(hopstream, keys.gamma, sizeof(hopstream)); |
|||
|
|||
memset(paddedhoppayloads, 0, sizeof(paddedhoppayloads)); |
|||
memcpy(paddedhoppayloads, msg->hoppayloads, TOTAL_HOP_PAYLOAD_SIZE); |
|||
xorbytes(paddedhoppayloads, paddedhoppayloads, hopstream, sizeof(hopstream)); |
|||
step->hoppayload = parse_hoppayload(step, paddedhoppayloads); |
|||
memcpy(&step->next->hoppayloads, paddedhoppayloads + HOP_PAYLOAD_SIZE, |
|||
TOTAL_HOP_PAYLOAD_SIZE); |
|||
|
|||
compute_blinding_factor(&msg->ephemeralkey, shared_secret, blind); |
|||
if (!blind_group_element(&step->next->ephemeralkey, &msg->ephemeralkey, blind)) |
|||
return tal_free(step); |
|||
memcpy(&step->next->nexthop, paddedheader, SECURITY_PARAMETER); |
|||
memcpy(&step->next->mac, |
|||
paddedheader + SECURITY_PARAMETER, |
|||
SECURITY_PARAMETER); |
|||
|
|||
memcpy(&step->next->routinginfo, paddedheader + 2 * SECURITY_PARAMETER, ROUTING_INFO_SIZE); |
|||
|
|||
if (memeqzero(step->next->mac, sizeof(step->next->mac))) { |
|||
step->nextcase = ONION_END; |
|||
} else { |
|||
step->nextcase = ONION_FORWARD; |
|||
} |
|||
|
|||
return step; |
|||
} |
|||
@ -1,136 +0,0 @@ |
|||
#ifndef LIGHTNING_DAEMON_SPHINX_H |
|||
#define LIGHTNING_DAEMON_SPHINX_H |
|||
|
|||
#include "config.h" |
|||
#include "bitcoin/privkey.h" |
|||
#include "bitcoin/pubkey.h" |
|||
|
|||
#include <ccan/short_types/short_types.h> |
|||
#include <ccan/tal/tal.h> |
|||
#include <secp256k1.h> |
|||
#include <sodium/randombytes.h> |
|||
|
|||
#define SECURITY_PARAMETER 20 |
|||
#define NUM_MAX_HOPS 20 |
|||
#define HOP_PAYLOAD_SIZE 20 |
|||
#define TOTAL_HOP_PAYLOAD_SIZE (NUM_MAX_HOPS * HOP_PAYLOAD_SIZE) |
|||
#define ROUTING_INFO_SIZE (2 * NUM_MAX_HOPS * SECURITY_PARAMETER) |
|||
#define TOTAL_PACKET_SIZE (1 + 33 + SECURITY_PARAMETER + ROUTING_INFO_SIZE + \ |
|||
TOTAL_HOP_PAYLOAD_SIZE) |
|||
|
|||
struct onionpacket { |
|||
/* Cleartext information */ |
|||
u8 version; |
|||
u8 nexthop[20]; |
|||
u8 mac[20]; |
|||
secp256k1_pubkey ephemeralkey; |
|||
|
|||
/* Encrypted information */ |
|||
u8 routinginfo[ROUTING_INFO_SIZE]; |
|||
u8 hoppayloads[TOTAL_HOP_PAYLOAD_SIZE]; |
|||
}; |
|||
|
|||
enum route_next_case { |
|||
ONION_END = 0, |
|||
ONION_FORWARD = 1, |
|||
}; |
|||
|
|||
/* FIXME-OLD #4:
|
|||
* |
|||
* The format of the per-hop-payload for a version 0 packet is as follows: |
|||
``` |
|||
+----------------+--------------------------+-------------------------------+--------------------------------------------+ |
|||
| realm (1 byte) | amt_to_forward (8 bytes) | outgoing_cltv_value (4 bytes) | unused_with_v0_version_on_header (7 bytes) | |
|||
+----------------+--------------------------+-------------------------------+--------------------------------------------+ |
|||
``` |
|||
*/ |
|||
struct hoppayload { |
|||
u8 realm; |
|||
u64 amt_to_forward; |
|||
u32 outgoing_cltv_value; |
|||
u8 unused_with_v0_version_on_header[7]; |
|||
}; |
|||
|
|||
struct route_step { |
|||
enum route_next_case nextcase; |
|||
struct onionpacket *next; |
|||
struct hoppayload *hoppayload; |
|||
}; |
|||
|
|||
/**
|
|||
* create_onionpacket - Create a new onionpacket that can be routed |
|||
* over a path of intermediate nodes. |
|||
* |
|||
* @ctx: tal context to allocate from |
|||
* @path: public keys of nodes along the path. |
|||
* @hoppayloads: payloads destined for individual hosts (limited to |
|||
* HOP_PAYLOAD_SIZE bytes) |
|||
* @num_hops: path length in nodes |
|||
* @sessionkey: 20 byte random session key to derive secrets from |
|||
* @assocdata: associated data to commit to in HMACs |
|||
* @assocdatalen: length of the assocdata |
|||
*/ |
|||
struct onionpacket *create_onionpacket( |
|||
const tal_t * ctx, |
|||
struct pubkey path[], |
|||
struct hoppayload hoppayloads[], |
|||
const u8 * sessionkey, |
|||
const u8 *assocdata, |
|||
const size_t assocdatalen |
|||
); |
|||
|
|||
/**
|
|||
* onion_shared_secret - calculate ECDH shared secret between nodes. |
|||
* |
|||
* @secret: the shared secret (32 bytes long) |
|||
* @pubkey: the public key of the other node |
|||
* @privkey: the private key of this node (32 bytes long) |
|||
*/ |
|||
bool onion_shared_secret( |
|||
u8 *secret, |
|||
const struct onionpacket *packet, |
|||
const struct privkey *privkey); |
|||
|
|||
/**
|
|||
* process_onionpacket - process an incoming packet by stripping one |
|||
* onion layer and return the packet for the next hop. |
|||
* |
|||
* @ctx: tal context to allocate from |
|||
* @packet: incoming packet being processed |
|||
* @shared_secret: the result of onion_shared_secret. |
|||
* @hoppayload: the per-hop payload destined for the processing node. |
|||
* @assocdata: associated data to commit to in HMACs |
|||
* @assocdatalen: length of the assocdata |
|||
*/ |
|||
struct route_step *process_onionpacket( |
|||
const tal_t * ctx, |
|||
const struct onionpacket *packet, |
|||
const u8 *shared_secret, |
|||
const u8 *assocdata, |
|||
const size_t assocdatalen |
|||
); |
|||
|
|||
/**
|
|||
* serialize_onionpacket - Serialize an onionpacket to a buffer. |
|||
* |
|||
* @ctx: tal context to allocate from |
|||
* @packet: the packet to serialize |
|||
*/ |
|||
u8 *serialize_onionpacket( |
|||
const tal_t *ctx, |
|||
const struct onionpacket *packet); |
|||
|
|||
/**
|
|||
* parese_onionpacket - Parse an onionpacket from a buffer. |
|||
* |
|||
* @ctx: tal context to allocate from |
|||
* @src: buffer to read the packet from |
|||
* @srclen: length of the @src |
|||
*/ |
|||
struct onionpacket *parse_onionpacket( |
|||
const tal_t *ctx, |
|||
const void *src, |
|||
const size_t srclen |
|||
); |
|||
|
|||
#endif /* LIGHTNING_DAEMON_SPHINX_H */ |
|||
@ -1,77 +0,0 @@ |
|||
#ifndef LIGHTNING_DAEMON_STATE_H |
|||
#define LIGHTNING_DAEMON_STATE_H |
|||
#include "config.h" |
|||
|
|||
#include "daemon/state_types.h" |
|||
#include <stdbool.h> |
|||
|
|||
static inline bool state_is_error(enum state s) |
|||
{ |
|||
return s >= STATE_ERR_BREAKDOWN && s <= STATE_ERR_INTERNAL; |
|||
} |
|||
|
|||
static inline bool state_is_shutdown(enum state s) |
|||
{ |
|||
return s == STATE_SHUTDOWN || s == STATE_SHUTDOWN_COMMITTING; |
|||
} |
|||
|
|||
static inline bool state_is_onchain(enum state s) |
|||
{ |
|||
return s >= STATE_CLOSE_ONCHAIN_CHEATED |
|||
&& s <= STATE_CLOSE_ONCHAIN_MUTUAL; |
|||
} |
|||
|
|||
static inline bool state_is_normal(enum state s) |
|||
{ |
|||
return s == STATE_NORMAL || s == STATE_NORMAL_COMMITTING; |
|||
} |
|||
|
|||
static inline bool state_is_waiting_for_anchor(enum state s) |
|||
{ |
|||
return s == STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE |
|||
|| s == STATE_OPEN_WAIT_ANCHORDEPTH; |
|||
} |
|||
|
|||
static inline bool state_is_openwait(enum state s) |
|||
{ |
|||
return s == STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE |
|||
|| s == STATE_OPEN_WAIT_ANCHORDEPTH |
|||
|| s == STATE_OPEN_WAIT_THEIRCOMPLETE; |
|||
} |
|||
|
|||
static inline bool state_is_opening(enum state s) |
|||
{ |
|||
return s <= STATE_OPEN_WAIT_THEIRCOMPLETE; |
|||
} |
|||
|
|||
static inline bool state_can_io(enum state s) |
|||
{ |
|||
if (state_is_error(s)) |
|||
return false; |
|||
if (s == STATE_CLOSED) |
|||
return false; |
|||
if (state_is_onchain(s)) |
|||
return false; |
|||
return true; |
|||
} |
|||
|
|||
static inline bool state_can_commit(enum state s) |
|||
{ |
|||
return s == STATE_NORMAL || s == STATE_SHUTDOWN; |
|||
} |
|||
|
|||
/* FIXME-OLD #2:
|
|||
* |
|||
* A node MUST NOT send a `update_add_htlc` after a `close_shutdown` |
|||
*/ |
|||
static inline bool state_can_add_htlc(enum state s) |
|||
{ |
|||
return state_is_normal(s); |
|||
} |
|||
|
|||
static inline bool state_can_remove_htlc(enum state s) |
|||
{ |
|||
return state_is_normal(s) || state_is_shutdown(s); |
|||
} |
|||
|
|||
#endif /* LIGHTNING_STATE_H */ |
|||
@ -1,99 +0,0 @@ |
|||
#ifndef LIGHTNING_STATE_TYPES_H |
|||
#define LIGHTNING_STATE_TYPES_H |
|||
#include "config.h" |
|||
/* FIXME: cdump is really dumb, so we put these in their own header. */ |
|||
#include "lightning.pb-c.h" |
|||
|
|||
enum state { |
|||
STATE_INIT, |
|||
|
|||
/*
|
|||
* Opening. |
|||
*/ |
|||
STATE_OPEN_WAIT_FOR_OPENPKT, |
|||
STATE_OPEN_WAIT_FOR_ANCHORPKT, |
|||
STATE_OPEN_WAIT_FOR_COMMIT_SIGPKT, |
|||
|
|||
/* We're waiting for depth+their complete. */ |
|||
STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE, |
|||
/* Got their pkt_complete. */ |
|||
STATE_OPEN_WAIT_ANCHORDEPTH, |
|||
/* Got anchor depth. */ |
|||
STATE_OPEN_WAIT_THEIRCOMPLETE, |
|||
|
|||
/*
|
|||
* Normal state. |
|||
*/ |
|||
STATE_NORMAL, |
|||
STATE_NORMAL_COMMITTING, |
|||
|
|||
/*
|
|||
* Closing (handled outside state machine). |
|||
*/ |
|||
STATE_SHUTDOWN, |
|||
STATE_SHUTDOWN_COMMITTING, |
|||
STATE_MUTUAL_CLOSING, |
|||
|
|||
/* Four states to represent closing onchain (for getpeers) */ |
|||
STATE_CLOSE_ONCHAIN_CHEATED, |
|||
STATE_CLOSE_ONCHAIN_THEIR_UNILATERAL, |
|||
STATE_CLOSE_ONCHAIN_OUR_UNILATERAL, |
|||
STATE_CLOSE_ONCHAIN_MUTUAL, |
|||
|
|||
/* All closed. */ |
|||
STATE_CLOSED, |
|||
|
|||
/*
|
|||
* Where angels fear to tread. |
|||
*/ |
|||
/* Bad packet from them / protocol breakdown. */ |
|||
STATE_ERR_BREAKDOWN, |
|||
/* The anchor didn't reach blockchain in reasonable time. */ |
|||
STATE_ERR_ANCHOR_TIMEOUT, |
|||
/* We saw a tx we didn't sign. */ |
|||
STATE_ERR_INFORMATION_LEAK, |
|||
/* We ended up in an unexpected state. */ |
|||
STATE_ERR_INTERNAL, |
|||
|
|||
STATE_MAX |
|||
}; |
|||
|
|||
enum state_input { |
|||
/*
|
|||
* Packet inputs. |
|||
*/ |
|||
PKT_OPEN = PKT__PKT_OPEN, |
|||
PKT_OPEN_ANCHOR = PKT__PKT_OPEN_ANCHOR, |
|||
PKT_OPEN_COMMIT_SIG = PKT__PKT_OPEN_COMMIT_SIG, |
|||
PKT_OPEN_COMPLETE = PKT__PKT_OPEN_COMPLETE, |
|||
|
|||
/* Updating the commit transaction: new HTLC */ |
|||
PKT_UPDATE_ADD_HTLC = PKT__PKT_UPDATE_ADD_HTLC, |
|||
/* Updating the commit transaction: I have your R value! */ |
|||
PKT_UPDATE_FULFILL_HTLC = PKT__PKT_UPDATE_FULFILL_HTLC, |
|||
/* Updating the commit transaction: your HTLC failed upstream */ |
|||
PKT_UPDATE_FAIL_HTLC = PKT__PKT_UPDATE_FAIL_HTLC, |
|||
|
|||
/* Committing updates */ |
|||
PKT_UPDATE_COMMIT = PKT__PKT_UPDATE_COMMIT, |
|||
PKT_UPDATE_REVOCATION = PKT__PKT_UPDATE_REVOCATION, |
|||
|
|||
/* If they want to close. */ |
|||
PKT_CLOSE_SHUTDOWN = PKT__PKT_CLOSE_SHUTDOWN, |
|||
|
|||
/* Something unexpected went wrong. */ |
|||
PKT_ERROR = PKT__PKT_ERROR, |
|||
|
|||
/*
|
|||
* Non-packet inputs. |
|||
*/ |
|||
INPUT_NONE, |
|||
|
|||
/*
|
|||
* Timeouts. |
|||
*/ |
|||
INPUT_CLOSE_COMPLETE_TIMEOUT, |
|||
|
|||
INPUT_MAX |
|||
}; |
|||
#endif /* LIGHTNING_STATE_TYPES_H */ |
|||
@ -1,73 +0,0 @@ |
|||
check: daemon-tests |
|||
|
|||
# We run three different bitcoinds, for different types of tests.
|
|||
# Provides limited paralellism.
|
|||
daemon-test-0-%: |
|||
NO_VALGRIND=$(NO_VALGRIND) VARIANT=0 daemon/test/test-$* |
|||
daemon-test-1-%: |
|||
NO_VALGRIND=$(NO_VALGRIND) VARIANT=1 daemon/test/test-$* |
|||
daemon-test-2-%: |
|||
NO_VALGRIND=$(NO_VALGRIND) VARIANT=2 daemon/test/test-$* |
|||
|
|||
# These don't work in parallel, so chain the deps
|
|||
daemon-test-0-steal: daemon-test-0-unilateral |
|||
daemon-test-0-unilateral: daemon-test-0-funding-timeout |
|||
daemon-test-0-funding-timeout: daemon-test-0-mutual-close-with-htlcs |
|||
daemon-test-0-mutual-close-with-htlcs: daemon-test-0-different-fees |
|||
daemon-test-0-different-fees: daemon-test-0-routing |
|||
daemon-test-0-routing: daemon-test-0-invoice |
|||
daemon-test-0-invoice: daemon-test-0-basic\ manual-commit |
|||
daemon-test-0-basic\ manual-commit: daemon-test-0-basic |
|||
daemon-test-0-basic: daemon-test-setup-0 |
|||
|
|||
daemon-test-2-steal\ --reconnect: daemon-test-2-unilateral\ --reconnect |
|||
daemon-test-2-unilateral\ --reconnect: daemon-test-2-funding-timeout\ --reconnect |
|||
daemon-test-2-funding-timeout\ --reconnect: daemon-test-2-mutual-close-with-htlcs\ --reconnect |
|||
daemon-test-2-mutual-close-with-htlcs\ --reconnect: daemon-test-2-different-fees\ --reconnect |
|||
daemon-test-2-different-fees\ --reconnect: daemon-test-2-routing\ --reconnect |
|||
daemon-test-2-routing\ --reconnect: daemon-test-2-invoice\ --reconnect |
|||
daemon-test-2-invoice\ --reconnect: daemon-test-2-basic\ manual-commit\ --reconnect |
|||
daemon-test-2-basic\ manual-commit\ --reconnect: daemon-test-2-basic\ --reconnect |
|||
daemon-test-2-basic\ --reconnect: daemon-test-setup-2 |
|||
|
|||
daemon-test-1-steal\ --restart: daemon-test-1-unilateral\ --restart |
|||
daemon-test-1-unilateral\ --restart: daemon-test-1-funding-timeout\ --restart |
|||
daemon-test-1-funding-timeout\ --restart: daemon-test-1-mutual-close-with-htlcs\ --restart |
|||
daemon-test-1-mutual-close-with-htlcs\ --restart: daemon-test-1-different-fees\ --restart |
|||
daemon-test-1-different-fees\ --restart: daemon-test-1-routing\ --restart |
|||
daemon-test-1-routing\ --restart: daemon-test-1-invoice\ --restart |
|||
daemon-test-1-invoice\ --restart: daemon-test-1-basic\ manual-commit\ --restart |
|||
daemon-test-1-basic\ manual-commit\ --restart: daemon-test-1-basic\ --restart |
|||
daemon-test-1-basic\ --restart: daemon-test-setup-1 |
|||
|
|||
# We shutdown first in case something is left over.
|
|||
daemon-test-setup-%: daemon-all |
|||
VARIANT=$* daemon/test/scripts/shutdown.sh 2>/dev/null || true |
|||
VARIANT=$* daemon/test/scripts/setup.sh |
|||
|
|||
daemon-test-shutdown-0: daemon-test-0-steal |
|||
VARIANT=0 daemon/test/scripts/shutdown.sh |
|||
daemon-test-shutdown-1: daemon-test-1-steal\ --restart |
|||
VARIANT=1 daemon/test/scripts/shutdown.sh |
|||
daemon-test-shutdown-2: daemon-test-2-steal\ --reconnect |
|||
VARIANT=2 daemon/test/scripts/shutdown.sh |
|||
|
|||
# Forms long dependency chains.
|
|||
daemon-all-test: daemon-test-shutdown-0 daemon-test-shutdown-1 daemon-test-shutdown-2 |
|||
|
|||
# Note that these actually #include everything they need, except ccan/ and bitcoin/.
|
|||
# That allows for unit testing of statics, and special effects.
|
|||
DAEMON_TEST_SRC := $(wildcard daemon/test/run-*.c) |
|||
DAEMON_TEST_OBJS := $(DAEMON_TEST_SRC:.c=.o) |
|||
DAEMON_TEST_PROGRAMS := $(DAEMON_TEST_OBJS:.o=) |
|||
|
|||
update-mocks: $(DAEMON_TEST_SRC:%=update-mocks/%) |
|||
|
|||
$(DAEMON_TEST_PROGRAMS): $(CCAN_OBJS) $(BITCOIN_OBJS) $(CORE_OBJS) $(CORE_TX_OBJS) $(CORE_PROTOBUF_OBJS) $(LIBBASE58_OBJS) $(WIRE_OBJS) libsecp256k1.a libsodium.a utils.o |
|||
|
|||
$(DAEMON_TEST_OBJS): $(DAEMON_HEADERS) $(DAEMON_JSMN_HEADERS) $(BITCOIN_HEADERS) $(CORE_HEADERS) $(CORE_TX_HEADERS) $(GEN_HEADERS) $(DAEMON_GEN_HEADERS) $(CCAN_HEADERS) $(WIRE_HEADERS) |
|||
|
|||
daemon-unit-tests: $(DAEMON_TEST_PROGRAMS:%=unittest/%) |
|||
|
|||
daemon-tests: daemon-unit-tests daemon-all-test |
|||
|
|||
@ -1,52 +0,0 @@ |
|||
#include "daemon/channel.c" |
|||
#include "daemon/htlc.c" |
|||
#include "daemon/htlc_state.c" |
|||
#include <assert.h> |
|||
#include <stdio.h> |
|||
|
|||
/* AUTOGENERATED MOCKS START */ |
|||
/* Generated stub for db_new_htlc */ |
|||
void db_new_htlc(struct peer *peer UNNEEDED, const struct htlc *htlc UNNEEDED) |
|||
{ fprintf(stderr, "db_new_htlc called!\n"); abort(); } |
|||
/* Generated stub for db_update_htlc_state */ |
|||
void db_update_htlc_state(struct peer *peer UNNEEDED, const struct htlc *htlc UNNEEDED, |
|||
enum htlc_state oldstate UNNEEDED) |
|||
{ fprintf(stderr, "db_update_htlc_state called!\n"); abort(); } |
|||
/* Generated stub for log_ */ |
|||
void log_(struct log *log UNNEEDED, enum log_level level UNNEEDED, const char *fmt UNNEEDED, ...) |
|||
|
|||
{ fprintf(stderr, "log_ called!\n"); abort(); } |
|||
/* Generated stub for peer_debug */ |
|||
void peer_debug(struct peer *peer UNNEEDED, const char *fmt UNNEEDED, ...) |
|||
|
|||
{ fprintf(stderr, "peer_debug called!\n"); abort(); } |
|||
/* Could not find declaration for tal_hexstr */ |
|||
/* Could not find declaration for type_to_string_ */ |
|||
/* AUTOGENERATED MOCKS END */ |
|||
|
|||
static void test_maxfee(size_t htlcs, u64 funds) |
|||
{ |
|||
struct channel_state cstate; |
|||
uint64_t maxrate; |
|||
|
|||
cstate.side[LOCAL].pay_msat = funds; |
|||
cstate.side[LOCAL].fee_msat = 0; |
|||
cstate.num_nondust = htlcs; |
|||
|
|||
maxrate = approx_max_feerate(&cstate, LOCAL); |
|||
assert(fee_by_feerate(tx_bytes(htlcs), maxrate) <= funds); |
|||
} |
|||
|
|||
int main(void) |
|||
{ |
|||
size_t htlcs, i; |
|||
for (htlcs = 0; htlcs < 600; htlcs++) { |
|||
for (i = 0; i < 32; i++) { |
|||
test_maxfee(htlcs, i); |
|||
test_maxfee(htlcs, 1ULL << i); |
|||
test_maxfee(htlcs, (1ULL << i) - 1); |
|||
test_maxfee(htlcs, (1ULL << i) + 1); |
|||
} |
|||
} |
|||
return 0; |
|||
} |
|||
@ -1,21 +0,0 @@ |
|||
#! /bin/sh |
|||
# Generate a block. |
|||
|
|||
set -e |
|||
|
|||
. `dirname $0`/vars.sh |
|||
INIT=$1 |
|||
|
|||
# Initially we need 100 blocks so coinbase matures, giving us funds. |
|||
if [ -n "$INIT" ]; then |
|||
# To activate segwit via BIP9, we need at least 432 blocks! |
|||
$CLI generate 432 > /dev/null |
|||
if $CLI getblockchaininfo | tr -s '\012\011 ' ' ' | grep -q '"segwit": { "status": "active",'; then : |
|||
else |
|||
echo "Segwit not activated after 432 blocks?" >&2 |
|||
$CLI getblockchaininfo >&2 |
|||
exit 1 |
|||
fi |
|||
else |
|||
$CLI generate 1 > /dev/null |
|||
fi |
|||
@ -1,29 +0,0 @@ |
|||
#! /bin/sh |
|||
# Query bitcoind to get (first) unspent output to spend. |
|||
|
|||
### |
|||
# Nobody should *EVER* write code like this. EVER!! |
|||
### |
|||
set -e |
|||
|
|||
. `dirname $0`/vars.sh |
|||
|
|||
NUM=1 |
|||
if [ $# = 1 ]; then |
|||
NUM=$1 |
|||
shift |
|||
fi |
|||
|
|||
if [ $# -gt 0 ]; then |
|||
echo "Usage: getinput.sh [INPUT-INDEX]" |
|||
exit 1 |
|||
fi |
|||
|
|||
TXID=`$CLI listunspent | sed -n 's/^ *"txid" *: *"\([0-9a-f]*\)",$/\1/p' | tail -n +$NUM | head -n1` |
|||
OUTNUM=`$CLI listunspent | sed -n 's/^ *"vout" *: *\([0-9]*\),$/\1/p' | tail -n +$NUM | head -n1` |
|||
AMOUNT=`$CLI listunspent | sed -n 's/^ *"amount" *: *\([0-9.]*\),$/\1/p' | tail -n +$NUM | head -n1 | tr -d . | sed 's/^0*//'` |
|||
SCRIPT=`$CLI listunspent | sed -n 's/^ *"scriptPubKey" *: *"\([0-9a-f]*\)",$/\1/p' | tail -n +$NUM | head -n1` |
|||
ADDR=`$CLI listunspent | sed -n 's/^ *"address" *: *"\([0-9a-zA-Z]*\)",$/\1/p' | tail -n +$NUM | head -n1` |
|||
PRIVKEY=`$CLI dumpprivkey $ADDR` |
|||
|
|||
echo $TXID/$OUTNUM/$AMOUNT/$SCRIPT/$PRIVKEY |
|||
@ -1,467 +0,0 @@ |
|||
#! /bin/sh |
|||
# Sourced by test script. |
|||
|
|||
# Takes the number of lightningd's we're going to start (2 or 3), then args |
|||
parse_cmdline() |
|||
{ |
|||
NUM_LIGHTNINGD=$1 |
|||
shift |
|||
|
|||
DIR1=/tmp/lightning.$$.1 |
|||
DIR2=/tmp/lightning.$$.2 |
|||
REDIR1="$DIR1/output" |
|||
REDIR2="$DIR2/output" |
|||
REDIRERR1="$DIR1/errors" |
|||
REDIRERR2="$DIR2/errors" |
|||
|
|||
if [ $NUM_LIGHTNINGD = 3 ]; then |
|||
DIR3=/tmp/lightning.$$.3 |
|||
REDIR3="$DIR3/output" |
|||
REDIRERR3="$DIR3/errors" |
|||
fi |
|||
|
|||
while [ $# != 0 ]; do |
|||
case x"$1" in |
|||
x"--valgrind-vgdb") |
|||
[ -n "$NO_VALGRIND" ] || PREFIX="$PREFIX --vgdb-error=1" |
|||
REDIR1="/dev/tty" |
|||
REDIRERR1="/dev/tty" |
|||
REDIR2="/dev/tty" |
|||
REDIRERR2="/dev/tty" |
|||
if [ $NUM_LIGHTNINGD = 3 ]; then |
|||
REDIR3="/dev/tty" |
|||
REDIRERR3="/dev/tty" |
|||
fi |
|||
;; |
|||
x"--gdb1") |
|||
GDB1=1 |
|||
;; |
|||
x"--gdb2") |
|||
GDB2=1 |
|||
;; |
|||
x"--gdb3") |
|||
GDB3=1 |
|||
if [ $NUM_LIGHTNINGD -lt 3 ]; then |
|||
echo "$1" invalid with only 2 lightning daemons >&2 |
|||
exit 1 |
|||
fi |
|||
;; |
|||
x"--gdb1="*) |
|||
DAEMON1_EXTRA=--dev-debugger=${1#--gdb1=} |
|||
;; |
|||
x"--gdb2="*) |
|||
DAEMON2_EXTRA=--dev-debugger=${1#--gdb2=} |
|||
;; |
|||
x"--reconnect") |
|||
RECONNECT=reconnect |
|||
;; |
|||
x"--restart") |
|||
RECONNECT=restart |
|||
;; |
|||
x"--crash") |
|||
CRASH_ON_FAIL=1 |
|||
;; |
|||
x"--verbose") |
|||
VERBOSE=1 |
|||
;; |
|||
*) |
|||
echo Unknown arg "$1" >&2 |
|||
exit 1 |
|||
esac |
|||
shift |
|||
done |
|||
|
|||
if [ -n "$VERBOSE" ]; then |
|||
FGREP="fgrep" |
|||
else |
|||
FGREP="fgrep -q" |
|||
# Suppress command output. |
|||
exec >/dev/null |
|||
fi |
|||
} |
|||
|
|||
failed() |
|||
{ |
|||
if [ -n "$CRASH_ON_FAIL" ]; then |
|||
$LCLI1 dev-crash 2>/dev/null || true |
|||
$LCLI2 dev-crash 2>/dev/null || true |
|||
echo -n Crash results in $DIR1 and $DIR2 >&2 |
|||
if [ -n "$LCLI3" ]; then |
|||
$LCLI3 dev-crash 2>/dev/null || true |
|||
echo and $DIR3 >&2 |
|||
else |
|||
echo >&2 |
|||
fi |
|||
fi |
|||
cat $DIR1/errors $DIR2/errors $DIR3/errors 2>/dev/null || true |
|||
exit 1 |
|||
} |
|||
|
|||
setup_lightning() |
|||
{ |
|||
NUM_LIGHTNINGD=$1 |
|||
|
|||
LCLI1="../lightning-cli --lightning-dir=$DIR1" |
|||
LCLI2="../lightning-cli --lightning-dir=$DIR2" |
|||
[ $NUM_LIGHTNINGD = 2 ] || LCLI3="../lightning-cli --lightning-dir=$DIR3" |
|||
|
|||
trap failed EXIT |
|||
mkdir $DIR1 $DIR2 |
|||
[ $NUM_LIGHTNINGD = 2 ] || mkdir $DIR3 |
|||
|
|||
cat > $DIR1/config <<EOF |
|||
disable-irc |
|||
log-level=debug |
|||
bitcoind-poll=5s |
|||
deadline-blocks=5 |
|||
min-htlc-expiry=6 |
|||
bitcoin-datadir=$DATADIR |
|||
locktime-blocks=6 |
|||
EOF |
|||
|
|||
cp $DIR1/config $DIR2/config |
|||
[ $NUM_LIGHTNINGD = 2 ] || cp $DIR1/config $DIR3/config |
|||
|
|||
# Find a free TCP port. |
|||
echo port=`findport 4000 $VARIANT` >> $DIR2/config |
|||
[ $NUM_LIGHTNINGD = 2 ] || echo port=`findport 4010 $VARIANT` >> $DIR3/config |
|||
} |
|||
|
|||
# Use DIR REDIR REDIRERR GDBFLAG BINARY EXTRAARGS |
|||
start_one_lightningd() |
|||
{ |
|||
# Need absolute path for re-exec testing. |
|||
local CMD |
|||
CMD="$(readlink -f `pwd`/../../$5) --lightning-dir=$1" |
|||
if [ -n "$4" ]; then |
|||
echo Press return once you run: gdb --args $CMD $6 >&2 |
|||
|
|||
read REPLY |
|||
else |
|||
CMD="$PREFIX $CMD" |
|||
$CMD $6 > $2 2> $3 & |
|||
fi |
|||
echo $CMD $6 |
|||
} |
|||
|
|||
start_lightningd() |
|||
{ |
|||
NUM_LIGHTNINGD=$1 |
|||
BINARY=${2:-daemon/lightningd} |
|||
|
|||
# If bitcoind not already running, start it. |
|||
if ! $CLI getinfo >/dev/null 2>&1; then |
|||
echo Starting bitcoind... |
|||
scripts/setup.sh |
|||
SHUTDOWN_BITCOIN=scripts/shutdown.sh |
|||
else |
|||
SHUTDOWN_BITCOIN=/bin/true |
|||
fi |
|||
|
|||
LIGHTNINGD1=`start_one_lightningd $DIR1 $REDIR1 $REDIRERR1 "$GDB1" $BINARY $DAEMON1_EXTRA` |
|||
LIGHTNINGD2=`start_one_lightningd $DIR2 $REDIR2 $REDIRERR2 "$GDB2" $BINARY $DAEMON2_EXTRA` |
|||
[ $NUM_LIGHTNINGD = 2 ] || LIGHTNINGD3=`start_one_lightningd $DIR3 $REDIR3 $REDIRERR3 "$GDB3" $BINARY` |
|||
|
|||
if ! check "$LCLI1 getlog 2>/dev/null | $FGREP Hello"; then |
|||
echo Failed to start daemon 1 >&2 |
|||
exit 1 |
|||
fi |
|||
|
|||
if ! check "$LCLI2 getlog 2>/dev/null | $FGREP Hello"; then |
|||
echo Failed to start daemon 2 >&2 |
|||
exit 1 |
|||
fi |
|||
|
|||
if [ $NUM_LIGHTNINGD = 3 ] && ! check "$LCLI3 getlog 2>/dev/null | $FGREP Hello"; then |
|||
echo Failed to start daemon 3 >&2 |
|||
exit 1 |
|||
fi |
|||
|
|||
# Version should match binary version |
|||
GETINFO_VERSION=`$LCLI1 getinfo | sed -n 's/.*"version" : "\([^"]*\)".*/\1/p'` |
|||
LCLI_VERSION=$($LCLI1 --version | head -n1) |
|||
LDAEMON_VERSION=$($LIGHTNINGD1 --version | head -n1) |
|||
if [ $GETINFO_VERSION != $LCLI_VERSION -o $GETINFO_VERSION != $LDAEMON_VERSION ]; then |
|||
echo Wrong versions: getinfo gave $GETINFO_VERSION, cli gave $LCLI_VERSION, daemon gave $LDAEMON_VERSION >&2 |
|||
exit 1 |
|||
fi |
|||
|
|||
ID1=`get_info_field "$LCLI1" id` |
|||
ID2=`get_info_field "$LCLI2" id` |
|||
[ $NUM_LIGHTNINGD = 2 ] || ID3=`get_info_field "$LCLI3" id` |
|||
|
|||
PORT2=`get_info_field "$LCLI2" port` |
|||
[ $NUM_LIGHTNINGD = 2 ] || PORT3=`get_info_field "$LCLI3" port` |
|||
} |
|||
|
|||
fund_lightningd() |
|||
{ |
|||
# Make a payment into a P2SH for anchor. |
|||
P2SHADDR=`$LCLI1 newaddr | sed -n 's/{ "address" : "\(.*\)" }/\1/p'` |
|||
FUND_INPUT_TXID=`$CLI sendtoaddress $P2SHADDR 0.01` |
|||
FUND_INPUT_TX=`$CLI getrawtransaction $FUND_INPUT_TXID` |
|||
|
|||
# Mine it so check_tx_spend doesn't see it (breaks some tests). |
|||
$CLI generate 1 |
|||
} |
|||
|
|||
lcli1() |
|||
{ |
|||
if [ -n "$VERBOSE" ]; then |
|||
echo $LCLI1 "$@" >&2 |
|||
fi |
|||
# Make sure we output if it fails; we need to capture it otherwise. |
|||
if ! OUT=`$LCLI1 "$@"`; then |
|||
echo "$OUT" |
|||
return 1 |
|||
fi |
|||
echo "$OUT" |
|||
if [ -n "$DO_RECONNECT" ]; then |
|||
case "$1" in |
|||
# Don't restart on every get* command. |
|||
get*) |
|||
;; |
|||
dev-disconnect) |
|||
;; |
|||
stop) |
|||
;; |
|||
*) |
|||
case "$RECONNECT" in |
|||
reconnect) |
|||
[ -z "$VERBOSE" ] || echo RECONNECTING >&2 |
|||
$LCLI1 dev-reconnect $ID2 >/dev/null |
|||
;; |
|||
restart) |
|||
[ -z "$VERBOSE" ] || echo RESTARTING >&2 |
|||
$LCLI1 -- dev-restart $LIGHTNINGD1 >/dev/null 2>&1 || true |
|||
if ! check "$LCLI1 getlog 2>/dev/null | fgrep -q Hello"; then |
|||
echo "dev-restart failed!">&2 |
|||
exit 1 |
|||
fi |
|||
;; |
|||
esac |
|||
# Wait for reconnect (if peer2 still there) |
|||
if [ -z "$NO_PEER2" ] && ! check "$LCLI1 getpeers | tr -s '\012\011\" ' ' ' | fgrep -q 'connected : true'"; then |
|||
echo "Failed to reconnect!">&2 |
|||
exit 1 |
|||
fi |
|||
|
|||
if [ "$1" = "dev-newhtlc" ]; then |
|||
# It might have gotten committed, or might be forgotten. |
|||
ID=`echo "$OUT" | extract_id` |
|||
if ! htlc_exists "$LCLI1" $2 $ID; then |
|||
if [ -z "$VERBOSE" ]; then |
|||
$LCLI1 "$@" >/dev/null 2>&1 || true |
|||
else |
|||
echo "Rerunning $LCLI1 $@" >&2 |
|||
$LCLI1 "$@" >&2 || true |
|||
fi |
|||
fi |
|||
# Make sure it's confirmed before we run next command, |
|||
# in case *that* restarts (unless manual commit) |
|||
[ -n "$MANUALCOMMIT" ] || check ! htlc_is_state \'"$LCLI1"\' $2 $ID SENT_ADD_HTLC |
|||
# Removals may also be forgotten. |
|||
elif [ "$1" = "fulfillhtlc" -o "$1" = "failhtlc" ]; then |
|||
ID="$3" |
|||
if htlc_is_state "$LCLI1" $2 $ID RCVD_ADD_ACK_REVOCATION; then |
|||
if [ -z "$VERBOSE" ]; then |
|||
$LCLI1 "$@" >/dev/null 2>&1 || true |
|||
else |
|||
echo "Rerunning $LCLI1 $@" >&2 |
|||
$LCLI1 "$@" >&2 || true |
|||
fi |
|||
# Make sure it's confirmed before we run next command, |
|||
# in case *that* restarts. |
|||
[ -n "$MANUALCOMMIT" ] || check ! htlc_is_state \'"$LCLI1"\' $2 $ID SENT_REMOVE_HTLC |
|||
fi |
|||
fi |
|||
;; |
|||
esac |
|||
fi |
|||
} |
|||
|
|||
lcli2() |
|||
{ |
|||
if [ -n "$VERBOSE" ]; then |
|||
echo $LCLI2 "$@" >&2 |
|||
fi |
|||
$LCLI2 "$@" |
|||
} |
|||
|
|||
lcli3() |
|||
{ |
|||
if [ -n "$VERBOSE" ]; then |
|||
echo $LCLI3 "$@" >&2 |
|||
fi |
|||
$LCLI3 "$@" |
|||
} |
|||
|
|||
all_ok() |
|||
{ |
|||
# Look for valgrind errors. |
|||
if grep ^== $DIR1/errors; then exit 1; fi |
|||
if grep ^== $DIR2/errors; then exit 1; fi |
|||
[ $NUM_LIGHTNINGD = 2 ] || if grep ^== $DIR3/errors; then exit 1; fi |
|||
|
|||
# Look for unknown logging types. |
|||
if grep "UNKNOWN TYPE" $DIR1/output >&2; then exit 1; fi |
|||
if grep "UNKNOWN TYPE" $DIR2/output >&2; then exit 1; fi |
|||
[ $NUM_LIGHTNINGD = 2 ] || if grep "UNKNOWN TYPE" $DIR3/output >&2; then exit 1; fi |
|||
$SHUTDOWN_BITCOIN |
|||
|
|||
trap "rm -rf $DIR1 $DIR2 $DIR3" EXIT |
|||
exit 0 |
|||
} |
|||
|
|||
# If result is in quotes, those are stripped. Spaces in quotes not handled |
|||
get_field() |
|||
{ |
|||
tr -s '\012\011" ' ' ' | sed 's/.* '$1' : \([^, }]*\).*/\1/' |
|||
} |
|||
|
|||
# If result is in quotes, those are stripped. Spaces in quotes not handled |
|||
get_info_field() |
|||
{ |
|||
$1 getinfo | tr -s '\012\011" ' ' ' | sed 's/.* '$2' : \([^, }]*\).*/\1/' |
|||
} |
|||
|
|||
# Peer $1 -> $2's htlc $3 is in state $4 |
|||
htlc_is_state() |
|||
{ |
|||
if [ $# != 4 ]; then echo "htlc_is_state got $# ARGS: $@" >&2; exit 1; fi |
|||
$1 gethtlcs $2 true | tr -s '\012\011\" ' ' ' | $FGREP "id : $3, state : $4 ," >&2 |
|||
} |
|||
|
|||
# Peer $1 -> $2's htlc $3 exists |
|||
htlc_exists() |
|||
{ |
|||
$1 gethtlcs $2 true | tr -s '\012\011\" ' ' ' | $FGREP "id : $3," >&2 |
|||
} |
|||
|
|||
blockheight() |
|||
{ |
|||
$CLI getblockcount |
|||
} |
|||
|
|||
# Usage: <cmd to test>... |
|||
check() |
|||
{ |
|||
local i=0 |
|||
while ! eval "$@"; do |
|||
sleep 1 |
|||
i=$(($i + 1)) |
|||
if [ $i = 60 ]; then |
|||
return 1 |
|||
fi |
|||
done |
|||
} |
|||
|
|||
check_balance_single() |
|||
{ |
|||
lcli="$1" |
|||
us_pay=$2 |
|||
us_fee=$3 |
|||
them_pay=$4 |
|||
them_fee=$5 |
|||
|
|||
if check "$lcli getpeers | tr -s '\012\011\" ' ' ' | $FGREP \"our_amount : $us_pay, our_fee : $us_fee, their_amount : $them_pay, their_fee : $them_fee,\""; then :; else |
|||
echo Cannot find $lcli output: "our_amount : $us_pay, our_fee : $us_fee, their_amount : $them_pay, their_fee : $them_fee," >&2 |
|||
$lcli getpeers | tr -s '\012\011" ' ' ' >&2 |
|||
return 1 |
|||
fi |
|||
} |
|||
|
|||
check_status_single() |
|||
{ |
|||
lcli="$1" |
|||
us_pay=$2 |
|||
us_fee=$3 |
|||
us_htlcs="$4" |
|||
them_pay=$5 |
|||
them_fee=$6 |
|||
them_htlcs="$7" |
|||
|
|||
check_balance_single "$lcli" $us_pay $us_fee $them_pay $them_fee |
|||
|
|||
if check "$lcli getpeers | tr -s '\012\011\" ' ' ' | $FGREP \"our_htlcs : [ $us_htlcs], their_htlcs : [ $them_htlcs]\""; then :; else |
|||
echo Cannot find $lcli output: "our_htlcs : [ $us_htlcs], their_htlcs : [ $them_htlcs]" >&2 |
|||
$lcli getpeers | tr -s '\012\011" ' ' ' >&2 |
|||
return 1 |
|||
fi |
|||
} |
|||
|
|||
# SEND_ -> RCVD_ and RCVD_ -> SEND_ |
|||
swap_status() |
|||
{ |
|||
echo "$@" | sed -e 's/state : RCVD_/@@/g' -e 's/state : SENT_/state : RCVD_/g' -e 's/@@/state : SENT_/g' |
|||
} |
|||
|
|||
check_status() |
|||
{ |
|||
us_pay=$1 |
|||
us_fee=$2 |
|||
us_htlcs="$3" |
|||
them_pay=$4 |
|||
them_fee=$5 |
|||
them_htlcs="$6" |
|||
|
|||
check_status_single lcli1 "$us_pay" "$us_fee" "$us_htlcs" "$them_pay" "$them_fee" "$them_htlcs" |
|||
check_status_single lcli2 "$them_pay" "$them_fee" "`swap_status \"$them_htlcs\"`" "$us_pay" "$us_fee" "`swap_status \"$us_htlcs\"`" |
|||
} |
|||
|
|||
check_tx_spend() |
|||
{ |
|||
local FAIL |
|||
FAIL=0 |
|||
if [ $# = 1 ]; then |
|||
check "$CLI getrawmempool | $FGREP $1" || FAIL=1 |
|||
else |
|||
check "$CLI getrawmempool | $FGREP '\"'" || FAIL=1 |
|||
fi |
|||
if [ $FAIL = 1 ]; then |
|||
echo "No tx $1 in mempool:" >&2 |
|||
$CLI getrawmempool >&2 |
|||
exit 1 |
|||
fi |
|||
} |
|||
|
|||
check_peerstate() |
|||
{ |
|||
if check "$1 getpeers | $FGREP -w $2"; then : |
|||
else |
|||
echo "$1" not in state "$2": >&2 |
|||
$1 getpeers >&2 |
|||
exit 1 |
|||
fi |
|||
} |
|||
|
|||
check_peerconnected() |
|||
{ |
|||
if check "$1 getpeers | tr -s '\012\011\" ' ' ' | $FGREP -w 'connected : '$2"; then : |
|||
else |
|||
echo "$1" not connected "$2": >&2 |
|||
$1 getpeers >&2 |
|||
exit 1 |
|||
fi |
|||
} |
|||
|
|||
check_no_peers() |
|||
{ |
|||
if check "$1 getpeers | tr -s '\012\011\" ' ' ' | $FGREP 'peers : [ ]'"; then : |
|||
else |
|||
echo "$1" still has peers: >&2 |
|||
$1 getpeers >&2 |
|||
exit 1 |
|||
fi |
|||
} |
|||
|
|||
extract_id() |
|||
{ |
|||
XID=`tr -s '\012\011\" ' ' ' | sed -n 's/{ id : \([0-9]*\) }/\1/p'` |
|||
case "$XID" in |
|||
[0-9]*) |
|||
echo $XID;; |
|||
*) |
|||
return 1;; |
|||
esac |
|||
} |
|||
@ -1,47 +0,0 @@ |
|||
#! /bin/sh -e |
|||
|
|||
. `dirname $0`/vars.sh |
|||
|
|||
VERSION=$(`dirname $0`/../../lightning-cli --version | head -n1) |
|||
[ $VERSION = `git describe --always --dirty` ] || (echo Wrong version $VERSION >&2; exit 1) |
|||
|
|||
# Start clean |
|||
rm -rf $DATADIR |
|||
mkdir $DATADIR |
|||
|
|||
# Find a free port (racy, but hey) |
|||
PORT=`findport 18332 $VARIANT` |
|||
RPCPORT=`findport $(($PORT + 1))` |
|||
|
|||
# Create appropriate config file so cmdline matches. |
|||
cat > $DATADIR/bitcoin.conf <<EOF |
|||
regtest=1 |
|||
testnet=0 |
|||
rpcport=$RPCPORT |
|||
port=$PORT |
|||
EOF |
|||
|
|||
$DAEMON & |
|||
i=0 |
|||
while ! $CLI getinfo >/dev/null 2>&1; do |
|||
if [ $i -gt 60 ]; then |
|||
echo $DAEMON start failed? >&1 |
|||
exit 1 |
|||
fi |
|||
sleep 1 |
|||
i=$(($i + 1)) |
|||
done |
|||
|
|||
# Make sure they have segwit support! |
|||
if $CLI getblockchaininfo | grep -q '"segwit"'; then : |
|||
else |
|||
echo This bitcoind does not have segwit support. >&2 |
|||
echo Please install a recent one >&2 |
|||
exit 1 |
|||
fi |
|||
|
|||
`dirname $0`/generate-block.sh init |
|||
|
|||
A1=$($CLI getnewaddress) |
|||
TX=`$CLI sendmany "" "{ \"$A1\":0.01 }"` |
|||
`dirname $0`/generate-block.sh |
|||
@ -1,11 +0,0 @@ |
|||
#! /bin/sh -e |
|||
|
|||
. `dirname $0`/vars.sh |
|||
|
|||
[ ! -f $DATADIR/regtest/bitcoind.pid ] || BITCOIN_PID=`cat $DATADIR/regtest/bitcoind.pid` |
|||
|
|||
$CLI stop |
|||
sleep 1 # Make sure socket is closed. |
|||
|
|||
# Now make sure it's dead. |
|||
if [ -n "$BITCOIN_PID" ]; then kill -9 $BITCOIN_PID 2>/dev/null || true; fi |
|||
@ -1,40 +0,0 @@ |
|||
# Sourced by other scripts |
|||
|
|||
# Bash variables for in-depth debugging. |
|||
#set -vx |
|||
#export PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }' |
|||
|
|||
# Suppress sync if we can, for speedup. |
|||
if which eatmydata >/dev/null; then EATMYDATA=eatmydata; fi |
|||
|
|||
DATADIR=/tmp/bitcoin-lightning$VARIANT |
|||
CLI="bitcoin-cli -datadir=$DATADIR" |
|||
REGTESTDIR=regtest |
|||
DAEMON="$EATMYDATA bitcoind -datadir=$DATADIR" |
|||
|
|||
PREFIX=$EATMYDATA |
|||
|
|||
# Always use valgrind if available (unless NO_VALGRIND=1 set) |
|||
if which valgrind >/dev/null; then :; else NO_VALGRIND=1; fi |
|||
[ -n "$NO_VALGRIND" ] || PREFIX="$EATMYDATA valgrind -q $VG_TRACE_CHILDREN --trace-children-skip=*bitcoin-cli* --error-exitcode=7" |
|||
|
|||
# We inject 0.01 bitcoin, but then fees (estimatefee fails and we use a |
|||
# fee rate as per the default). |
|||
AMOUNT=991880000 |
|||
|
|||
# Default fee rate per kb. |
|||
FEE_RATE=200000 |
|||
|
|||
# Fee in millisatoshi if we have no htlcs (note rounding to make it even) |
|||
NO_HTLCS_FEE=$((338 * $FEE_RATE / 2000 * 2000)) |
|||
ONE_HTLCS_FEE=$(( (338 + 32) * $FEE_RATE / 2000 * 2000)) |
|||
EXTRA_FEE=$(($ONE_HTLCS_FEE - $NO_HTLCS_FEE)) |
|||
|
|||
findport() |
|||
{ |
|||
PORT=$1 |
|||
# Give two ports per variant. |
|||
if [ x"$2" != x ]; then PORT=$(($PORT + $2 * 2)); fi |
|||
while netstat -ntl | grep -q ":$PORT "; do PORT=$(($PORT + 1)); done |
|||
echo $PORT |
|||
} |
|||
@ -1,359 +0,0 @@ |
|||
#! /bin/sh -e |
|||
|
|||
# Wherever we are, we want to be in daemon/test dir. |
|||
cd `git rev-parse --show-toplevel`/daemon/test |
|||
|
|||
. scripts/vars.sh |
|||
. scripts/helpers.sh |
|||
|
|||
if [ x"$1" = x"manual-commit" ]; then |
|||
MANUALCOMMIT=1 |
|||
shift |
|||
fi |
|||
|
|||
parse_cmdline 2 "$@" |
|||
setup_lightning 2 |
|||
|
|||
if [ -n "$MANUALCOMMIT" ]; then |
|||
# Aka. never. |
|||
echo 'commit-time=1h' >> $DIR1/config |
|||
echo 'commit-time=1h' >> $DIR2/config |
|||
fi |
|||
|
|||
start_lightningd 2 |
|||
fund_lightningd |
|||
|
|||
# Check IDs match logs |
|||
[ `$LCLI1 getlog | sed -n 's/.*"ID: \([0-9a-f]*\)".*/\1/p'` = $ID1 ] |
|||
[ `$LCLI2 getlog | sed -n 's/.*"ID: \([0-9a-f]*\)".*/\1/p'` = $ID2 ] |
|||
|
|||
lcli1 connect localhost $PORT2 $FUND_INPUT_TX & |
|||
|
|||
# Expect them to be waiting for anchor, and ack from other side. |
|||
check_peerstate lcli1 STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE |
|||
check_peerstate lcli2 STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE |
|||
|
|||
# Enable reconnect from here. |
|||
DO_RECONNECT=$RECONNECT |
|||
|
|||
# Now make it pass anchor (should be in mempool: one block to bury it) |
|||
check_tx_spend |
|||
$CLI generate 1 |
|||
|
|||
check_peerstate lcli1 STATE_NORMAL |
|||
check_peerstate lcli2 STATE_NORMAL |
|||
|
|||
# We turn off routing failure for the moment. |
|||
lcli1 dev-routefail false |
|||
lcli2 dev-routefail false |
|||
|
|||
A_AMOUNT=$(($AMOUNT - $NO_HTLCS_FEE)) |
|||
A_FEE=$NO_HTLCS_FEE |
|||
B_AMOUNT=0 |
|||
B_FEE=0 |
|||
check_status $A_AMOUNT $A_FEE "" $B_AMOUNT $B_FEE "" |
|||
|
|||
# This is 10,000 satoshi, so not dust! |
|||
HTLC_AMOUNT=10000000 |
|||
|
|||
EXPIRY=$(( $(blockheight) + 10)) |
|||
SECRET=1de08917a61cb2b62ed5937d38577f6a7bfe59c176781c6d8128018e8b5ccdfd |
|||
RHASH=`lcli1 dev-rhash $SECRET | sed 's/.*"\([0-9a-f]*\)".*/\1/'` |
|||
|
|||
HTLCID=`lcli1 dev-newhtlc $ID2 $HTLC_AMOUNT $EXPIRY $RHASH | extract_id` |
|||
|
|||
if [ -n "$MANUALCOMMIT" ]; then |
|||
# They should register a staged htlc. |
|||
check_status $A_AMOUNT $A_FEE "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_HTLC } " $B_AMOUNT $B_FEE "" |
|||
|
|||
# Now commit it. |
|||
lcli1 dev-commit $ID2 |
|||
|
|||
# Node 1 hasn't got it committed, but node2 should have told it to stage. |
|||
check_status_single lcli1 $A_AMOUNT $A_FEE "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : RCVD_ADD_REVOCATION } " $B_AMOUNT $B_FEE "" |
|||
|
|||
# Check channel status |
|||
A_AMOUNT=$(($A_AMOUNT - $EXTRA_FEE - $HTLC_AMOUNT)) |
|||
A_FEE=$(($A_FEE + $EXTRA_FEE)) |
|||
|
|||
# Node 2 has it committed. |
|||
check_status_single lcli2 $B_AMOUNT $B_FEE "" $A_AMOUNT $A_FEE "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_REVOCATION } " |
|||
|
|||
# There should be no "both committed" here yet |
|||
if lcli1 getlog debug | $FGREP "Both committed"; then |
|||
echo "Node1 thinks they are both committed"; |
|||
exit 1 |
|||
fi |
|||
if lcli2 getlog debug | $FGREP "Both committed"; then |
|||
echo "Node2 thinks they are both committed"; |
|||
exit 1 |
|||
fi |
|||
|
|||
# Now node2 gives commitment to node1. |
|||
lcli2 dev-commit $ID1 |
|||
|
|||
# After revocation, they should know they're both committed. |
|||
check lcli1 "getlog debug | $FGREP 'Both committed to ADD of our HTLC'" |
|||
check lcli2 "getlog debug | $FGREP 'Both committed to ADD of their HTLC'" |
|||
else |
|||
A_AMOUNT=$(($A_AMOUNT - $EXTRA_FEE - $HTLC_AMOUNT)) |
|||
A_FEE=$(($A_FEE + $EXTRA_FEE)) |
|||
fi |
|||
|
|||
# Both should have committed tx. |
|||
check_status $A_AMOUNT $A_FEE "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_ACK_REVOCATION } " $B_AMOUNT $B_FEE "" |
|||
|
|||
lcli2 dev-fulfillhtlc $ID1 $HTLCID $SECRET |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
|
|||
# Without manual commit, this check is racy. |
|||
if [ -n "$MANUALCOMMIT" ]; then |
|||
if lcli1 getlog debug | $FGREP 'Both committed to FULFILL'; then |
|||
echo "Node1 thinks they are both committed"; |
|||
exit 1 |
|||
fi |
|||
if lcli2 getlog debug | $FGREP 'Both committed to FULFILL'; then |
|||
echo "Node2 thinks they are both committed"; |
|||
exit 1 |
|||
fi |
|||
fi |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 |
|||
|
|||
# If we're very slow, manually committed above, and we're restarting, |
|||
# we may restart *after* this and thus not see it in the log. |
|||
[ "$RECONNECT$MANUALCOMMIT" = restart1 ] || check lcli1 "getlog debug | $FGREP 'Both committed to FULFILL of our HTLC'" |
|||
check lcli2 "getlog debug | $FGREP 'Both committed to FULFILL of their HTLC'" |
|||
|
|||
# We've transferred the HTLC amount to 2, who now has to pay fees, |
|||
# so no net change for A who saves on fees. |
|||
B_FEE=$HTLC_AMOUNT |
|||
# With no HTLCs, extra fee no longer required. |
|||
A_FEE=$(($A_FEE - $EXTRA_FEE - $B_FEE)) |
|||
A_AMOUNT=$(($A_AMOUNT + $EXTRA_FEE + $HTLC_AMOUNT)) |
|||
|
|||
check_status $A_AMOUNT $A_FEE "" $B_AMOUNT $B_FEE "" |
|||
|
|||
# A new one, at 10x the amount. |
|||
HTLC_AMOUNT=100000000 |
|||
|
|||
HTLCID=`lcli1 dev-newhtlc $ID2 $HTLC_AMOUNT $EXPIRY $RHASH | extract_id` |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
|
|||
# Check channel status |
|||
A_AMOUNT=$(($A_AMOUNT - $EXTRA_FEE - $HTLC_AMOUNT)) |
|||
A_FEE=$(($A_FEE + $EXTRA_FEE)) |
|||
check_status $A_AMOUNT $A_FEE "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_ACK_REVOCATION } " $B_AMOUNT $B_FEE "" |
|||
|
|||
lcli2 dev-failhtlc $ID1 $HTLCID 695 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 |
|||
|
|||
# Back to how we were before. |
|||
A_AMOUNT=$(($A_AMOUNT + $EXTRA_FEE + $HTLC_AMOUNT)) |
|||
A_FEE=$(($A_FEE - $EXTRA_FEE)) |
|||
check_status $A_AMOUNT $A_FEE "" $B_AMOUNT $B_FEE "" |
|||
|
|||
# Same again, but this time it expires. |
|||
HTLC_AMOUNT=10000001 |
|||
HTLCID=`lcli1 dev-newhtlc $ID2 $HTLC_AMOUNT $EXPIRY $RHASH | extract_id` |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
|
|||
# Check channel status |
|||
A_AMOUNT=$(($A_AMOUNT - $EXTRA_FEE - $HTLC_AMOUNT)) |
|||
A_FEE=$(($A_FEE + $EXTRA_FEE)) |
|||
check_status $A_AMOUNT $A_FEE "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_ACK_REVOCATION } " $B_AMOUNT $B_FEE "" |
|||
|
|||
# Make sure node1 accepts the expiry packet. |
|||
while [ $(blockheight) != $EXPIRY ]; do |
|||
$CLI generate 1 |
|||
done |
|||
|
|||
# This should make node2 send it. |
|||
$CLI generate 1 |
|||
|
|||
if [ -n "$MANUALCOMMIT" ]; then |
|||
check_status $A_AMOUNT $A_FEE "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : RCVD_REMOVE_HTLC } " $B_AMOUNT $B_FEE "" |
|||
|
|||
lcli2 dev-commit $ID1 |
|||
lcli1 dev-commit $ID2 |
|||
fi |
|||
|
|||
# Back to how we were before. |
|||
A_AMOUNT=$(($A_AMOUNT + $EXTRA_FEE + $HTLC_AMOUNT)) |
|||
A_FEE=$(($A_FEE - $EXTRA_FEE)) |
|||
check_status $A_AMOUNT $A_FEE "" $B_AMOUNT $B_FEE "" |
|||
|
|||
# First, give more money to node2, so it can offer HTLCs. |
|||
EXPIRY=$(( $(blockheight) + 10)) |
|||
HTLC_AMOUNT=100000000 |
|||
HTLCID=`lcli1 dev-newhtlc $ID2 $HTLC_AMOUNT $EXPIRY $RHASH | extract_id` |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
|
|||
check_status $(($A_AMOUNT - $HTLC_AMOUNT - $EXTRA_FEE)) $(($A_FEE + $EXTRA_FEE)) "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_ACK_REVOCATION } " $B_AMOUNT $B_FEE "" |
|||
|
|||
lcli2 dev-fulfillhtlc $ID1 $HTLCID $SECRET |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 |
|||
|
|||
# Both now pay equal fees. |
|||
A_FEE=$(($NO_HTLCS_FEE / 2)) |
|||
B_FEE=$(($NO_HTLCS_FEE / 2)) |
|||
# We transferred 10000000 before, and $HTLC_AMOUNT now. |
|||
A_AMOUNT=$(($AMOUNT - 10000000 - $HTLC_AMOUNT - $A_FEE)) |
|||
B_AMOUNT=$((10000000 + $HTLC_AMOUNT - $B_FEE)) |
|||
|
|||
check_status $A_AMOUNT $A_FEE "" $B_AMOUNT $B_FEE "" |
|||
|
|||
# Two failures crossover |
|||
SECRET2=1de08917a61cb2b62ed5937d38577f6a7bfe59c176781c6d8128018e8b5ccdfe |
|||
RHASH2=`lcli1 dev-rhash $SECRET2 | sed 's/.*"\([0-9a-f]*\)".*/\1/'` |
|||
|
|||
# This means B will *just* afford it (but can't cover increased fees) |
|||
HTLC_AMOUNT=$(($B_AMOUNT - $EXTRA_FEE / 2)) |
|||
HTLCID=`lcli2 dev-newhtlc $ID1 $HTLC_AMOUNT $EXPIRY $RHASH | extract_id` |
|||
# Make sure that's committed, in case lcli1 restarts. |
|||
lcli2 dev-commit $ID1 >/dev/null || true |
|||
|
|||
HTLCID2=`lcli1 dev-newhtlc $ID2 $HTLC_AMOUNT $EXPIRY $RHASH2 | extract_id` |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
|
|||
# A covers the extra part of the fee. |
|||
check_status $(($A_AMOUNT - $HTLC_AMOUNT - $EXTRA_FEE - $EXTRA_FEE / 2)) $(($A_FEE + $EXTRA_FEE + $EXTRA_FEE / 2)) "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH2 , state : SENT_ADD_ACK_REVOCATION } " 0 $(($B_FEE + $EXTRA_FEE / 2)) "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : RCVD_ADD_ACK_REVOCATION } " |
|||
|
|||
# Fail both, to reset. |
|||
lcli1 dev-failhtlc $ID2 $HTLCID 830 |
|||
lcli2 dev-failhtlc $ID1 $HTLCID2 829 |
|||
|
|||
[ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 |
|||
|
|||
check_status $A_AMOUNT $A_FEE "" $B_AMOUNT $B_FEE "" |
|||
|
|||
# Now, two HTLCs at once, one from each direction. |
|||
# Both sides can afford this. |
|||
HTLC_AMOUNT=1000000 |
|||
HTLCID=`lcli1 dev-newhtlc $ID2 $HTLC_AMOUNT $EXPIRY $RHASH | extract_id` |
|||
HTLCID2=`lcli2 dev-newhtlc $ID1 $HTLC_AMOUNT $EXPIRY $RHASH2 | extract_id` |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
|
|||
check_status $(($A_AMOUNT - $HTLC_AMOUNT - $EXTRA_FEE)) $(($A_FEE + $EXTRA_FEE)) "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_ACK_REVOCATION } " $(($B_AMOUNT - $HTLC_AMOUNT - $EXTRA_FEE)) $(($B_FEE + $EXTRA_FEE)) "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH2 , state : RCVD_ADD_ACK_REVOCATION } " |
|||
|
|||
lcli1 dev-fulfillhtlc $ID2 $HTLCID2 $SECRET2 |
|||
lcli2 dev-failhtlc $ID1 $HTLCID 849 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
|
|||
# We transferred amount from B to A. |
|||
A_AMOUNT=$(($A_AMOUNT + $HTLC_AMOUNT)) |
|||
B_AMOUNT=$(($B_AMOUNT - $HTLC_AMOUNT)) |
|||
check_status $A_AMOUNT $A_FEE "" $B_AMOUNT $B_FEE "" |
|||
|
|||
# Now, test making more changes before receiving commit reply. |
|||
DO_RECONNECT="" |
|||
lcli2 dev-output $ID1 false |
|||
HTLCID=`lcli1 dev-newhtlc $ID2 $HTLC_AMOUNT $EXPIRY $RHASH | extract_id` |
|||
|
|||
# Make sure node1 sends commit (in the background, since it will block!) |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 & |
|||
|
|||
if [ -n "$MANUALCOMMIT" ]; then |
|||
# node2 will consider this committed. |
|||
check_status_single lcli2 $(($B_AMOUNT - $EXTRA_FEE/2)) $(($B_FEE + $EXTRA_FEE/2)) "" $(($A_AMOUNT - $HTLC_AMOUNT - $EXTRA_FEE/2)) $(($A_FEE + $EXTRA_FEE/2)) "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_REVOCATION } " |
|||
else |
|||
# It will start committing by itself |
|||
check_status_single lcli2 $(($B_AMOUNT - $EXTRA_FEE/2)) $(($B_FEE + $EXTRA_FEE/2)) "" $(($A_AMOUNT - $HTLC_AMOUNT - $EXTRA_FEE/2)) $(($A_FEE + $EXTRA_FEE/2)) "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_ACK_COMMIT } " |
|||
fi |
|||
|
|||
# node1 will still be awaiting node2's revocation reply. |
|||
check_status_single lcli1 $(($A_AMOUNT)) $(($A_FEE)) "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_COMMIT } " $B_AMOUNT $B_FEE "" |
|||
|
|||
# Now send another offer, and enable node2 output. |
|||
HTLCID2=`lcli1 dev-newhtlc $ID2 $HTLC_AMOUNT $EXPIRY $RHASH2 | extract_id` |
|||
lcli2 dev-output $ID1 true |
|||
|
|||
[ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
|
|||
DO_RECONNECT=$RECONNECT |
|||
|
|||
# Both sides should be committed to htlcs |
|||
# We open-code check_status here: HTLCs could be in either order. |
|||
check_balance_single lcli1 $(($A_AMOUNT - $HTLC_AMOUNT*2 - $EXTRA_FEE)) $(($A_FEE + $EXTRA_FEE)) $(($B_AMOUNT - $EXTRA_FEE)) $(($B_FEE + $EXTRA_FEE)) |
|||
check_balance_single lcli2 $(($B_AMOUNT - $EXTRA_FEE)) $(($B_FEE + $EXTRA_FEE)) $(($A_AMOUNT - $HTLC_AMOUNT*2 - $EXTRA_FEE)) $(($A_FEE + $EXTRA_FEE)) |
|||
|
|||
# Once both balances are correct, this should be right. |
|||
lcli1 getpeers | tr -s '\012\011" ' ' ' | $FGREP "our_htlcs : [ { msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_ACK_REVOCATION }, { msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH2 , state : SENT_ADD_ACK_REVOCATION } ], their_htlcs : [ ]" || lcli1 getpeers | tr -s '\012\011" ' ' ' | $FGREP "our_htlcs : [ { msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH2 , state : SENT_ADD_ACK_REVOCATION }, { msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_ACK_REVOCATION } ], their_htlcs : [ ]" |
|||
|
|||
lcli2 getpeers | tr -s '\012\011" ' ' ' | $FGREP "our_htlcs : [ ], their_htlcs : [ { msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : RCVD_ADD_ACK_REVOCATION }, { msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH2 , state : RCVD_ADD_ACK_REVOCATION } ]" || lcli2 getpeers | tr -s '\012\011" ' ' ' | $FGREP "our_htlcs : [ ], their_htlcs : [ { msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH2 , state : RCVD_ADD_ACK_REVOCATION }, { msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : RCVD_ADD_ACK_REVOCATION } ]" |
|||
|
|||
# Just for once, reconnect/restart node 2. |
|||
case "$RECONNECT" in |
|||
reconnect) |
|||
echo RECONNECTING NODE2 |
|||
$LCLI2 dev-reconnect $ID1 >/dev/null |
|||
sleep 1 |
|||
;; |
|||
restart) |
|||
echo RESTARTING NODE2 |
|||
$LCLI2 -- dev-restart $LIGHTNINGD2 >/dev/null 2>&1 || true |
|||
if ! check "$LCLI2 getlog 2>/dev/null | fgrep -q Hello"; then |
|||
echo "Node2 dev-restart failed!">&2 |
|||
exit 1 |
|||
fi |
|||
;; |
|||
esac |
|||
|
|||
if ! check "$LCLI2 getpeers | tr -s '\012\011\" ' ' ' | fgrep -q 'connected : true'"; then |
|||
echo "Failed to reconnect!">&2 |
|||
exit 1 |
|||
fi |
|||
|
|||
# Node2 collects the HTLCs. |
|||
lcli2 dev-fulfillhtlc $ID1 $HTLCID $SECRET |
|||
lcli2 dev-fulfillhtlc $ID1 $HTLCID2 $SECRET2 |
|||
|
|||
[ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
[ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 |
|||
|
|||
# We transferred 2 * amount from A to B. |
|||
A_AMOUNT=$(($A_AMOUNT - $HTLC_AMOUNT * 2)) |
|||
B_AMOUNT=$(($B_AMOUNT + $HTLC_AMOUNT * 2)) |
|||
check_status $A_AMOUNT $A_FEE "" $B_AMOUNT $B_FEE "" |
|||
|
|||
lcli1 close $ID2 |
|||
|
|||
# They should be negotiating the close. |
|||
check_peerstate lcli1 STATE_MUTUAL_CLOSING |
|||
check_peerstate lcli2 STATE_MUTUAL_CLOSING |
|||
|
|||
$CLI generate 1 |
|||
|
|||
check_peerstate lcli1 STATE_CLOSE_ONCHAIN_MUTUAL |
|||
check_peerstate lcli2 STATE_CLOSE_ONCHAIN_MUTUAL |
|||
|
|||
# Give it forever-1 blocks. |
|||
$CLI generate 8 |
|||
|
|||
# Make sure they saw it! |
|||
check_peerstate lcli1 STATE_CLOSE_ONCHAIN_MUTUAL |
|||
check_peerstate lcli2 STATE_CLOSE_ONCHAIN_MUTUAL |
|||
|
|||
# Now the final one. |
|||
$CLI generate 1 |
|||
|
|||
check_no_peers lcli1 |
|||
check_no_peers lcli2 |
|||
|
|||
lcli1 stop |
|||
lcli2 stop |
|||
|
|||
all_ok |
|||
@ -1,86 +0,0 @@ |
|||
#! /bin/sh -e |
|||
|
|||
# Wherever we are, we want to be in daemon/test dir. |
|||
cd `git rev-parse --show-toplevel`/daemon/test |
|||
|
|||
. scripts/vars.sh |
|||
. scripts/helpers.sh |
|||
|
|||
parse_cmdline 2 "$@" |
|||
setup_lightning 2 |
|||
|
|||
# Simply override default fee (estimatefee fails on regtest anyway) |
|||
DEFAULT_FEE_RATE2=50000 |
|||
# We use 5x fee rate for commits, by defailt. |
|||
FEE_RATE2=$(($DEFAULT_FEE_RATE2 * 5)) |
|||
echo "default-fee-rate=$DEFAULT_FEE_RATE2" >> $DIR2/config |
|||
|
|||
start_lightningd 2 |
|||
fund_lightningd |
|||
|
|||
lcli1 connect localhost $PORT2 $FUND_INPUT_TX & |
|||
|
|||
# Now make it pass anchor (should be in mempool: one block to bury it) |
|||
check_tx_spend |
|||
$CLI generate 1 |
|||
|
|||
DO_RECONNECT=$RECONNECT |
|||
|
|||
check_peerstate lcli1 STATE_NORMAL |
|||
check_peerstate lcli2 STATE_NORMAL |
|||
|
|||
# Asymmetry, since fee rates different. |
|||
NO_HTLCS_FEE2=$((338 * $FEE_RATE2 / 2000 * 2000)) |
|||
ONE_HTLCS_FEE2=$(( (338 + 32) * $FEE_RATE2 / 2000 * 2000)) |
|||
|
|||
A_AMOUNT1=$(($AMOUNT - $NO_HTLCS_FEE)) |
|||
A_FEE1=$NO_HTLCS_FEE |
|||
A_AMOUNT2=$(($AMOUNT - $NO_HTLCS_FEE2)) |
|||
A_FEE2=$NO_HTLCS_FEE2 |
|||
B_AMOUNT=0 |
|||
B_FEE=0 |
|||
|
|||
check_status_single lcli1 $A_AMOUNT1 $A_FEE1 "" $B_AMOUNT $B_FEE "" |
|||
check_status_single lcli2 $B_AMOUNT $B_FEE "" $(($A_AMOUNT2)) $(($A_FEE2)) "" |
|||
|
|||
# This is 100,000 satoshi, so covers fees. |
|||
HTLC_AMOUNT=100000000 |
|||
RHASH=`lcli2 invoice $HTLC_AMOUNT RHASH3 | sed 's/.*"\([0-9a-f]*\)".*/\1/'` |
|||
ROUTE=`lcli1 getroute $ID2 $HTLC_AMOUNT 1` |
|||
ROUTE=`echo $ROUTE | sed 's/^{ "route" : \(.*\) }$/\1/'` |
|||
lcli1 sendpay "$ROUTE" $RHASH |
|||
|
|||
# They should not split fees. |
|||
check_status_single lcli1 $(($AMOUNT - $HTLC_AMOUNT - $NO_HTLCS_FEE / 2)) $(($NO_HTLCS_FEE / 2)) "" $(($HTLC_AMOUNT - $NO_HTLCS_FEE / 2)) $(($NO_HTLCS_FEE / 2)) "" |
|||
check_status_single lcli2 $(($HTLC_AMOUNT - $NO_HTLCS_FEE2 / 2)) $(($NO_HTLCS_FEE2 / 2)) "" $(($AMOUNT - $HTLC_AMOUNT - $NO_HTLCS_FEE2 / 2)) $(($NO_HTLCS_FEE2 / 2)) "" |
|||
|
|||
# FIXME: reactivate feechanges! |
|||
# # Change fee rate on node2 to same as node1. |
|||
# lcli2 dev-feerate 40000 |
|||
# $CLI generate 1 |
|||
# [ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
# [ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 |
|||
|
|||
# check_status $(($AMOUNT - $HTLC_AMOUNT - $NO_HTLCS_FEE / 2)) $(($NO_HTLCS_FEE / 2)) "" $(($HTLC_AMOUNT - $NO_HTLCS_FEE / 2)) $(($NO_HTLCS_FEE / 2)) "" |
|||
|
|||
# # Change back. |
|||
# lcli2 dev-feerate 50000 |
|||
# $CLI generate 1 |
|||
# [ ! -n "$MANUALCOMMIT" ] || lcli2 dev-commit $ID1 |
|||
# [ ! -n "$MANUALCOMMIT" ] || lcli1 dev-commit $ID2 |
|||
|
|||
# check_status_single lcli1 $(($AMOUNT - $HTLC_AMOUNT - $NO_HTLCS_FEE / 2)) $(($NO_HTLCS_FEE / 2)) "" $(($HTLC_AMOUNT - $NO_HTLCS_FEE / 2)) $(($NO_HTLCS_FEE / 2)) "" |
|||
# check_status_single lcli2 $(($HTLC_AMOUNT - $NO_HTLCS_FEE2 / 2)) $(($NO_HTLCS_FEE2 / 2)) "" $(($AMOUNT - $HTLC_AMOUNT - $NO_HTLCS_FEE2 / 2)) $(($NO_HTLCS_FEE2 / 2)) "" |
|||
|
|||
lcli1 close $ID2 |
|||
check_tx_spend |
|||
|
|||
# Give it 10 blocks ie "forever" |
|||
$CLI generate 10 |
|||
check_no_peers lcli1 |
|||
check_no_peers lcli2 |
|||
|
|||
lcli1 stop |
|||
lcli2 stop |
|||
|
|||
all_ok |
|||
@ -1,82 +0,0 @@ |
|||
#! /bin/sh -e |
|||
|
|||
# Wherever we are, we want to be in daemon/test dir. |
|||
cd `git rev-parse --show-toplevel`/daemon/test |
|||
|
|||
. scripts/vars.sh |
|||
. scripts/helpers.sh |
|||
|
|||
parse_cmdline 2 "$@" |
|||
setup_lightning 2 |
|||
start_lightningd 2 |
|||
fund_lightningd |
|||
|
|||
# Prevent anchor broadcast |
|||
lcli1 dev-broadcast false |
|||
lcli1 connect localhost $PORT2 $FUND_INPUT_TX & |
|||
|
|||
# Expect them to be waiting for anchor, and ack from other side. |
|||
check_peerstate lcli1 STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE |
|||
check_peerstate lcli2 STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE |
|||
|
|||
# Enable reconnect from here. |
|||
DO_RECONNECT=$RECONNECT |
|||
|
|||
$CLI generate 99 |
|||
|
|||
# Still waiting. |
|||
check_peerstate lcli1 STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE |
|||
check_peerstate lcli2 STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE |
|||
|
|||
# Make sure whichever times out first doesn't tell the other. |
|||
lcli1 dev-output $ID2 false |
|||
lcli2 dev-output $ID1 false |
|||
$CLI generate 1 |
|||
|
|||
# Node1 should have gone into STATE_ERR_ANCHOR_TIMEOUT. |
|||
check "lcli1 getlog debug | $FGREP STATE_ERR_ANCHOR_TIMEOUT" |
|||
|
|||
# Don't try to reconnect any more if we are. |
|||
if [ x"$RECONNECT" = xreconnect ]; then DO_RECONNECT=""; fi |
|||
|
|||
# If we're restarting, don't expect peer. |
|||
NO_PEER2=1 |
|||
|
|||
# Now let them send errors if they're still trying. |
|||
lcli2 dev-output $ID1 true || true |
|||
lcli1 dev-output $ID2 true || true |
|||
|
|||
# Peer 2 should give up, and have forgotten all about it. |
|||
check "lcli2 getlog debug | $FGREP STATE_CLOSED" |
|||
check_no_peers lcli2 |
|||
|
|||
# Node1 should be disconnected. |
|||
check_peerconnected lcli1 false |
|||
|
|||
# Now let node1 broadcast anchor and unilateral close belatedly! |
|||
lcli1 dev-broadcast true |
|||
|
|||
# Now mine that transaction so they see it. |
|||
$CLI generate 1 |
|||
check_peerstate lcli1 STATE_CLOSE_ONCHAIN_OUR_UNILATERAL |
|||
|
|||
# Now move bitcoind 1 day, which is what node2 asked for on commit. |
|||
# Get current time from last block (works if we run this twice). |
|||
CURTIME=$($CLI getblock $($CLI getblockhash $(($BLOCKHEIGHT + 100))) | sed -n 's/ "time": \([0-9]*\),/\1/p') |
|||
$CLI setmocktime $(($CURTIME + 24 * 60 * 60)) |
|||
|
|||
# Move average so CSV moves. |
|||
$CLI generate 6 |
|||
|
|||
# Now it should have spent the commit tx. |
|||
check_tx_spend |
|||
|
|||
# 100 blocks pass |
|||
$CLI generate 100 |
|||
|
|||
# Considers it all done now. |
|||
check_no_peers lcli1 |
|||
|
|||
lcli1 stop |
|||
lcli2 stop |
|||
all_ok |
|||
@ -1,87 +0,0 @@ |
|||
#! /bin/sh -e |
|||
|
|||
# Wherever we are, we want to be in daemon/test dir. |
|||
cd `git rev-parse --show-toplevel`/daemon/test |
|||
|
|||
. scripts/vars.sh |
|||
. scripts/helpers.sh |
|||
|
|||
parse_cmdline 2 "$@" |
|||
setup_lightning 2 |
|||
start_lightningd 2 |
|||
fund_lightningd |
|||
|
|||
lcli1 connect localhost $PORT2 $FUND_INPUT_TX & |
|||
|
|||
# Now make it pass anchor (should be in mempool: one block to bury it) |
|||
check_tx_spend |
|||
$CLI generate 1 |
|||
|
|||
DO_RECONNECT=$RECONNECT |
|||
|
|||
check_peerstate lcli1 STATE_NORMAL |
|||
check_peerstate lcli2 STATE_NORMAL |
|||
|
|||
A_AMOUNT=$(($AMOUNT - $NO_HTLCS_FEE)) |
|||
A_FEE=$NO_HTLCS_FEE |
|||
B_AMOUNT=0 |
|||
B_FEE=0 |
|||
check_status $A_AMOUNT $A_FEE "" $B_AMOUNT $B_FEE "" |
|||
|
|||
# 100k satoshi should cover fees. |
|||
HTLC_AMOUNT=100000000 |
|||
EXPIRY=$(( $(blockheight) + 10)) |
|||
RHASH3=`lcli2 invoice $HTLC_AMOUNT RHASH3 | sed 's/.*"\([0-9a-f]*\)".*/\1/'` |
|||
|
|||
lcli2 listinvoice |
|||
[ "`lcli2 listinvoice | tr -s '\012\011\" ' ' '`" = "[ { label : RHASH3 , rhash : $RHASH3 , msatoshi : $HTLC_AMOUNT, complete : false } ] " ] |
|||
|
|||
HTLCID3=`lcli1 dev-newhtlc $ID2 $HTLC_AMOUNT $EXPIRY $RHASH3 | extract_id` |
|||
|
|||
# We transferred amount from A to B, but fee now split evenly. |
|||
A_AMOUNT=$(($A_AMOUNT - $HTLC_AMOUNT + $NO_HTLCS_FEE / 2)) |
|||
B_AMOUNT=$(($B_AMOUNT + $HTLC_AMOUNT - $NO_HTLCS_FEE / 2)) |
|||
A_FEE=$(($NO_HTLCS_FEE / 2)) |
|||
B_FEE=$(($NO_HTLCS_FEE / 2)) |
|||
check_status $A_AMOUNT $A_FEE "" $B_AMOUNT $B_FEE "" |
|||
|
|||
[ "`lcli2 listinvoice | tr -s '\012\011\" ' ' '`" = "[ { label : RHASH3 , rhash : $RHASH3 , msatoshi : $HTLC_AMOUNT, complete : true } ] " ] |
|||
|
|||
# Now, failed payment (didn't pay enough) |
|||
RHASH4=`lcli2 invoice $HTLC_AMOUNT RHASH4 | sed 's/.*"\([0-9a-f]*\)".*/\1/'` |
|||
|
|||
# Shouldn't have this already. |
|||
if lcli2 getlog | $FGREP 'Short payment for'; then exit 1; fi |
|||
|
|||
# Test listinvoice with both, or subset (either order possible!) |
|||
INVOICES=`lcli2 listinvoice | tr -s '\012\011\" ' ' '` |
|||
[ "$INVOICES" = "[ { label : RHASH3 , rhash : $RHASH3 , msatoshi : $HTLC_AMOUNT, complete : true }, { label : RHASH4 , rhash : $RHASH4 , msatoshi : $HTLC_AMOUNT, complete : false } ] " ] || [ "$INVOICES" = "[ { label : RHASH4 , rhash : $RHASH4 , msatoshi : $HTLC_AMOUNT, complete : false }, { label : RHASH3 , rhash : $RHASH3 , msatoshi : $HTLC_AMOUNT, complete : true } ] " ] |
|||
[ "`lcli2 listinvoice RHASH3 | tr -s '\012\011\" ' ' '`" = "[ { label : RHASH3 , rhash : $RHASH3 , msatoshi : $HTLC_AMOUNT, complete : true } ] " ] |
|||
[ "`lcli2 listinvoice RHASH4 | tr -s '\012\011\" ' ' '`" = "[ { label : RHASH4 , rhash : $RHASH4 , msatoshi : $HTLC_AMOUNT, complete : false } ] " ] |
|||
|
|||
HTLCID4=`lcli1 dev-newhtlc $ID2 $(($HTLC_AMOUNT - 1)) $EXPIRY $RHASH4 | extract_id` |
|||
|
|||
check lcli2 "getlog | $FGREP 'Short payment for'" |
|||
check_status $A_AMOUNT $A_FEE "" $B_AMOUNT $B_FEE "" |
|||
|
|||
lcli2 delinvoice RHASH4 |
|||
if lcli2 delinvoice RHASH3 >/dev/null; then |
|||
echo "Should not be able to delete completed invoice!" >&2 |
|||
exit 1 |
|||
fi |
|||
|
|||
lcli1 close $ID2 |
|||
|
|||
# They should be negotiate the close. |
|||
check_tx_spend |
|||
|
|||
# Bury it in "forever" blocks. |
|||
$CLI generate 10 |
|||
|
|||
check_no_peers lcli1 |
|||
check_no_peers lcli2 |
|||
|
|||
lcli1 stop |
|||
lcli2 stop |
|||
|
|||
all_ok |
|||
@ -1,96 +0,0 @@ |
|||
#! /bin/sh -e |
|||
|
|||
# Wherever we are, we want to be in daemon/test dir. |
|||
cd `git rev-parse --show-toplevel`/daemon/test |
|||
|
|||
. scripts/vars.sh |
|||
. scripts/helpers.sh |
|||
|
|||
parse_cmdline 2 "$@" |
|||
setup_lightning 2 |
|||
start_lightningd 2 |
|||
fund_lightningd |
|||
|
|||
lcli1 connect localhost $PORT2 $FUND_INPUT_TX & |
|||
|
|||
# Now make it pass anchor (should be in mempool: one block to bury it) |
|||
check_tx_spend |
|||
$CLI generate 1 |
|||
|
|||
DO_RECONNECT=$RECONNECT |
|||
|
|||
check_peerstate lcli1 STATE_NORMAL |
|||
check_peerstate lcli2 STATE_NORMAL |
|||
|
|||
A_AMOUNT=$(($AMOUNT - $NO_HTLCS_FEE)) |
|||
A_FEE=$NO_HTLCS_FEE |
|||
B_AMOUNT=0 |
|||
B_FEE=0 |
|||
|
|||
# Send funds to 2 so it can offer HTLCS |
|||
HTLC_AMOUNT=100000000 |
|||
RHASH=`lcli2 invoice $HTLC_AMOUNT RHASH3 | sed 's/.*"\([0-9a-f]*\)".*/\1/'` |
|||
ROUTE=`lcli1 getroute $ID2 $HTLC_AMOUNT 1` |
|||
ROUTE=`echo $ROUTE | sed 's/^{ "route" : \(.*\) }$/\1/'` |
|||
lcli1 sendpay "$ROUTE" $RHASH |
|||
|
|||
# They pay half fees each. |
|||
A_AMOUNT=$(($A_AMOUNT - $HTLC_AMOUNT + $NO_HTLCS_FEE / 2)) |
|||
A_FEE=$(($NO_HTLCS_FEE / 2)) |
|||
B_AMOUNT=$(($B_AMOUNT + $HTLC_AMOUNT - $NO_HTLCS_FEE / 2)) |
|||
B_FEE=$(($NO_HTLCS_FEE / 2)) |
|||
check_status $A_AMOUNT $A_FEE "" $B_AMOUNT $B_FEE "" |
|||
|
|||
# For next step, make sure neither node fails HTLCs we're about to set up. |
|||
lcli1 dev-routefail false |
|||
lcli2 dev-routefail false |
|||
|
|||
# Set up HTLCs both ways. |
|||
|
|||
# This is 10,000 satoshi, so not dust! |
|||
HTLC_AMOUNT=10000000 |
|||
|
|||
EXPIRY=$(( $(blockheight) + 10)) |
|||
SECRET=1de08917a61cb2b62ed5937d38577f6a7bfe59c176781c6d8128018e8b5ccdfd |
|||
RHASH=`lcli1 dev-rhash $SECRET | sed 's/.*"\([0-9a-f]*\)".*/\1/'` |
|||
|
|||
HTLCID1=`lcli1 dev-newhtlc $ID2 $HTLC_AMOUNT $EXPIRY $RHASH | extract_id` |
|||
|
|||
# FIXME: Test with dust htlc, too. |
|||
HTLCID2=`lcli2 dev-newhtlc $ID1 $HTLC_AMOUNT $EXPIRY $RHASH | extract_id` |
|||
|
|||
check_status $(($A_AMOUNT - $HTLC_AMOUNT - $EXTRA_FEE)) $(($A_FEE + $EXTRA_FEE)) "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_ACK_REVOCATION } " $(($B_AMOUNT - $HTLC_AMOUNT - $EXTRA_FEE)) $(($B_FEE + $EXTRA_FEE)) "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : RCVD_ADD_ACK_REVOCATION } " |
|||
|
|||
# Now begin close |
|||
lcli1 close $ID2 |
|||
|
|||
# They should be waiting for it to clear up. |
|||
check_peerstate lcli1 STATE_SHUTDOWN |
|||
check_peerstate lcli2 STATE_SHUTDOWN |
|||
|
|||
# Fail one, still waiting. |
|||
lcli2 dev-failhtlc $ID1 $HTLCID1 800 |
|||
check_peerstate lcli1 STATE_SHUTDOWN |
|||
check_peerstate lcli2 STATE_SHUTDOWN |
|||
|
|||
# Fulfill the other causes them to actually complete the close. |
|||
lcli1 dev-fulfillhtlc $ID2 $HTLCID2 $SECRET |
|||
check_peerstate lcli1 STATE_MUTUAL_CLOSING |
|||
check_peerstate lcli2 STATE_MUTUAL_CLOSING |
|||
|
|||
check_tx_spend |
|||
$CLI generate 1 |
|||
|
|||
check_peerstate lcli1 STATE_CLOSE_ONCHAIN_MUTUAL |
|||
check_peerstate lcli2 STATE_CLOSE_ONCHAIN_MUTUAL |
|||
|
|||
# Give it "forever" blocks. |
|||
$CLI generate 9 |
|||
|
|||
check_no_peers lcli1 |
|||
check_no_peers lcli2 |
|||
|
|||
lcli1 stop |
|||
lcli2 stop |
|||
|
|||
all_ok |
|||
@ -1,146 +0,0 @@ |
|||
#! /bin/sh -e |
|||
|
|||
# Wherever we are, we want to be in daemon/test dir. |
|||
cd `git rev-parse --show-toplevel`/daemon/test |
|||
|
|||
. scripts/vars.sh |
|||
. scripts/helpers.sh |
|||
|
|||
parse_cmdline 3 "$@" |
|||
setup_lightning 3 |
|||
start_lightningd 3 |
|||
fund_lightningd |
|||
|
|||
# We connect 1->2->3 |
|||
lcli1 connect localhost $PORT2 $FUND_INPUT_TX & |
|||
check_tx_spend |
|||
$CLI generate 1 |
|||
|
|||
P2SHADDR2=`$LCLI2 newaddr | sed -n 's/{ "address" : "\(.*\)" }/\1/p'` |
|||
TXID2=`$CLI sendtoaddress $P2SHADDR2 0.01` |
|||
FUND_INPUT_TX2=`$CLI getrawtransaction $TXID2` |
|||
$CLI generate 1 |
|||
|
|||
lcli2 connect localhost $PORT3 $FUND_INPUT_TX2 & |
|||
check_tx_spend |
|||
$CLI generate 1 |
|||
|
|||
DO_RECONNECT=$RECONNECT |
|||
|
|||
# Make sure all in STATE_NORMAL. |
|||
check_peerstate lcli1 STATE_NORMAL |
|||
check_peerstate lcli3 STATE_NORMAL |
|||
|
|||
# More than enough to cover commit fees. |
|||
HTLC_AMOUNT=100000000 |
|||
|
|||
# Tell node 1 about the 2->3 route. |
|||
# Add to config in case we are restaring. |
|||
echo "add-route=$ID2/$ID3/546000/10/36/36" >> $DIR1/config |
|||
lcli1 dev-add-route $ID2 $ID3 546000 10 36 36 |
|||
RHASH=`lcli3 invoice $HTLC_AMOUNT RHASH | sed 's/.*"\([0-9a-f]*\)".*/\1/'` |
|||
BAD_RHASH=`echo $RHASH | tr '0-9a-f' 'a-f0-9'` |
|||
|
|||
# Get route. |
|||
ROUTE=`lcli1 getroute $ID3 $HTLC_AMOUNT 1` |
|||
ROUTE=`echo $ROUTE | sed 's/^{ "route" : \(.*\) }$/\1/'` |
|||
|
|||
# Try wrong hash. |
|||
if lcli1 sendpay "$ROUTE" $BAD_RHASH; then |
|||
echo Paid with wrong hash? >&2 |
|||
exit 1 |
|||
fi |
|||
|
|||
# Try underpaying. |
|||
PAID=`echo "$ROUTE" | sed -n 's/.*"msatoshi" : \([0-9]*\),.*/\1/p'` |
|||
UNDERPAY=`echo "$ROUTE" | sed "s/: $PAID,/: $(($PAID - 1)),/"` |
|||
if lcli1 sendpay "$UNDERPAY" $RHASH; then |
|||
echo Paid with too little? >&2 |
|||
exit 1 |
|||
fi |
|||
|
|||
# If restarting, make sure node3 remembers incoming payment. |
|||
if [ "$RECONNECT" = restart ]; then |
|||
$LCLI3 -- dev-restart $LIGHTNINGD3 >/dev/null 2>&1 || true |
|||
if ! check "$LCLI3 getpeers 2>/dev/null | tr -s '\012\011\" ' ' ' | fgrep -q 'connected : true'"; then |
|||
echo "Failed to reconnect!">&2 |
|||
exit 1 |
|||
fi |
|||
fi |
|||
|
|||
[ "`lcli3 listinvoice RHASH | tr -s '\012\011\" ' ' '`" = "[ { label : RHASH , rhash : $RHASH , msatoshi : $HTLC_AMOUNT, complete : false } ] " ] |
|||
# Pay correctly. |
|||
lcli1 sendpay "$ROUTE" $RHASH |
|||
|
|||
# Node 3 should end up with that amount (minus 1/2 tx fee) |
|||
# Note that it is delayed a little, since node2 fulfils as soon as fulfill |
|||
# starts. |
|||
check lcli3 "getpeers | $FGREP \"\\\"our_amount\\\" : $(($HTLC_AMOUNT - $NO_HTLCS_FEE / 2))\"" |
|||
|
|||
# If restarting, make sure node3 remembers completed payment. |
|||
if [ "$RECONNECT" = restart ]; then |
|||
echo RESTARTING NODE3 |
|||
$LCLI3 -- dev-restart $LIGHTNINGD3 >/dev/null 2>&1 || true |
|||
sleep 5 |
|||
$LCLI2 -- dev-restart $LIGHTNINGD2 >/dev/null 2>&1 || true |
|||
if ! check "$LCLI3 getpeers 2>/dev/null | tr -s '\012\011\" ' ' ' | fgrep -q 'connected : true'"; then |
|||
echo "Failed to reconnect!">&2 |
|||
exit 1 |
|||
fi |
|||
fi |
|||
|
|||
[ "`lcli3 listinvoice RHASH | tr -s '\012\011\" ' ' '`" = "[ { label : RHASH , rhash : $RHASH , msatoshi : $HTLC_AMOUNT, complete : true } ] " ] |
|||
|
|||
[ "`lcli3 waitanyinvoice | tr -s '\012\011\" ' ' '`" = "{ label : RHASH , rhash : $RHASH , msatoshi : $HTLC_AMOUNT } " ] |
|||
|
|||
# Can't pay twice (try from node2) |
|||
ROUTE2=`lcli2 getroute $ID3 $HTLC_AMOUNT 1` |
|||
ROUTE2=`echo $ROUTE2 | sed 's/^{ "route" : \(.*\) }$/\1/'` |
|||
if lcli2 sendpay "$ROUTE2" $RHASH; then |
|||
echo "Paying twice worked?" >&2 |
|||
exit 1 |
|||
fi |
|||
|
|||
lcli3 close $ID2 |
|||
check_peerstate lcli3 STATE_MUTUAL_CLOSING |
|||
|
|||
# Re-send should be a noop (doesn't matter that node3 is down!) |
|||
lcli1 sendpay "$ROUTE" $RHASH |
|||
|
|||
# Re-send to different id or amount should complain. |
|||
SHORTROUTE=`echo "$ROUTE" | sed 's/, { "id" : .* }//' | sed 's/"msatoshi" : [0-9]*,/"msatoshi" : '$HTLC_AMOUNT,/` |
|||
lcli1 sendpay "$SHORTROUTE" $RHASH | $FGREP "already succeeded to $ID3" |
|||
lcli1 sendpay "$UNDERPAY" $RHASH | $FGREP "already succeeded with amount $HTLC_AMOUNT" |
|||
|
|||
# Now node2 should fail to route. |
|||
if lcli1 sendpay "$ROUTE" $BAD_RHASH | $FGREP "failed: error code 404 node $ID2 reason Unknown peer"; then : ; |
|||
else |
|||
echo "Pay to node3 didn't give 404" >&2 |
|||
exit 1 |
|||
fi |
|||
|
|||
# Now node1 should fail to route (route deleted) |
|||
if lcli1 getroute $ID3 $HTLC_AMOUNT 1 | $FGREP "no route found"; then : ; |
|||
else |
|||
echo "Pay to node3 didn't fail instantly second time" >&2 |
|||
exit 1 |
|||
fi |
|||
|
|||
lcli1 close $ID2 |
|||
check_peerstate lcli1 STATE_MUTUAL_CLOSING |
|||
|
|||
# Make sure both txs broadcast. |
|||
check '[ `$CLI getrawmempool | egrep -c "[a-f0-9]{32}"` = 2 ]' |
|||
|
|||
# Bury them in "forever" blocks. |
|||
$CLI generate 10 |
|||
|
|||
check_no_peers lcli1 |
|||
check_no_peers lcli2 |
|||
check_no_peers lcli3 |
|||
|
|||
lcli1 stop |
|||
lcli2 stop |
|||
lcli3 stop |
|||
|
|||
all_ok |
|||
@ -1,91 +0,0 @@ |
|||
#! /bin/sh -e |
|||
|
|||
# Wherever we are, we want to be in daemon/test dir. |
|||
cd `git rev-parse --show-toplevel`/daemon/test |
|||
|
|||
. scripts/vars.sh |
|||
. scripts/helpers.sh |
|||
|
|||
parse_cmdline 2 "$@" |
|||
setup_lightning 2 |
|||
start_lightningd 2 |
|||
fund_lightningd |
|||
|
|||
lcli1 connect localhost $PORT2 $FUND_INPUT_TX & |
|||
|
|||
# Now make it pass anchor (should be in mempool: one block to bury it) |
|||
check_tx_spend |
|||
$CLI generate 1 |
|||
|
|||
DO_RECONNECT=$RECONNECT |
|||
|
|||
check_peerstate lcli1 STATE_NORMAL |
|||
check_peerstate lcli2 STATE_NORMAL |
|||
|
|||
A_AMOUNT=$(($AMOUNT - $NO_HTLCS_FEE)) |
|||
A_FEE=$NO_HTLCS_FEE |
|||
B_AMOUNT=0 |
|||
B_FEE=0 |
|||
|
|||
# Send funds to 2 so it can offer HTLCS |
|||
HTLC_AMOUNT=100000000 |
|||
RHASH=`lcli2 invoice $HTLC_AMOUNT RHASH3 | sed 's/.*"\([0-9a-f]*\)".*/\1/'` |
|||
ROUTE=`lcli1 getroute $ID2 $HTLC_AMOUNT 1` |
|||
ROUTE=`echo $ROUTE | sed 's/^{ "route" : \(.*\) }$/\1/'` |
|||
lcli1 sendpay "$ROUTE" $RHASH |
|||
|
|||
# They pay half fees each noe. |
|||
A_AMOUNT=$(($A_AMOUNT - $HTLC_AMOUNT + $NO_HTLCS_FEE / 2)) |
|||
A_FEE=$(($NO_HTLCS_FEE / 2)) |
|||
B_AMOUNT=$(($B_AMOUNT + $HTLC_AMOUNT - $NO_HTLCS_FEE / 2)) |
|||
B_FEE=$(($NO_HTLCS_FEE / 2)) |
|||
check_status $A_AMOUNT $A_FEE "" $B_AMOUNT $B_FEE "" |
|||
|
|||
# For next step, make sure neither node fails HTLCs we're about to set up. |
|||
lcli1 dev-routefail false |
|||
lcli2 dev-routefail false |
|||
|
|||
# Set up HTLCs both ways. |
|||
|
|||
# This is 10,000 satoshi, so not dust! |
|||
HTLC_AMOUNT=10000000 |
|||
|
|||
EXPIRY=$(( $(blockheight) + 10)) |
|||
SECRET=1de08917a61cb2b62ed5937d38577f6a7bfe59c176781c6d8128018e8b5ccdfd |
|||
RHASH=`lcli1 dev-rhash $SECRET | sed 's/.*"\([0-9a-f]*\)".*/\1/'` |
|||
|
|||
HTLCID1=`lcli1 dev-newhtlc $ID2 $HTLC_AMOUNT $EXPIRY $RHASH | extract_id` |
|||
|
|||
# FIXME: Test with dust htlc, too. |
|||
HTLCID2=`lcli2 dev-newhtlc $ID1 $HTLC_AMOUNT $EXPIRY $RHASH | extract_id` |
|||
|
|||
check_status $(($A_AMOUNT - $HTLC_AMOUNT - $EXTRA_FEE)) $(($A_FEE + $EXTRA_FEE)) "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_ACK_REVOCATION } " $(($B_AMOUNT - $HTLC_AMOUNT - $EXTRA_FEE)) $(($B_FEE + $EXTRA_FEE)) "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : RCVD_ADD_ACK_REVOCATION } " |
|||
|
|||
# This is the tx we're going to try to spend. |
|||
STEAL_TX=`$LCLI1 dev-signcommit $ID2 | cut -d\" -f4` |
|||
|
|||
# Fail one, succeed 2->1 payment |
|||
lcli2 dev-failhtlc $ID1 $HTLCID1 800 |
|||
lcli1 dev-fulfillhtlc $ID2 $HTLCID2 $SECRET |
|||
|
|||
A_AMOUNT=$(($A_AMOUNT + $HTLC_AMOUNT)) |
|||
B_AMOUNT=$(($B_AMOUNT - $HTLC_AMOUNT)) |
|||
check_status $A_AMOUNT $A_FEE "" $B_AMOUNT $B_FEE "" |
|||
|
|||
# Send out old commit tx from peer 1. |
|||
$CLI sendrawtransaction $STEAL_TX |
|||
$CLI generate 1 |
|||
|
|||
# Node1 should get really upset; node2 should steal the transaction. |
|||
check_peerstate lcli1 STATE_ERR_INFORMATION_LEAK |
|||
check_peerstate lcli2 STATE_CLOSE_ONCHAIN_CHEATED |
|||
check_tx_spend |
|||
|
|||
# Give it "forever" blocks. |
|||
$CLI generate 10 |
|||
|
|||
check_no_peers lcli2 |
|||
|
|||
lcli1 stop |
|||
lcli2 stop |
|||
all_ok |
|||
@ -1,87 +0,0 @@ |
|||
#! /bin/sh -e |
|||
|
|||
# Wherever we are, we want to be in daemon/test dir. |
|||
cd `git rev-parse --show-toplevel`/daemon/test |
|||
|
|||
. scripts/vars.sh |
|||
. scripts/helpers.sh |
|||
|
|||
parse_cmdline 2 "$@" |
|||
setup_lightning 2 |
|||
start_lightningd 2 |
|||
fund_lightningd |
|||
|
|||
lcli1 connect localhost $PORT2 $FUND_INPUT_TX & |
|||
|
|||
# Now make it pass anchor (should be in mempool: one block to bury it) |
|||
check_tx_spend |
|||
$CLI generate 1 |
|||
|
|||
DO_RECONNECT=$RECONNECT |
|||
|
|||
check_peerstate lcli1 STATE_NORMAL |
|||
check_peerstate lcli2 STATE_NORMAL |
|||
|
|||
# Make sure node2 doesn't fail |
|||
lcli2 dev-routefail false |
|||
|
|||
A_AMOUNT=$(($AMOUNT - $NO_HTLCS_FEE)) |
|||
A_FEE=$NO_HTLCS_FEE |
|||
B_AMOUNT=0 |
|||
B_FEE=0 |
|||
|
|||
# This is 10,000 satoshi, so not dust! |
|||
HTLC_AMOUNT=10000000 |
|||
|
|||
EXPIRY=$(( $(blockheight) + 10)) |
|||
SECRET=1de08917a61cb2b62ed5937d38577f6a7bfe59c176781c6d8128018e8b5ccdfd |
|||
RHASH=`lcli1 dev-rhash $SECRET | sed 's/.*"\([0-9a-f]*\)".*/\1/'` |
|||
|
|||
HTLCID=`lcli1 dev-newhtlc $ID2 $HTLC_AMOUNT $EXPIRY $RHASH | extract_id` |
|||
|
|||
A_AMOUNT=$(($A_AMOUNT - $EXTRA_FEE - $HTLC_AMOUNT)) |
|||
A_FEE=$(($A_FEE + $EXTRA_FEE)) |
|||
B_AMOUNT=0 |
|||
B_FEE=0 |
|||
|
|||
# Wait for both to committed. |
|||
check_status $A_AMOUNT $A_FEE "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_ACK_REVOCATION } " $B_AMOUNT $B_FEE "" |
|||
|
|||
# make node1 disconnect with node2. |
|||
lcli1 dev-disconnect $ID2 |
|||
check_peerconnected lcli1 false |
|||
|
|||
# lcli1 should have sent out commitment tx |
|||
check_peerstate lcli1 STATE_ERR_BREAKDOWN |
|||
check_tx_spend |
|||
|
|||
# Mine it. |
|||
$CLI generate 1 |
|||
check_peerstate lcli1 STATE_CLOSE_ONCHAIN_OUR_UNILATERAL |
|||
check_peerstate lcli2 STATE_CLOSE_ONCHAIN_THEIR_UNILATERAL |
|||
|
|||
# both still know about htlc |
|||
check_status $A_AMOUNT $A_FEE "{ msatoshi : $HTLC_AMOUNT, expiry : { block : $EXPIRY }, rhash : $RHASH , state : SENT_ADD_ACK_REVOCATION } " $B_AMOUNT $B_FEE "" |
|||
|
|||
# Generate 6 blocks so CSV timeout has expired. |
|||
$CLI generate 6 |
|||
|
|||
# Now, lcli1 should spend its own output. |
|||
check_tx_spend |
|||
check_peerstate lcli1 STATE_CLOSE_ONCHAIN_OUR_UNILATERAL |
|||
|
|||
while [ $(blockheight) != $EXPIRY ]; do |
|||
$CLI generate 1 |
|||
done |
|||
|
|||
# lcli1 should have gotten HTLC back. |
|||
check_tx_spend |
|||
|
|||
# Now, after "forever" blocks, should all be concluded. |
|||
$CLI generate 10 |
|||
|
|||
# Both consider it all done now. |
|||
check_no_peers lcli1 |
|||
|
|||
lcli1 stop |
|||
all_ok |
|||
@ -1,144 +0,0 @@ |
|||
/* Poor man's wallet.
|
|||
* Needed because bitcoind doesn't (yet) produce segwit outputs, and we need |
|||
* such outputs for our anchor tx to make it immalleable. |
|||
*/ |
|||
#include "bitcoin/base58.h" |
|||
#include "bitcoin/privkey.h" |
|||
#include "bitcoin/script.h" |
|||
#include "bitcoin/signature.h" |
|||
#include "bitcoin/tx.h" |
|||
#include "db.h" |
|||
#include "jsonrpc.h" |
|||
#include "lightningd.h" |
|||
#include "log.h" |
|||
#include "wallet.h" |
|||
#include <ccan/structeq/structeq.h> |
|||
#include <sodium/randombytes.h> |
|||
|
|||
struct wallet { |
|||
struct list_node list; |
|||
struct privkey privkey; |
|||
struct pubkey pubkey; |
|||
struct ripemd160 p2sh; |
|||
}; |
|||
|
|||
bool restore_wallet_address(struct lightningd_state *dstate, |
|||
const struct privkey *privkey) |
|||
{ |
|||
struct wallet *w = tal(dstate, struct wallet); |
|||
u8 *redeemscript; |
|||
struct sha256 h; |
|||
|
|||
w->privkey = *privkey; |
|||
if (!pubkey_from_privkey(&w->privkey, &w->pubkey)) |
|||
return false; |
|||
|
|||
redeemscript = bitcoin_redeem_p2sh_p2wpkh(w, &w->pubkey); |
|||
sha256(&h, redeemscript, tal_count(redeemscript)); |
|||
ripemd160(&w->p2sh, h.u.u8, sizeof(h)); |
|||
|
|||
list_add_tail(&dstate->wallet, &w->list); |
|||
tal_free(redeemscript); |
|||
return true; |
|||
} |
|||
|
|||
static void new_keypair(struct privkey *privkey, struct pubkey *pubkey) |
|||
{ |
|||
do { |
|||
randombytes_buf(privkey->secret.data, |
|||
sizeof(privkey->secret.data)); |
|||
} while (!pubkey_from_privkey(privkey, pubkey)); |
|||
} |
|||
|
|||
static struct wallet *find_by_pubkey(struct lightningd_state *dstate, |
|||
const struct pubkey *walletkey) |
|||
{ |
|||
struct wallet *w; |
|||
|
|||
list_for_each(&dstate->wallet, w, list) { |
|||
if (pubkey_eq(walletkey, &w->pubkey)) |
|||
return w; |
|||
} |
|||
return NULL; |
|||
} |
|||
|
|||
bool wallet_add_signed_input(struct lightningd_state *dstate, |
|||
const struct pubkey *walletkey, |
|||
struct bitcoin_tx *tx, |
|||
unsigned int input_num) |
|||
{ |
|||
u8 *redeemscript; |
|||
secp256k1_ecdsa_signature sig; |
|||
struct wallet *w = find_by_pubkey(dstate, walletkey); |
|||
|
|||
assert(input_num < tal_count(tx->input)); |
|||
if (!w) |
|||
return false; |
|||
|
|||
redeemscript = bitcoin_redeem_p2sh_p2wpkh(tx, &w->pubkey); |
|||
|
|||
sign_tx_input(tx, input_num, |
|||
redeemscript, |
|||
p2wpkh_scriptcode(redeemscript, &w->pubkey), |
|||
&w->privkey, |
|||
&w->pubkey, |
|||
&sig); |
|||
|
|||
bitcoin_witness_p2sh_p2wpkh(tx->input, |
|||
&tx->input[input_num], |
|||
&sig, |
|||
&w->pubkey); |
|||
tal_free(redeemscript); |
|||
return true; |
|||
} |
|||
|
|||
bool wallet_can_spend(struct lightningd_state *dstate, |
|||
const struct bitcoin_tx_output *output, |
|||
struct pubkey *walletkey) |
|||
{ |
|||
struct ripemd160 h; |
|||
struct wallet *w; |
|||
|
|||
if (!is_p2sh(output->script)) |
|||
return NULL; |
|||
|
|||
memcpy(&h, output->script + 2, 20); |
|||
list_for_each(&dstate->wallet, w, list) { |
|||
if (structeq(&h, &w->p2sh)) { |
|||
*walletkey = w->pubkey; |
|||
return true; |
|||
} |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
static void json_newaddr(struct command *cmd, |
|||
const char *buffer, const jsmntok_t *params) |
|||
{ |
|||
struct json_result *response = new_json_result(cmd); |
|||
struct wallet *w = tal(cmd->dstate, struct wallet); |
|||
u8 *redeemscript; |
|||
struct sha256 h; |
|||
|
|||
new_keypair(&w->privkey, &w->pubkey); |
|||
redeemscript = bitcoin_redeem_p2sh_p2wpkh(cmd, &w->pubkey); |
|||
sha256(&h, redeemscript, tal_count(redeemscript)); |
|||
ripemd160(&w->p2sh, h.u.u8, sizeof(h)); |
|||
|
|||
list_add_tail(&cmd->dstate->wallet, &w->list); |
|||
db_add_wallet_privkey(cmd->dstate, &w->privkey); |
|||
|
|||
json_object_start(response, NULL); |
|||
json_add_string(response, "address", |
|||
p2sh_to_base58(cmd, cmd->dstate->testnet, &w->p2sh)); |
|||
json_object_end(response); |
|||
command_success(cmd, response); |
|||
} |
|||
|
|||
static const struct json_command newaddr_command = { |
|||
"newaddr", |
|||
json_newaddr, |
|||
"Get a new address to fund a channel", |
|||
"Returns {address} a p2sh address" |
|||
}; |
|||
AUTODATA(json_command, &newaddr_command); |
|||
@ -1,21 +0,0 @@ |
|||
#ifndef LIGHTNING_DAEMON_WALLET_H |
|||
#define LIGHTNING_DAEMON_WALLET_H |
|||
#include "config.h" |
|||
|
|||
struct lightningd_state; |
|||
struct bitcoin_tx; |
|||
struct bitcoin_tx_output; |
|||
|
|||
bool restore_wallet_address(struct lightningd_state *dstate, |
|||
const struct privkey *privkey); |
|||
|
|||
bool wallet_add_signed_input(struct lightningd_state *dstate, |
|||
const struct pubkey *walletkey, |
|||
struct bitcoin_tx *tx, |
|||
unsigned int input_num); |
|||
|
|||
bool wallet_can_spend(struct lightningd_state *dstate, |
|||
const struct bitcoin_tx_output *output, |
|||
struct pubkey *walletkey); |
|||
|
|||
#endif /* LIGHTNING_DAEMON_WALLET_H */ |
|||
Loading…
Reference in new issue