Browse Source

channel: remove htlcs array.

We could put it back later for debugging, but we should be using the global
state not this array.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
ppa-0.6.1
Rusty Russell 8 years ago
parent
commit
19be4dbfe6
  1. 146
      daemon/channel.c
  2. 54
      daemon/channel.h
  3. 13
      daemon/packets.c
  4. 92
      daemon/peer.c
  5. 11
      remove_dust.h

146
daemon/channel.c

@ -1,5 +1,6 @@
#include "channel.h"
#include "htlc.h"
#include "remove_dust.h"
#include <assert.h>
#include <ccan/array_size/array_size.h>
#include <ccan/mem/mem.h>
@ -36,17 +37,6 @@ static uint64_t calculate_fee_msat(size_t num_nondust_htlcs,
return fee_by_feerate(bytes, fee_rate) * 1000;
}
/* Total, in millisatoshi. */
static uint64_t htlcs_total(struct htlc **htlcs)
{
size_t i, n = tal_count(htlcs);
uint64_t total = 0;
for (i = 0; i < n; i++)
total += htlcs[i]->msatoshis;
return total;
}
/* Pay this much fee, if possible. Return amount unpaid. */
static uint64_t pay_fee(struct channel_oneside *side, uint64_t fee_msat)
{
@ -103,11 +93,10 @@ static bool change_funding(uint64_t anchor_satoshis,
size_t num_nondust_htlcs)
{
uint64_t fee_msat;
uint64_t htlcs_total;
assert(a->pay_msat + a->fee_msat
+ b->pay_msat + b->fee_msat
+ htlcs_total(a->htlcs) + htlcs_total(b->htlcs)
== anchor_satoshis * 1000);
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);
@ -121,10 +110,9 @@ static bool change_funding(uint64_t anchor_satoshis,
a->pay_msat -= htlc_msat;
recalculate_fees(a, b, fee_msat);
assert(a->pay_msat + a->fee_msat
+ b->pay_msat + b->fee_msat
+ htlcs_total(a->htlcs) + htlcs_total(b->htlcs) + htlc_msat
== anchor_satoshis * 1000);
htlcs_total += htlc_msat;
assert(htlcs_total == anchor_satoshis * 1000
- (a->pay_msat + a->fee_msat + b->pay_msat + b->fee_msat));
return true;
}
@ -139,7 +127,7 @@ struct channel_state *initial_cstate(const tal_t *ctx,
cstate->fee_rate = fee_rate;
cstate->anchor = anchor_satoshis;
cstate->changes = 0;
cstate->num_nondust = 0;
/* Anchor must fit in 32 bit. */
if (anchor_satoshis >= (1ULL << 32) / 1000)
@ -153,8 +141,7 @@ struct channel_state *initial_cstate(const tal_t *ctx,
fundee = &cstate->side[!funding];
/* Neither side has HTLCs. */
funder->htlcs = tal_arr(cstate, struct htlc *, 0);
fundee->htlcs = tal_arr(cstate, struct htlc *, 0);
funder->num_htlcs = fundee->num_htlcs = 0;
/* Initially, all goes back to funder. */
funder->pay_msat = anchor_satoshis * 1000 - fee_msat;
@ -168,37 +155,13 @@ struct channel_state *initial_cstate(const tal_t *ctx,
return cstate;
}
/* Dust is defined as an output < 546*minRelayTxFee/1000.
* minRelayTxFee defaults to 1000 satoshi. */
bool is_dust_amount(uint64_t satoshis)
{
return satoshis < 546;
}
static size_t count_nondust_htlcs(struct htlc **htlcs)
{
size_t i, n = tal_count(htlcs), nondust = 0;
for (i = 0; i < n; i++)
if (!is_dust_amount(htlcs[i]->msatoshis / 1000))
nondust++;
return nondust;
}
static size_t total_nondust_htlcs(const struct channel_state *cstate)
{
return count_nondust_htlcs(cstate->side[OURS].htlcs)
+ count_nondust_htlcs(cstate->side[THEIRS].htlcs);
}
void adjust_fee(struct channel_state *cstate, uint32_t fee_rate)
{
uint64_t fee_msat;
fee_msat = calculate_fee_msat(total_nondust_htlcs(cstate), fee_rate);
fee_msat = calculate_fee_msat(cstate->num_nondust, fee_rate);
recalculate_fees(&cstate->side[OURS], &cstate->side[THEIRS], fee_msat);
cstate->changes++;
}
bool force_fee(struct channel_state *cstate, uint64_t fee)
@ -207,42 +170,29 @@ bool force_fee(struct channel_state *cstate, uint64_t fee)
if (fee > 0xFFFFFFFFFFFFFFFFULL / 1000)
return false;
recalculate_fees(&cstate->side[OURS], &cstate->side[THEIRS], fee * 1000);
cstate->changes++;
return cstate->side[OURS].fee_msat + cstate->side[THEIRS].fee_msat == fee * 1000;
}
/* Add a HTLC to @creator if it can afford it. */
bool cstate_add_htlc(struct channel_state *cstate,
struct htlc *htlc,
enum channel_side side)
bool cstate_add_htlc(struct channel_state *cstate, const struct htlc *htlc)
{
size_t n, nondust;
size_t nondust;
struct channel_oneside *creator, *recipient;
assert(htlc_channel_side(htlc) == side);
creator = &cstate->side[side];
recipient = &cstate->side[!side];
creator = &cstate->side[htlc_channel_side(htlc)];
recipient = &cstate->side[!htlc_channel_side(htlc)];
for (n = 0; n < tal_count(creator->htlcs); n++)
assert(creator->htlcs[n] != htlc);
/* Remember to count the new one in total txsize if not dust! */
nondust = total_nondust_htlcs(cstate);
if (!is_dust_amount(htlc->msatoshis / 1000))
nondust = cstate->num_nondust;
if (!is_dust(htlc->msatoshis / 1000))
nondust++;
if (!change_funding(cstate->anchor, cstate->fee_rate,
htlc->msatoshis, creator, recipient, nondust))
return false;
n = tal_count(creator->htlcs);
tal_resize(&creator->htlcs, n+1);
creator->htlcs[n] = htlc;
memcheck(&creator->htlcs[n]->msatoshis,
sizeof(creator->htlcs[n]->msatoshis));
memcheck(&creator->htlcs[n]->rhash, sizeof(creator->htlcs[n]->rhash));
cstate->changes++;
cstate->num_nondust = nondust;
creator->num_htlcs++;
return true;
}
@ -250,14 +200,13 @@ bool cstate_add_htlc(struct channel_state *cstate,
static void remove_htlc(struct channel_state *cstate,
enum channel_side creator,
enum channel_side beneficiary,
struct htlc *htlc)
const struct htlc *htlc)
{
size_t nondust;
size_t i, n = tal_count(cstate->side[creator].htlcs);
/* Remember to remove this one in total txsize if not dust! */
nondust = total_nondust_htlcs(cstate);
if (!is_dust_amount(htlc->msatoshis / 1000)) {
nondust = cstate->num_nondust;
if (!is_dust(htlc->msatoshis / 1000)) {
assert(nondust > 0);
nondust--;
}
@ -270,58 +219,25 @@ static void remove_htlc(struct channel_state *cstate,
abort();
/* Actually remove the HTLC. */
for (i = 0; i < tal_count(cstate->side[creator].htlcs); i++) {
if (cstate->side[creator].htlcs[i] == htlc) {
memmove(cstate->side[creator].htlcs + i,
cstate->side[creator].htlcs + i + 1,
(n - i - 1) * sizeof(htlc));
tal_resize(&cstate->side[creator].htlcs, n-1);
cstate->changes++;
return;
}
}
abort();
}
void cstate_fail_htlc(struct channel_state *cstate,
struct htlc *htlc,
enum channel_side side)
{
assert(htlc_channel_side(htlc) == side);
remove_htlc(cstate, side, side, htlc);
assert(cstate->side[creator].num_htlcs > 0);
cstate->side[creator].num_htlcs--;
cstate->num_nondust = nondust;
}
void cstate_fulfill_htlc(struct channel_state *cstate,
struct htlc *htlc,
enum channel_side side)
void cstate_fail_htlc(struct channel_state *cstate, const struct htlc *htlc)
{
assert(htlc_channel_side(htlc) == side);
remove_htlc(cstate, side, !side, htlc);
remove_htlc(cstate, htlc_channel_side(htlc), htlc_channel_side(htlc),
htlc);
}
struct htlc *cstate_htlc_by_id(const struct channel_state *cstate,
uint64_t id,
enum channel_side side)
void cstate_fulfill_htlc(struct channel_state *cstate, const struct htlc *htlc)
{
size_t i;
for (i = 0; i < tal_count(cstate->side[side].htlcs); i++) {
if (cstate->side[side].htlcs[i]->id == id)
return cstate->side[side].htlcs[i];
}
return NULL;
remove_htlc(cstate, htlc_channel_side(htlc), !htlc_channel_side(htlc),
htlc);
}
struct channel_state *copy_cstate(const tal_t *ctx,
const struct channel_state *cstate)
{
struct channel_state *cs = tal_dup(ctx, struct channel_state, cstate);
size_t i;
for (i = 0; i < ARRAY_SIZE(cs->side); i++) {
cs->side[i].htlcs = tal_dup_arr(cs, struct htlc *,
cs->side[i].htlcs,
tal_count(cs->side[i].htlcs), 0);
}
return cs;
return tal_dup(ctx, struct channel_state, cstate);
}

54
daemon/channel.h

@ -6,12 +6,13 @@
#include <ccan/tal/tal.h>
#include <stdbool.h>
struct htlc;
struct channel_oneside {
/* Payment and fee is in millisatoshi. */
uint32_t pay_msat, fee_msat;
/* Use tal_count to get the number */
/* FIXME: Use htlc_map, but needs permute changes. */
struct htlc **htlcs;
/* Number of HTLCs (required for limiting total number) */
unsigned int num_htlcs;
};
enum channel_side {
@ -26,8 +27,8 @@ struct channel_state {
uint64_t anchor;
/* Satoshis per 1000 bytes. */
uint32_t fee_rate;
/* Generation counter (incremented on every change) */
uint32_t changes;
/* Number of non-dust htlcs (to calculate txsize) */
unsigned int num_nondust;
struct channel_oneside side[2];
};
@ -57,41 +58,31 @@ struct channel_state *copy_cstate(const tal_t *ctx,
* cstate_add_htlc: append an HTLC to cstate if it can afford it
* @cstate: The channel state
* @htlc: the htlc pointer.
* @side: OURS or THEIRS
*
* If that direction can't afford the HTLC (or still owes its half of the fees),
* this will return false and leave @cstate unchanged. Otherwise
* cstate->side[dir].htlcs will have the HTLC appended, and pay_msat and
* this will 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,
struct htlc *htlc,
enum channel_side side);
bool cstate_add_htlc(struct channel_state *cstate, const struct htlc *htlc);
/**
* cstate_fail_htlc: remove an HTLC, funds to the side which offered it.
* @cstate: The channel state
* @htlc: the htlc in cstate->side[dir].htlcs[].
* @side: OURS or THEIRS
* @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,
struct htlc *htlc,
enum channel_side side);
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 in cstate->side[dir].htlcs[].
* @side: OURS or THEIRS
* @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,
struct htlc *htlc,
enum channel_side side);
void cstate_fulfill_htlc(struct channel_state *cstate, const struct htlc *htlc);
/**
* adjust_fee: Change fee rate.
@ -111,18 +102,6 @@ void adjust_fee(struct channel_state *cstate, uint32_t fee_rate);
*/
bool force_fee(struct channel_state *cstate, uint64_t fee);
/**
* cstate_htlc_by_id: find an HTLC on this side of the channel by ID.
* @cstate: The channel state
* @id: id for HTLC.
* @side: OURS or THEIRS
*
* Returns a pointer into cstate->side[@side].htlcs, or NULL.
*/
struct htlc *cstate_htlc_by_id(const struct channel_state *cstate,
uint64_t id,
enum channel_side side);
/**
* fee_for_feerate: calculate the fee (in satoshi) for a given fee_rate.
* @txsize: transaction size in bytes.
@ -130,13 +109,4 @@ struct htlc *cstate_htlc_by_id(const struct channel_state *cstate,
*/
uint64_t fee_by_feerate(size_t txsize, uint32_t fee_rate);
/**
* is_dust_amount: is an output of this value considered dust?
* @satoshis: number of satoshis.
*
* Transactions with dust outputs will not be relayed by the bitcoin
* network. It's not an exact definition, unfortunately.
*/
bool is_dust_amount(uint64_t satoshis);
#endif /* LIGHTNING_DAEMON_CHANNEL_H */

13
daemon/packets.c

@ -375,7 +375,7 @@ Pkt *accept_pkt_htlc_add(struct peer *peer, const Pkt *pkt, struct htlc **h)
* A node MUST NOT add a HTLC if it would result in it
* offering more than 300 HTLCs in the remote commitment transaction.
*/
if (tal_count(peer->remote.staging_cstate->side[THEIRS].htlcs) == 300)
if (peer->remote.staging_cstate->side[THEIRS].num_htlcs == 300)
return pkt_err(peer, "Too many HTLCs");
/* BOLT #2:
@ -403,19 +403,20 @@ Pkt *accept_pkt_htlc_add(struct peer *peer, const Pkt *pkt, struct htlc **h)
static Pkt *find_commited_htlc(struct peer *peer, uint64_t id,
struct htlc **local_htlc)
{
*local_htlc = htlc_get(&peer->htlcs, id, LOCAL);
/* BOLT #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 (!cstate_htlc_by_id(peer->local.commit->cstate, id, OURS))
if (!(*local_htlc))
return pkt_err(peer, "Did not find HTLC %"PRIu64, id);
/* They must not fail/fulfill twice, so it should be in staging, too. */
*local_htlc = cstate_htlc_by_id(peer->local.staging_cstate, id, OURS);
if (!*local_htlc)
return pkt_err(peer, "Already removed 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;
}

92
daemon/peer.c

@ -19,6 +19,7 @@
#include "permute_tx.h"
#include "protobuf_convert.h"
#include "pseudorand.h"
#include "remove_dust.h"
#include "routing.h"
#include "secrets.h"
#include "state.h"
@ -131,7 +132,7 @@ static const struct bitcoin_tx *bitcoin_spend_ours(struct peer *peer)
/* FIXME: Fail gracefully in these cases (not worth collecting) */
if (fee > commit->output[p2wsh_out].amount
|| is_dust_amount(commit->output[p2wsh_out].amount - fee))
|| is_dust(commit->output[p2wsh_out].amount - fee))
fatal("Amount of %"PRIu64" won't cover fee %"PRIu64,
commit->output[p2wsh_out].amount, fee);
@ -223,8 +224,6 @@ static bool peer_uncommitted_changes(const struct peer *peer)
static void remote_changes_pending(struct peer *peer)
{
log_debug(peer->log, "remote_changes_pending: changes=%u",
peer->remote.staging_cstate->changes);
if (!peer->commit_timer) {
log_debug(peer->log, "remote_changes_pending: adding timer");
peer->commit_timer = new_reltimer(peer->dstate, peer,
@ -547,12 +546,12 @@ static void adjust_cstate_side(struct channel_state *cstate,
if (old_committed && !new_committed) {
if (h->r)
cstate_fulfill_htlc(cstate, h, htlc_channel_side(h));
cstate_fulfill_htlc(cstate, h);
else
cstate_fail_htlc(cstate, h, htlc_channel_side(h));
cstate_fail_htlc(cstate, h);
} else if (!old_committed && new_committed) {
/* FIXME: This can happen; see BOLT */
if (!cstate_add_htlc(cstate, h, htlc_channel_side(h)))
if (!cstate_add_htlc(cstate, h))
fatal("Could not afford htlc");
}
}
@ -839,7 +838,7 @@ static Pkt *handle_pkt_htlc_add(struct peer *peer, const Pkt *pkt)
* "Fee Calculation" ). A node SHOULD fail the connection if
* this occurs.
*/
if (!cstate_add_htlc(peer->local.staging_cstate, htlc, THEIRS)) {
if (!cstate_add_htlc(peer->local.staging_cstate, htlc)) {
tal_free(htlc);
return pkt_err(peer, "Cannot afford %"PRIu64" milli-satoshis"
" in our commitment tx",
@ -857,7 +856,7 @@ static Pkt *handle_pkt_htlc_fail(struct peer *peer, const Pkt *pkt)
if (err)
return err;
cstate_fail_htlc(peer->local.staging_cstate, htlc, OURS);
cstate_fail_htlc(peer->local.staging_cstate, htlc);
/* BOLT #2:
*
@ -885,7 +884,7 @@ static Pkt *handle_pkt_htlc_fulfill(struct peer *peer, const Pkt *pkt)
* ... and the receiving node MUST add the HTLC fulfill/fail
* to the unacked changeset for its local commitment.
*/
cstate_fulfill_htlc(peer->local.staging_cstate, htlc, OURS);
cstate_fulfill_htlc(peer->local.staging_cstate, htlc);
htlc_changestate(htlc, SENT_ADD_ACK_REVOCATION, RCVD_REMOVE_HTLC);
return NULL;
}
@ -1204,7 +1203,7 @@ static const struct bitcoin_tx *htlc_fulfill_tx(const struct peer *peer,
peer->dstate->config.closing_fee_rate);
/* FIXME: Fail gracefully in these cases (not worth collecting) */
if (fee > satoshis || is_dust_amount(satoshis - fee))
if (fee > satoshis || is_dust(satoshis - fee))
fatal("HTLC fulfill amount of %"PRIu64" won't cover fee %"PRIu64,
satoshis, fee);
@ -1234,9 +1233,7 @@ static bool command_htlc_fail(struct peer *peer, struct htlc *htlc)
* The sending node MUST add the HTLC fulfill/fail to the
* unacked changeset for its remote commitment
*/
assert(cstate_htlc_by_id(peer->remote.staging_cstate, htlc->id, THEIRS)
== htlc);
cstate_fail_htlc(peer->remote.staging_cstate, htlc, THEIRS);
cstate_fail_htlc(peer->remote.staging_cstate, htlc);
htlc_changestate(htlc, RCVD_ADD_ACK_REVOCATION, SENT_REMOVE_HTLC);
@ -1285,9 +1282,7 @@ static bool command_htlc_fulfill(struct peer *peer, struct htlc *htlc)
* The sending node MUST add the HTLC fulfill/fail to the
* unacked changeset for its remote commitment
*/
assert(cstate_htlc_by_id(peer->remote.staging_cstate, htlc->id, THEIRS)
== htlc);
cstate_fulfill_htlc(peer->remote.staging_cstate, htlc, THEIRS);
cstate_fulfill_htlc(peer->remote.staging_cstate, htlc);
htlc_changestate(htlc, RCVD_ADD_ACK_REVOCATION, SENT_REMOVE_HTLC);
@ -1329,7 +1324,7 @@ struct htlc *command_htlc_add(struct peer *peer, u64 msatoshis,
* A node MUST NOT add a HTLC if it would result in it
* offering more than 300 HTLCs in the remote commitment transaction.
*/
if (tal_count(peer->remote.staging_cstate->side[OURS].htlcs) == 300) {
if (peer->remote.staging_cstate->side[OURS].num_htlcs == 300) {
log_unusual(peer->log, "add_htlc: fail: already at limit");
return NULL;
}
@ -1352,7 +1347,7 @@ struct htlc *command_htlc_add(struct peer *peer, u64 msatoshis,
* the remote commitment transaction at the current `fee_rate`
*/
cstate = copy_cstate(peer, peer->remote.staging_cstate);
if (!cstate_add_htlc(cstate, htlc, OURS)) {
if (!cstate_add_htlc(cstate, htlc)) {
log_unusual(peer->log, "add_htlc: fail: Cannot afford %"PRIu64
" milli-satoshis in their commit tx",
msatoshis);
@ -1361,7 +1356,7 @@ struct htlc *command_htlc_add(struct peer *peer, u64 msatoshis,
tal_free(cstate);
cstate = copy_cstate(peer, peer->local.staging_cstate);
if (!cstate_add_htlc(cstate, htlc, OURS)) {
if (!cstate_add_htlc(cstate, htlc)) {
log_unusual(peer->log, "add_htlc: fail: Cannot afford %"PRIu64
" milli-satoshis in our commit tx",
msatoshis);
@ -1374,7 +1369,7 @@ struct htlc *command_htlc_add(struct peer *peer, u64 msatoshis,
* The sending node MUST add the HTLC addition to the unacked
* changeset for its remote commitment
*/
if (!cstate_add_htlc(peer->remote.staging_cstate, htlc, OURS))
if (!cstate_add_htlc(peer->remote.staging_cstate, htlc))
fatal("Could not add HTLC?");
remote_changes_pending(peer);
@ -1538,11 +1533,12 @@ static void do_commit(struct peer *peer, struct command *jsoncmd)
ci->cstate, REMOTE);
bitcoin_txid(ci->tx, &ci->txid);
log_debug(peer->log, "Signing tx for %u/%u msatoshis, %zu/%zu htlcs",
log_debug(peer->log, "Signing tx for %u/%u msatoshis, %u/%u htlcs (%u non-dust)",
ci->cstate->side[OURS].pay_msat,
ci->cstate->side[THEIRS].pay_msat,
tal_count(ci->cstate->side[OURS].htlcs),
tal_count(ci->cstate->side[THEIRS].htlcs));
ci->cstate->side[OURS].num_htlcs,
ci->cstate->side[THEIRS].num_htlcs,
ci->cstate->num_nondust);
log_add_struct(peer->log, " (txid %s)", struct sha256_double, &ci->txid);
ci->sig = tal(ci, struct bitcoin_signature);
@ -1963,18 +1959,23 @@ const struct json_command connect_command = {
};
/* Have any of our HTLCs passed their deadline? */
static bool any_deadline_past(struct peer *peer,
const struct channel_state *cstate)
static bool any_deadline_past(struct peer *peer)
{
size_t i;
u32 height = get_block_height(peer->dstate);
struct htlc **htlcs = cstate->side[OURS].htlcs;
struct htlc_map_iter it;
struct htlc *h;
for (i = 0; i < tal_count(htlcs); i++) {
if (height >= htlcs[i]->deadline) {
for (h = htlc_map_first(&peer->htlcs, &it);
h;
h = htlc_map_next(&peer->htlcs, &it)) {
if (htlc_is_dead(h))
continue;
if (htlc_owner(h) != LOCAL)
continue;
if (height >= h->deadline) {
log_unusual_struct(peer->log,
"HTLC %s deadline has passed",
struct htlc, htlcs[i]);
struct htlc, h);
return true;
}
}
@ -1983,26 +1984,28 @@ static bool any_deadline_past(struct peer *peer,
static void check_htlc_expiry(struct peer *peer)
{
size_t i;
u32 height = get_block_height(peer->dstate);
struct htlc_map_iter it;
struct htlc *h;
again:
/* Check their currently still-existing htlcs for expiry:
* We eliminate them from staging as we go. */
for (i = 0; i < tal_count(peer->remote.staging_cstate->side[THEIRS].htlcs); i++) {
struct htlc *htlc = peer->remote.staging_cstate->side[THEIRS].htlcs[i];
/* Check their currently still-existing htlcs for expiry */
for (h = htlc_map_first(&peer->htlcs, &it);
h;
h = htlc_map_next(&peer->htlcs, &it)) {
assert(!abs_locktime_is_seconds(&h->expiry));
assert(!abs_locktime_is_seconds(&htlc->expiry));
/* Only their consider HTLCs which are completely locked in. */
if (h->state != RCVD_ADD_ACK_REVOCATION)
continue;
/* We give it an extra block, to avoid the worst of the
* inter-node timing issues. */
if (height <= abs_locktime_to_blocks(&htlc->expiry))
if (height <= abs_locktime_to_blocks(&h->expiry))
continue;
/* This can fail only if we're in an error state. */
if (!command_htlc_fail(peer, htlc))
if (!command_htlc_fail(peer, h))
return;
goto again;
}
/* BOLT #2:
@ -2019,10 +2022,7 @@ again:
if (!state_is_normal(peer->state))
return;
if (any_deadline_past(peer, peer->remote.staging_cstate)
|| any_deadline_past(peer, peer->local.staging_cstate)
|| any_deadline_past(peer, peer->remote.commit->cstate)
|| any_deadline_past(peer, peer->local.commit->cstate)) {
if (any_deadline_past(peer)) {
set_peer_state(peer, STATE_ERR_BREAKDOWN, __func__);
peer_breakdown(peer);
}
@ -2191,7 +2191,7 @@ static const struct bitcoin_tx *htlc_timeout_tx(const struct peer *peer,
peer->dstate->config.closing_fee_rate);
/* FIXME: Fail gracefully in these cases (not worth collecting) */
if (fee > satoshis || is_dust_amount(satoshis - fee))
if (fee > satoshis || is_dust(satoshis - fee))
fatal("HTLC refund amount of %"PRIu64" won't cover fee %"PRIu64,
satoshis, fee);
@ -2735,7 +2735,7 @@ static void resolve_their_steal(struct peer *peer,
fee = peer->dstate->config.closing_fee_rate
* (measure_tx_cost(steal_tx) + wsize) / 1000;
if (fee > input_total || is_dust_amount(input_total - fee)) {
if (fee > input_total || is_dust(input_total - fee)) {
log_unusual(peer->log, "Not worth stealing tiny amount %"PRIu64,
input_total);
/* Consider them all resolved by steal tx. */

11
remove_dust.h

@ -9,8 +9,15 @@ void remove_dust(struct bitcoin_tx *tx, int *map);
/* Less than this is dust. */
#define DUST_THRESHOLD 546
static inline bool is_dust(u64 amount)
/**
* is_dust: is an output of this value considered dust?
* @satoshis: number of satoshis.
*
* Transactions with dust outputs will not be relayed by the bitcoin
* network. It's not an exact definition, unfortunately.
*/
static inline bool is_dust(u64 satoshis)
{
return amount < DUST_THRESHOLD;
return satoshis < DUST_THRESHOLD;
}
#endif /* LIGHTNING_REMOVE_DUST_H */

Loading…
Cancel
Save