aljaz/lightning
1
0
Fork 0
mirror of https://github.com/aljazceru/lightning.git synced 2025-12-19 15:14:23 +01:00
Code Issues Packages Projects Releases Wiki Activity

lightningd: handle fees as blockcount + range.

Browse Source 
Rather than have specific-purpose levels, have an array of
[blockcount, feerate], and rebuild the specific-purpose levels
for now on top.

We also keep a *separate* smoothed feerate, so you can ask for that
explicitly.

Since all the plugins used the same formula to derive the different
named fee levels, we apply the reverse to return to the underlying
estimates: updating the interface comes next.

This is ugly for now, but various specific-purpose levels will be
going away, as we shift to deadline-driven fees.

This temporarily breaks the floor calculation, so that test is
disabled.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
This commit is contained in:
Rusty Russell
2023-04-07 14:09:53 +09:30
parent faae44713b
commit cdb85d5618
6 changed files with 328 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
contrib/pyln-testing/pyln/testing/utils.py
View File

@@ -1191,7 +1191,7 @@ class LightningNode(object):
self.daemon.rpcproxy.mock_rpc('estimatesmartfee', mock_estimatesmartfee)
# Technically, this waits until it's called, not until it's processed.
# We wait until all three levels have been called.
# We wait until all four levels have been called.
if wait_for_effect:
wait_for(lambda:
self.daemon.rpcproxy.mock_counts['estimatesmartfee'] >= 4)

134
lightningd/bitcoind.c
View File

@@ -156,20 +156,69 @@ static void bitcoin_plugin_send(struct bitcoind *bitcoind,
* "max_acceptable": <sat per kVB>,
* }
*/
struct estimatefee_call {
struct bitcoind *bitcoind;
void (*cb)(struct bitcoind *bitcoind, const u32 satoshi_per_kw[],
void *);
void *arg;
void (*cb)(struct lightningd *ld, u32 feerate_floor,
const struct feerate_est *rates);
};
/* Note: returns estimates in perkb, caller converts! */
static struct feerate_est *parse_deprecated_feerates(const tal_t *ctx,
struct bitcoind *bitcoind,
const char *buf,
const jsmntok_t *toks)
{
struct feerate_est *rates = tal_arr(ctx, struct feerate_est, 0);
struct oldstyle {
const char *name;
size_t blockcount;
size_t multiplier;
} oldstyles[] = { { "max_acceptable", 2, 10 },
{ "unilateral_close", 6, 1 },
{ "opening", 12, 1 },
{ "mutual_close", 100, 1 } };
for (size_t i = 0; i < ARRAY_SIZE(oldstyles); i++) {
const jsmntok_t *feeratetok;
struct feerate_est rate;
feeratetok = json_get_member(buf, toks, oldstyles[i].name);
if (!feeratetok) {
bitcoin_plugin_error(bitcoind, buf, toks,
"estimatefees",
"missing '%s' field",
oldstyles[i].name);
}
if (!json_to_u32(buf, feeratetok, &rate.rate)) {
if (chainparams->testnet)
log_debug(bitcoind->log,
"Unable to estimate %s fees",
oldstyles[i].name);
else
log_unusual(bitcoind->log,
"Unable to estimate %s fees",
oldstyles[i].name);
continue;
}
if (rate.rate == 0)
continue;
/* Cancel out the 10x multiplier on max_acceptable */
rate.rate /= oldstyles[i].multiplier;
rate.blockcount = oldstyles[i].blockcount;
tal_arr_expand(&rates, rate);
}
return rates;
}
static void estimatefees_callback(const char *buf, const jsmntok_t *toks,
const jsmntok_t *idtok,
struct estimatefee_call *call)
{
const jsmntok_t *resulttok, *feeratetok;
u32 *feerates = tal_arr(call, u32, NUM_FEERATES);
const jsmntok_t *resulttok;
struct feerate_est *feerates;
u32 floor;
resulttok = json_get_member(buf, toks, "result");
if (!resulttok)
@@ -177,73 +226,40 @@ static void estimatefees_callback(const char *buf, const jsmntok_t *toks,
"estimatefees",
"bad 'result' field");
for (int f = 0; f < NUM_FEERATES; f++) {
feeratetok = json_get_member(buf, resulttok, feerate_name(f));
if (!feeratetok)
bitcoin_plugin_error(call->bitcoind, buf, toks,
"estimatefees",
"missing '%s' field", feerate_name(f));
/* We still use the bcli plugin for min and max, even with
* force_feerates */
if (f < tal_count(call->bitcoind->ld->force_feerates)) {
feerates[f] = call->bitcoind->ld->force_feerates[f];
continue;
}
feerates = parse_deprecated_feerates(call, call->bitcoind,
buf, resulttok);
/* FIXME: get from plugin! */
floor = feerate_from_style(FEERATE_FLOOR, FEERATE_PER_KSIPA);
/* FIXME: We could trawl recent blocks for median fee... */
if (!json_to_u32(buf, feeratetok, &feerates[f])) {
if (chainparams->testnet)
log_debug(call->bitcoind->log,
"Unable to estimate %s fees",
feerate_name(f));
else
log_unusual(call->bitcoind->log,
"Unable to estimate %s fees",
feerate_name(f));
/* Convert to perkw */
floor = feerate_from_style(floor, FEERATE_PER_KBYTE);
if (floor < FEERATE_FLOOR)
floor = FEERATE_FLOOR;
#if DEVELOPER
/* This is needed to test for failed feerate estimates
* in DEVELOPER mode */
feerates[f] = 0;
#else
/* If we are in testnet mode we want to allow payments
* with the minimal fee even if the estimate didn't
* work out. This is less disruptive than erring out
* all the time. */
if (chainparams->testnet)
feerates[f] = FEERATE_FLOOR;
else
feerates[f] = 0;
#endif
} else {
if (f == FEERATE_UNILATERAL_CLOSE) {
feerates[f] = feerates[f] * call->bitcoind->ld->config.commit_fee_percent / 100;
} else if (f == FEERATE_MAX) {
/* Plugins always use 10 as multiplier. */
feerates[f] = feerates[f] * call->bitcoind->ld->config.max_fee_multiplier / 10;
}
/* Rate in satoshi per kw. */
feerates[f] = feerate_from_style(feerates[f],
/* FIXME: We could let this go below the dynamic floor, but we'd
* need to know if the floor is because of their node's policy
* (minrelaytxfee) or mempool conditions (mempoolminfee). */
for (size_t i = 0; i < tal_count(feerates); i++) {
feerates[i].rate = feerate_from_style(feerates[i].rate,
FEERATE_PER_KBYTE);
}
if (feerates[i].rate < floor)
feerates[i].rate = floor;
}
call->cb(call->bitcoind, feerates, call->arg);
call->cb(call->bitcoind->ld, floor, feerates);
tal_free(call);
}
void bitcoind_estimate_fees_(struct bitcoind *bitcoind,
size_t num_estimates,
void (*cb)(struct bitcoind *bitcoind,
const u32 satoshi_per_kw[], void *),
void *arg)
void bitcoind_estimate_fees(struct bitcoind *bitcoind,
void (*cb)(struct lightningd *ld,
u32 feerate_floor,
const struct feerate_est *feerates))
{
struct jsonrpc_request *req;
struct estimatefee_call *call = tal(bitcoind, struct estimatefee_call);
call->bitcoind = bitcoind;
call->cb = cb;
call->arg = arg;
req = jsonrpc_request_start(bitcoind, "estimatefees", NULL, true,
bitcoind->log,

18
lightningd/bitcoind.h
View File

@@ -9,6 +9,7 @@
struct bitcoin_blkid;
struct bitcoin_tx_output;
struct block;
struct feerate_est;
struct lightningd;
struct ripemd160;
struct bitcoin_tx;
@@ -57,19 +58,10 @@ struct bitcoind *new_bitcoind(const tal_t *ctx,
struct lightningd *ld,
struct log *log);
void bitcoind_estimate_fees_(struct bitcoind *bitcoind,
size_t num_estimates,
void (*cb)(struct bitcoind *bitcoind,
const u32 satoshi_per_kw[], void *),
void *arg);
#define bitcoind_estimate_fees(bitcoind_, num, cb, arg) \
bitcoind_estimate_fees_((bitcoind_), (num), \
typesafe_cb_preargs(void, void *, \
(cb), (arg), \
struct bitcoind *, \
const u32 *), \
(arg))
void bitcoind_estimate_fees(struct bitcoind *bitcoind,
void (*cb)(struct lightningd *ld,
u32 feerate_floor,
const struct feerate_est *feerates));
void bitcoind_sendrawtx_(struct bitcoind *bitcoind,
const char *id_prefix TAKES,

281
lightningd/chaintopology.c
View File

@@ -352,88 +352,180 @@ static void watch_for_utxo_reconfirmation(struct chain_topology *topo,
/* Mutual recursion via timer. */
static void next_updatefee_timer(struct chain_topology *topo);
static void init_feerate_history(struct chain_topology *topo,
enum feerate feerate, u32 val)
static u32 interp_feerate(const struct feerate_est *rates, u32 blockcount)
{
for (size_t i = 0; i < FEE_HISTORY_NUM; i++)
topo->feehistory[feerate][i] = val;
const struct feerate_est *before = NULL, *after = NULL;
/* Find before and after. */
for (size_t i = 0; i < tal_count(rates); i++) {
if (rates[i].blockcount <= blockcount) {
before = &rates[i];
} else if (rates[i].blockcount > blockcount && !after) {
after = &rates[i];
}
}
/* No estimates at all? */
if (!before && !after)
return 0;
/* We don't extrapolate. */
if (!before && after)
return after->rate;
if (before && !after)
return before->rate;
/* Interpolate, eg. blockcount 10, rate 15000, blockcount 20, rate 5000.
* At 15, rate should be 10000.
* 15000 + (15 - 10) / (20 - 10) * (15000 - 5000)
* 15000 + 5 / 10 * 10000
* => 10000
*/
/* Don't go backwards though! */
if (before->rate < after->rate)
return before->rate;
return before->rate
- ((u64)(blockcount - before->blockcount)
* (before->rate - after->rate)
/ (after->blockcount - before->blockcount));
}
static void add_feerate_history(struct chain_topology *topo,
enum feerate feerate, u32 val)
u32 feerate_for_deadline(const struct chain_topology *topo, u32 blockcount)
{
memmove(&topo->feehistory[feerate][1], &topo->feehistory[feerate][0],
(FEE_HISTORY_NUM - 1) * sizeof(u32));
topo->feehistory[feerate][0] = val;
u32 rate = interp_feerate(topo->feerates[0], blockcount);
/* 0 is a special value, meaning "don't know" */
if (rate && rate < topo->feerate_floor)
rate = topo->feerate_floor;
return rate;
}
/* We sanitize feerates if necessary to put them in descending order. */
static void update_feerates(struct bitcoind *bitcoind,
const u32 *satoshi_per_kw,
struct chain_topology *topo)
u32 smoothed_feerate_for_deadline(const struct chain_topology *topo,
u32 blockcount)
{
/* Note: we cap it at feerate_floor when we smooth */
return interp_feerate(topo->smoothed_feerates, blockcount);
}
/* Mixes in fresh feerate rate into old smoothed values, modifies rate */
static void smooth_one_feerate(const struct chain_topology *topo,
struct feerate_est *rate)
{
u32 old_feerates[NUM_FEERATES];
/* Smoothing factor alpha for simple exponential smoothing. The goal is to
* have the feerate account for 90 percent of the values polled in the last
* 2 minutes. The following will do that in a polling interval
* independent manner. */
double alpha = 1 - pow(0.1,(double)topo->poll_seconds / 120);
bool notify_feerate_changed = false;
u32 old_feerate, feerate_smooth;
for (size_t i = 0; i < NUM_FEERATES; i++) {
u32 feerate = satoshi_per_kw[i];
/* We don't call this unless we had a previous feerate */
old_feerate = smoothed_feerate_for_deadline(topo, rate->blockcount);
assert(old_feerate);
/* Takes into account override_fee_rate */
old_feerates[i] = try_get_feerate(topo, i);
feerate_smooth = rate->rate * alpha + old_feerate * (1 - alpha);
/* If estimatefee failed, don't do anything. */
if (!feerate)
continue;
/* Initial smoothed feerate is the polled feerate */
if (!old_feerates[i]) {
notify_feerate_changed = true;
old_feerates[i] = feerate;
init_feerate_history(topo, i, feerate);
log_debug(topo->log,
"Smoothed feerate estimate for %s initialized to polled estimate %u",
feerate_name(i), feerate);
} else {
add_feerate_history(topo, i, feerate);
}
/* Smooth the feerate to avoid spikes. */
u32 feerate_smooth = feerate * alpha + old_feerates[i] * (1 - alpha);
/* But to avoid updating forever, only apply smoothing when its
* effect is more then 10 percent */
if (abs((int)feerate - (int)feerate_smooth) > (0.1 * feerate)) {
feerate = feerate_smooth;
if (abs((int)rate->rate - (int)feerate_smooth) > (0.1 * rate->rate)) {
rate->rate = feerate_smooth;
log_debug(topo->log,
"... polled feerate estimate for %s (%u) smoothed to %u (alpha=%.2f)",
feerate_name(i), satoshi_per_kw[i],
feerate, alpha);
"... polled feerate estimate for %u blocks smoothed to %u (alpha=%.2f)",
rate->blockcount, rate->rate, alpha);
}
if (feerate < get_feerate_floor(topo)) {
feerate = get_feerate_floor(topo);
if (rate->rate < get_feerate_floor(topo)) {
rate->rate = get_feerate_floor(topo);
log_debug(topo->log,
"... feerate estimate for %s hit floor %u",
feerate_name(i), feerate);
"... feerate estimate for %u blocks hit floor %u",
rate->blockcount, rate->rate);
}
if (feerate != topo->feerate[i]) {
log_debug(topo->log, "Feerate estimate for %s set to %u (was %u)",
feerate_name(i),
feerate, topo->feerate[i]);
}
topo->feerate[i] = feerate;
/* After adjustment, If any entry doesn't match prior reported, report all */
if (feerate != old_feerates[i])
notify_feerate_changed = true;
if (rate->rate != feerate_smooth)
log_debug(topo->log,
"Feerate estimate for %u blocks set to %u (was %u)",
rate->blockcount, rate->rate, feerate_smooth);
}
static bool feerates_differ(const struct feerate_est *a,
const struct feerate_est *b)
{
if (tal_count(a) != tal_count(b))
return true;
for (size_t i = 0; i < tal_count(a); i++) {
if (a[i].blockcount != b[i].blockcount)
return true;
if (a[i].rate != b[i].rate)
return true;
}
return false;
}
/* In case the plugin does weird stuff! */
static bool different_blockcounts(struct chain_topology *topo,
const struct feerate_est *old,
const struct feerate_est *new)
{
if (tal_count(old) != tal_count(new)) {
log_unusual(topo->log, "Presented with %zu feerates this time (was %zu!)",
tal_count(new), tal_count(old));
return true;
}
for (size_t i = 0; i < tal_count(old); i++) {
if (old[i].blockcount != new[i].blockcount) {
log_unusual(topo->log, "Presented with feerates"
" for blockcount %u, previously %u",
new[i].blockcount, old[i].blockcount);
return true;
}
}
return false;
}
static void update_feerates(struct lightningd *ld,
u32 feerate_floor,
const struct feerate_est *rates TAKES)
{
struct feerate_est *new_smoothed;
bool changed;
struct chain_topology *topo = ld->topology;
topo->feerate_floor = feerate_floor;
/* Don't bother updating if we got no feerates; we'd rather have
* historical ones, if any. */
if (tal_count(rates) == 0)
goto rearm;
/* If the feerate blockcounts differ, don't average, just override */
if (topo->feerates[0] && different_blockcounts(topo, topo->feerates[0], rates)) {
for (size_t i = 0; i < ARRAY_SIZE(topo->feerates); i++)
topo->feerates[i] = tal_free(topo->feerates[i]);
topo->smoothed_feerates = tal_free(topo->smoothed_feerates);
}
/* Move down historical rates, insert these */
tal_free(topo->feerates[FEE_HISTORY_NUM-1]);
memmove(topo->feerates + 1, topo->feerates,
sizeof(topo->feerates[0]) * (FEE_HISTORY_NUM-1));
topo->feerates[0] = tal_dup_talarr(topo, struct feerate_est, rates);
changed = feerates_differ(topo->feerates[0], topo->feerates[1]);
/* Use this as basis of new smoothed ones. */
new_smoothed = tal_dup_talarr(topo, struct feerate_est, topo->feerates[0]);
/* If there were old smoothed feerates, incorporate those */
if (tal_count(topo->smoothed_feerates) != 0) {
for (size_t i = 0; i < tal_count(new_smoothed); i++)
smooth_one_feerate(topo, &new_smoothed[i]);
}
changed |= feerates_differ(topo->smoothed_feerates, new_smoothed);
tal_free(topo->smoothed_feerates);
topo->smoothed_feerates = new_smoothed;
if (changed)
notify_feerate_change(topo->ld);
rearm:
if (topo->feerate_uninitialized) {
/* This doesn't mean we *have* a fee estimate, but it does
* mean we tried. */
@@ -441,9 +533,6 @@ static void update_feerates(struct bitcoind *bitcoind,
maybe_completed_init(topo);
}
if (notify_feerate_changed)
notify_feerate_change(bitcoind->ld);
next_updatefee_timer(topo);
}
@@ -453,8 +542,7 @@ static void start_fee_estimate(struct chain_topology *topo)
if (topo->stopping)
return;
/* Once per new block head, update fee estimates. */
bitcoind_estimate_fees(topo->bitcoind, NUM_FEERATES, update_feerates,
topo);
bitcoind_estimate_fees(topo->bitcoind, update_feerates);
}
u32 opening_feerate(struct chain_topology *topo)
@@ -910,10 +998,58 @@ u32 get_network_blockheight(const struct chain_topology *topo)
return topo->headercount;
}
struct rate_conversion {
u32 blockcount;
};
static struct rate_conversion conversions[] = {
[FEERATE_OPENING] = { 12 },
[FEERATE_MUTUAL_CLOSE] = { 100 },
[FEERATE_UNILATERAL_CLOSE] = { 6 },
[FEERATE_DELAYED_TO_US] = { 12 },
[FEERATE_HTLC_RESOLUTION] = { 6 },
[FEERATE_PENALTY] = { 12 },
};
u32 try_get_feerate(const struct chain_topology *topo, enum feerate feerate)
{
return topo->feerate[feerate];
u32 val;
/* Max and min look over history as well. */
if (feerate == FEERATE_MAX) {
u32 max = 0;
for (size_t i = 0; i < ARRAY_SIZE(topo->feerates); i++) {
for (size_t j = 0; j < tal_count(topo->feerates[i]); j++) {
if (topo->feerates[i][j].rate > max)
max = topo->feerates[i][j].rate;
}
}
return max * topo->ld->config.max_fee_multiplier;
}
if (feerate == FEERATE_MIN) {
u32 min = 0xFFFFFFFF;
for (size_t i = 0; i < ARRAY_SIZE(topo->feerates); i++) {
for (size_t j = 0; j < tal_count(topo->feerates[i]); j++) {
if (topo->feerates[i][j].rate < min)
min = topo->feerates[i][j].rate;
}
}
if (min == 0xFFFFFFFF)
return 0;
/* FIXME: This is what bcli used to do: halve the slow feerate! */
min /= 2;
return min;
}
if (topo->ld->force_feerates)
val = topo->ld->force_feerates[feerate];
else
val = smoothed_feerate_for_deadline(topo, conversions[feerate].blockcount);
if (feerate == FEERATE_UNILATERAL_CLOSE)
val = val * topo->ld->config.commit_fee_percent / 100;
return val;
}
u32 feerate_min(struct lightningd *ld, bool *unknown)
@@ -931,14 +1067,6 @@ u32 feerate_min(struct lightningd *ld, bool *unknown)
if (!min) {
if (unknown)
*unknown = true;
} else {
const u32 *hist = ld->topology->feehistory[FEERATE_MIN];
/* If one of last three was an outlier, use that. */
for (size_t i = 0; i < FEE_HISTORY_NUM; i++) {
if (hist[i] < min)
min = hist[i];
}
}
}
@@ -950,7 +1078,6 @@ u32 feerate_min(struct lightningd *ld, bool *unknown)
u32 feerate_max(struct lightningd *ld, bool *unknown)
{
u32 feerate;
const u32 *feehistory = ld->topology->feehistory[FEERATE_MAX];
if (unknown)
*unknown = false;
@@ -965,12 +1092,6 @@ u32 feerate_max(struct lightningd *ld, bool *unknown)
*unknown = true;
return UINT_MAX;
}
/* If one of last three was an outlier, use that. */
for (size_t i = 0; i < FEE_HISTORY_NUM; i++) {
if (feehistory[i] > feerate)
feerate = feehistory[i];
}
return feerate;
}
@@ -1001,10 +1122,11 @@ struct chain_topology *new_topology(struct lightningd *ld, struct log *log)
topo->txowatches = tal(topo, struct txowatch_hash);
txowatch_hash_init(topo->txowatches);
topo->log = log;
memset(topo->feerate, 0, sizeof(topo->feerate));
topo->bitcoind = new_bitcoind(topo, ld, log);
topo->poll_seconds = 30;
topo->feerate_uninitialized = true;
memset(topo->feerates, 0, sizeof(topo->feerates));
topo->smoothed_feerates = NULL;
topo->root = NULL;
topo->sync_waiters = tal(topo, struct list_head);
topo->extend_timer = NULL;
@@ -1110,7 +1232,6 @@ void setup_topology(struct chain_topology *topo,
u32 min_blockheight, u32 max_blockheight)
{
void *ret;
memset(&topo->feerate, 0, sizeof(topo->feerate));
topo->min_blockheight = min_blockheight;
topo->max_blockheight = max_blockheight;

24
lightningd/chaintopology.h
View File

@@ -88,15 +88,31 @@ static inline bool outgoing_tx_eq(const struct outgoing_tx *b, const struct bitc
HTABLE_DEFINE_TYPE(struct outgoing_tx, keyof_outgoing_tx_map,
outgoing_tx_hash_sha, outgoing_tx_eq, outgoing_tx_map);
/* Our plugins give us a series of blockcount, feerate pairs. */
struct feerate_est {
u32 blockcount;
u32 rate;
};
struct chain_topology {
struct lightningd *ld;
struct block *root;
struct block *tip;
struct bitcoin_blkid prev_tip;
struct block_map *block_map;
u32 feerate[NUM_FEERATES];
/* Set during startup */
bool feerate_uninitialized;
u32 feehistory[NUM_FEERATES][FEE_HISTORY_NUM];
/* This is the lowest feerate that bitcoind is saying will broadcast. */
u32 feerate_floor;
/* We keep last three feerates we got: this is useful for min/max. */
struct feerate_est *feerates[FEE_HISTORY_NUM];
/* We keep a smoothed feerate: this is useful when we're going to
* suggest feerates / check feerates from our peers. */
struct feerate_est *smoothed_feerates;
/* Where to log things. */
struct log *log;
@@ -161,6 +177,10 @@ u32 get_block_height(const struct chain_topology *topo);
* likely to lag behind the rest of the network.*/
u32 get_network_blockheight(const struct chain_topology *topo);
/* Get feerate estimate for getting a tx in this many blocks */
u32 feerate_for_deadline(const struct chain_topology *topo, u32 blockcount);
u32 smoothed_feerate_for_deadline(const struct chain_topology *topo, u32 blockcount);
/* Get fee rate in satoshi per kiloweight, or 0 if unavailable! */
u32 try_get_feerate(const struct chain_topology *topo, enum feerate feerate);

25
tests/test_misc.py
View File

@@ -1556,35 +1556,39 @@ def test_feerates(node_factory):
l1.set_feerates((15000, 0, 0, 0), True)
wait_for(lambda: l1.rpc.feerates('perkw')['perkw']['max_acceptable'] == 15000 * 10)
feerates = l1.rpc.feerates('perkw')
assert feerates['warning_missing_feerates'] == 'Some fee estimates unavailable: bitcoind startup?'
# We only get the warning if *no* feerates are avail.
assert 'warning_missing_feerates' not in feerates
assert 'perkb' not in feerates
assert feerates['perkw']['min_acceptable'] == 253
# With only one data point, this is a terrible guess!
assert feerates['perkw']['min_acceptable'] == 15000 // 2
# assert feerates['perkw']['min_acceptable'] == 253
# Set ECONOMICAL/6 feerate, for unilateral_close and htlc_resolution
l1.set_feerates((15000, 11000, 0, 0), True)
wait_for(lambda: len(l1.rpc.feerates('perkw')['perkw']) == 4)
feerates = l1.rpc.feerates('perkw')
assert feerates['perkw']['unilateral_close'] == 11000
assert feerates['perkw']['htlc_resolution'] == 11000
assert feerates['warning_missing_feerates'] == 'Some fee estimates unavailable: bitcoind startup?'
assert 'warning_missing_feerates' not in feerates
assert 'perkb' not in feerates
assert feerates['perkw']['max_acceptable'] == 15000 * 10
assert feerates['perkw']['min_acceptable'] == 253
# With only two data points, this is a terrible guess!
assert feerates['perkw']['min_acceptable'] == 11000 // 2
# Set ECONOMICAL/12 feerate, for all but min (so, no mutual_close feerate)
l1.set_feerates((15000, 11000, 6250, 0), True)
wait_for(lambda: len(l1.rpc.feerates('perkb')['perkb']) == len(types) - 1 + 2)
feerates = l1.rpc.feerates('perkb')
assert feerates['perkb']['unilateral_close'] == 11000 * 4
assert feerates['perkb']['htlc_resolution'] == 11000 * 4
assert 'mutual_close' not in feerates['perkb']
# We dont' extrapolate, so it uses the same for mutual_close
assert feerates['perkb']['mutual_close'] == 6250 * 4
for t in types:
if t not in ("unilateral_close", "htlc_resolution", "mutual_close"):
assert feerates['perkb'][t] == 25000
assert feerates['warning_missing_feerates'] == 'Some fee estimates unavailable: bitcoind startup?'
assert 'warning_missing_feerates' not in feerates
assert 'perkw' not in feerates
assert feerates['perkb']['max_acceptable'] == 15000 * 4 * 10
assert feerates['perkb']['min_acceptable'] == 253 * 4
# With only three data points, this is a terrible guess!
assert feerates['perkb']['min_acceptable'] == 6250 // 2 * 4
# Set ECONOMICAL/100 feerate for min and mutual_close
l1.set_feerates((15000, 11000, 6250, 5000), True)
@@ -1596,7 +1600,7 @@ def test_feerates(node_factory):
for t in types:
if t not in ("unilateral_close", "htlc_resolution", "mutual_close"):
assert feerates['perkw'][t] == 25000 // 4
assert 'warning' not in feerates
assert 'warning_missing_feerates' not in feerates
assert 'perkb' not in feerates
assert feerates['perkw']['max_acceptable'] == 15000 * 10
assert feerates['perkw']['min_acceptable'] == 5000 // 2
@@ -1910,6 +1914,7 @@ def test_bitcoind_fail_first(node_factory, bitcoind):
@unittest.skipIf(TEST_NETWORK == 'liquid-regtest', "Fees on elements are different")
@unittest.skip("FIXME: temporarily broken")
def test_bitcoind_feerate_floor(node_factory, bitcoind):
"""Don't return a feerate less than minrelaytxfee/mempoolnifee."""
l1 = node_factory.get_node()