lukechilds
/
lightning
mirror of https://github.com/lukechilds/lightning.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6163 Commits
55 Branches
107 Tags
38 MiB
Tree: b17b4c3eb6
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b17b4c3eb6'
${ noResults }
lightning/lightningd/test/run-invoice-select-inchan.c

767 lines
39 KiB
Raw Normal View History

json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it's in state NORMAL (not shutting down, not still waiting for lockin), that it's connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
6 years ago
#include "../channel.c"
#include "../invoice.c"
#include "../peer_control.c"
#include <ccan/alignof/alignof.h>
bool deprecated_apis = false;
/* AUTOGENERATED MOCKS START */
wire: use common/bigsize routines Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
5 years ago
/* Generated stub for bigsize_get */
size_t bigsize_get(const u8 *p UNNEEDED, size_t max UNNEEDED, bigsize_t *val UNNEEDED)
{ fprintf(stderr, "bigsize_get called!\n"); abort(); }
/* Generated stub for bigsize_put */
size_t bigsize_put(u8 buf[BIGSIZE_MAX_LEN] UNNEEDED, bigsize_t v UNNEEDED)
{ fprintf(stderr, "bigsize_put called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for bitcoind_gettxout */
void bitcoind_gettxout(struct bitcoind *bitcoind UNNEEDED,
const struct bitcoin_txid *txid UNNEEDED, const u32 outnum UNNEEDED,
void (*cb)(struct bitcoind *bitcoind UNNEEDED,
const struct bitcoin_tx_output *txout UNNEEDED,
void *arg) UNNEEDED,
void *arg UNNEEDED)
{ fprintf(stderr, "bitcoind_gettxout called!\n"); abort(); }
/* Generated stub for bolt11_decode */
struct bolt11 *bolt11_decode(const tal_t *ctx UNNEEDED, const char *str UNNEEDED,
const char *description UNNEEDED, char **fail UNNEEDED)
{ fprintf(stderr, "bolt11_decode called!\n"); abort(); }
/* Generated stub for bolt11_encode_ */
char *bolt11_encode_(const tal_t *ctx UNNEEDED,
const struct bolt11 *b11 UNNEEDED, bool n_field UNNEEDED,
bool (*sign)(const u5 *u5bytes UNNEEDED,
const u8 *hrpu8 UNNEEDED,
secp256k1_ecdsa_recoverable_signature *rsig UNNEEDED,
void *arg) UNNEEDED,
void *arg UNNEEDED)
{ fprintf(stderr, "bolt11_encode_ called!\n"); abort(); }
/* Generated stub for broadcast_tx */
void broadcast_tx(struct chain_topology *topo UNNEEDED,
struct channel *channel UNNEEDED, const struct bitcoin_tx *tx UNNEEDED,
void (*failed)(struct channel *channel UNNEEDED,
int exitstatus UNNEEDED,
const char *err))
{ fprintf(stderr, "broadcast_tx called!\n"); abort(); }
fix:Add infor about how many blocks needed until funding is confirmed 1. Rename channel_funding_locked to channel_funding_depth in channeld/channel_wire.csv. 2. Add minimum_depth in struct channel in common/initial_channel.h and change corresponding init function: new_initial_channel(). 3. Add confirmation_needed in struct peer in channeld/channeld.c. 4. Rename channel_tell_funding_locked to channel_tell_depth. 5. Call channel_tell_depth even if depth &lt; minimum, and still call lockin_complete in channel_tell_depth, iff depth &gt; minimum_depth. 6. channeld ignore the channel_funding_depth unless its &gt; minimum_depth(except to update billboard, and set peer-&gt;confirmation_needed = minimum_depth - depth).
6 years ago
/* Generated stub for channel_tell_depth */
bool channel_tell_depth(struct lightningd *ld UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct channel *channel UNNEEDED,
const struct bitcoin_txid *txid UNNEEDED,
u32 depth UNNEEDED)
fix:Add infor about how many blocks needed until funding is confirmed 1. Rename channel_funding_locked to channel_funding_depth in channeld/channel_wire.csv. 2. Add minimum_depth in struct channel in common/initial_channel.h and change corresponding init function: new_initial_channel(). 3. Add confirmation_needed in struct peer in channeld/channeld.c. 4. Rename channel_tell_funding_locked to channel_tell_depth. 5. Call channel_tell_depth even if depth &lt; minimum, and still call lockin_complete in channel_tell_depth, iff depth &gt; minimum_depth. 6. channeld ignore the channel_funding_depth unless its &gt; minimum_depth(except to update billboard, and set peer-&gt;confirmation_needed = minimum_depth - depth).
6 years ago
{ fprintf(stderr, "channel_tell_depth called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for command_fail */
param: make command sinks (fail/success) return a special type. These routines free the &#39;struct command&#39;: a common coding error is not to return immediately. To catch this, we make them return a non-NULL &#39;struct command_result *&#39;, and we&#39;re going to make the command handlers return the same (to encourage &#39;return command_fail(...)&#39;-style usage). We also provide two sources for external use: 1. command_param_failed() when param() fails. 2. command_its_complicated() for some complex cases. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct command_result *command_fail(struct command *cmd UNNEEDED, int code UNNEEDED,
const char *fmt UNNEEDED, ...)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "command_fail called!\n"); abort(); }
jsonrpc: declare up front whether a response is success or fail. Such an API is required for when we stream it directly. Almost all our handlers fit this pattern already, or nearly do. We remove new_json_result() in favor of explicit json_stream_success() and json_stream_fail(), but still allowing command_fail() if you just want a simple all-in-one fail wrapper. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for command_failed */
param: make command sinks (fail/success) return a special type. These routines free the &#39;struct command&#39;: a common coding error is not to return immediately. To catch this, we make them return a non-NULL &#39;struct command_result *&#39;, and we&#39;re going to make the command handlers return the same (to encourage &#39;return command_fail(...)&#39;-style usage). We also provide two sources for external use: 1. command_param_failed() when param() fails. 2. command_its_complicated() for some complex cases. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct command_result *command_failed(struct command *cmd UNNEEDED,
jsonrpc: don&#39;t be coy with details for command_its_complicated(). Obviously the Facebook relationship status joke was a bit subtle, but I&#39;ve continued it anyway because I&#39;m especially susceptible to Dad jokes. Suggested-by: @niftynei Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct json_stream *result)
jsonrpc: declare up front whether a response is success or fail. Such an API is required for when we stream it directly. Almost all our handlers fit this pattern already, or nearly do. We remove new_json_result() in favor of explicit json_stream_success() and json_stream_fail(), but still allowing command_fail() if you just want a simple all-in-one fail wrapper. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "command_failed called!\n"); abort(); }
json-rpc: make commands return &#39;struct command_result *&#39;. Usually, this means they return &#39;command_param_failed()&#39; if param() fails, and changing &#39;command_success(); return;&#39; to &#39;return command_success()&#39;. Occasionally, it&#39;s more complex: there&#39;s a command_its_complicated() for the case where we can&#39;t exactly determine what the status is, but it should be considered a last resort. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for command_its_complicated */
jsonrpc: don&#39;t be coy with details for command_its_complicated(). Obviously the Facebook relationship status joke was a bit subtle, but I&#39;ve continued it anyway because I&#39;m especially susceptible to Dad jokes. Suggested-by: @niftynei Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct command_result *command_its_complicated(const char *why UNNEEDED)
json-rpc: make commands return &#39;struct command_result *&#39;. Usually, this means they return &#39;command_param_failed()&#39; if param() fails, and changing &#39;command_success(); return;&#39; to &#39;return command_success()&#39;. Occasionally, it&#39;s more complex: there&#39;s a command_its_complicated() for the case where we can&#39;t exactly determine what the status is, but it should be considered a last resort. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "command_its_complicated called!\n"); abort(); }
/* Generated stub for command_param_failed */
struct command_result *command_param_failed(void)
jsonrpc: don&#39;t be coy with details for command_its_complicated(). Obviously the Facebook relationship status joke was a bit subtle, but I&#39;ve continued it anyway because I&#39;m especially susceptible to Dad jokes. Suggested-by: @niftynei Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
json-rpc: make commands return &#39;struct command_result *&#39;. Usually, this means they return &#39;command_param_failed()&#39; if param() fails, and changing &#39;command_success(); return;&#39; to &#39;return command_success()&#39;. Occasionally, it&#39;s more complex: there&#39;s a command_its_complicated() for the case where we can&#39;t exactly determine what the status is, but it should be considered a last resort. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "command_param_failed called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for command_still_pending */
jsonrpc: don&#39;t be coy with details for command_its_complicated(). Obviously the Facebook relationship status joke was a bit subtle, but I&#39;ve continued it anyway because I&#39;m especially susceptible to Dad jokes. Suggested-by: @niftynei Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct command_result *command_still_pending(struct command *cmd)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "command_still_pending called!\n"); abort(); }
/* Generated stub for command_success */
param: make command sinks (fail/success) return a special type. These routines free the &#39;struct command&#39;: a common coding error is not to return immediately. To catch this, we make them return a non-NULL &#39;struct command_result *&#39;, and we&#39;re going to make the command handlers return the same (to encourage &#39;return command_fail(...)&#39;-style usage). We also provide two sources for external use: 1. command_param_failed() when param() fails. 2. command_its_complicated() for some complex cases. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct command_result *command_success(struct command *cmd UNNEEDED,
jsonrpc: don&#39;t be coy with details for command_its_complicated(). Obviously the Facebook relationship status joke was a bit subtle, but I&#39;ve continued it anyway because I&#39;m especially susceptible to Dad jokes. Suggested-by: @niftynei Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct json_stream *response)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "command_success called!\n"); abort(); }
/* Generated stub for connect_succeeded */
Use node_id everywhere for nodes. I tried to just do gossipd, but it was uncontainable, so this ended up being a complete sweep. We didn&#39;t get much space saving in gossipd, even though we should save 24 bytes per node. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void connect_succeeded(struct lightningd *ld UNNEEDED, const struct node_id *id UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "connect_succeeded called!\n"); abort(); }
/* Generated stub for delay_then_reconnect */
void delay_then_reconnect(struct channel *channel UNNEEDED, u32 seconds_delay UNNEEDED,
const struct wireaddr_internal *addrhint TAKES UNNEEDED)
{ fprintf(stderr, "delay_then_reconnect called!\n"); abort(); }
lightningd: move local invoice resolution into invoice.c function. We&#39;re going to make it async, so start by moving the core code into invoice.c and having that directly call fail/success functions for the htlc. We add an extra check in fulfill_htlc() that the HTLC state is correct: that can&#39;t happen now, but may once we&#39;re async. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for fail_htlc */
void fail_htlc(struct htlc_in *hin UNNEEDED, enum onion_type failcode UNNEEDED)
{ fprintf(stderr, "fail_htlc called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for fatal */
void fatal(const char *fmt UNNEEDED, ...)
{ fprintf(stderr, "fatal called!\n"); abort(); }
channeld: wire up dev_memleak. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for fromwire_channel_dev_memleak_reply */
bool fromwire_channel_dev_memleak_reply(const void *p UNNEEDED, bool *leak UNNEEDED)
{ fprintf(stderr, "fromwire_channel_dev_memleak_reply called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for fromwire_connect_peer_connected */
gossipd: don&#39;t send gossip stream, let per-peer daemons read it themselves. Keeping the uintmap ordering all the broadcastable messages is expensive: 130MB for the million-channels project. But now we delete obsolete entries from the store, we can have the per-peer daemons simply read that sequentially and stream the gossip itself. This is the most primitive version, where all gossip is streamed; successive patches will bring back proper handling of timestamp filtering and initial_routing_sync. We add a gossip_state field to track what&#39;s happening with our gossip streaming: it&#39;s initialized in gossipd, and currently always set, but once we handle timestamps the per-peer daemon may do it when the first filter is sent. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
bool fromwire_connect_peer_connected(const tal_t *ctx UNNEEDED, const void *p UNNEEDED, struct node_id *id UNNEEDED, struct wireaddr_internal *addr UNNEEDED, struct per_peer_state **pps UNNEEDED, u8 **globalfeatures UNNEEDED, u8 **localfeatures UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "fromwire_connect_peer_connected called!\n"); abort(); }
/* Generated stub for fromwire_gossip_get_incoming_channels_reply */
bool fromwire_gossip_get_incoming_channels_reply(const tal_t *ctx UNNEEDED, const void *p UNNEEDED, struct route_info **route_info UNNEEDED)
{ fprintf(stderr, "fromwire_gossip_get_incoming_channels_reply called!\n"); abort(); }
/* Generated stub for fromwire_hsm_get_channel_basepoints_reply */
bool fromwire_hsm_get_channel_basepoints_reply(const void *p UNNEEDED, struct basepoints *basepoints UNNEEDED, struct pubkey *funding_pubkey UNNEEDED)
{ fprintf(stderr, "fromwire_hsm_get_channel_basepoints_reply called!\n"); abort(); }
/* Generated stub for fromwire_hsm_sign_commitment_tx_reply */
signature: wrap almost all signatures in struct bitcoin_signature. This is prep work for when we sign htlc txs with SIGHASH_SINGLE|SIGHASH_ANYONECANPAY. We still deal with raw signatures for the htlc txs at the moment, since we send them like that across the wire, and changing that was simply too painful (for the moment?). Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
bool fromwire_hsm_sign_commitment_tx_reply(const void *p UNNEEDED, struct bitcoin_signature *sig UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "fromwire_hsm_sign_commitment_tx_reply called!\n"); abort(); }
/* Generated stub for fromwire_hsm_sign_invoice_reply */
bool fromwire_hsm_sign_invoice_reply(const void *p UNNEEDED, secp256k1_ecdsa_recoverable_signature *sig UNNEEDED)
{ fprintf(stderr, "fromwire_hsm_sign_invoice_reply called!\n"); abort(); }
onchaind: wire up dev_memleak. For onchaind we need to remove globals from memleak consideration; we also change the htlc pointer to an htlc copy, which simplifies things as well. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for fromwire_onchain_dev_memleak_reply */
bool fromwire_onchain_dev_memleak_reply(const void *p UNNEEDED, bool *leak UNNEEDED)
{ fprintf(stderr, "fromwire_onchain_dev_memleak_reply called!\n"); abort(); }
lightningd: move local invoice resolution into invoice.c function. We&#39;re going to make it async, so start by moving the core code into invoice.c and having that directly call fail/success functions for the htlc. We add an extra check in fulfill_htlc() that the HTLC state is correct: that can&#39;t happen now, but may once we&#39;re async. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for fulfill_htlc */
void fulfill_htlc(struct htlc_in *hin UNNEEDED, const struct preimage *preimage UNNEEDED)
{ fprintf(stderr, "fulfill_htlc called!\n"); abort(); }
[test] update test mocks for getinfo rpc update
6 years ago
/* Generated stub for get_block_height */
u32 get_block_height(const struct chain_topology *topo UNNEEDED)
{ fprintf(stderr, "get_block_height called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for get_chainparams */
const struct chainparams *get_chainparams(const struct lightningd *ld UNNEEDED)
{ fprintf(stderr, "get_chainparams called!\n"); abort(); }
/* Generated stub for get_log_level */
enum log_level get_log_level(struct log_book *lr UNNEEDED)
{ fprintf(stderr, "get_log_level called!\n"); abort(); }
lightningd: make &#39;spendable_msatoshi&#39; more realistic. Take into account the fee we&#39;d have to pay if we&#39;re the funder, and also drop to 0 if the amount is less than the smallest HTLC the peer will accept. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for htlc_is_trimmed */
bool htlc_is_trimmed(enum side htlc_owner UNNEEDED,
struct amount_msat htlc_amount UNNEEDED,
u32 feerate_per_kw UNNEEDED,
struct amount_sat dust_limit UNNEEDED,
enum side side UNNEEDED)
{ fprintf(stderr, "htlc_is_trimmed called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for htlcs_reconnect */
void htlcs_reconnect(struct lightningd *ld UNNEEDED,
struct htlc_in_map *htlcs_in UNNEEDED,
struct htlc_out_map *htlcs_out UNNEEDED)
{ fprintf(stderr, "htlcs_reconnect called!\n"); abort(); }
[test] update test mocks for getinfo rpc update
6 years ago
/* Generated stub for json_add_address */
void json_add_address(struct json_stream *response UNNEEDED, const char *fieldname UNNEEDED,
const struct wireaddr *addr UNNEEDED)
{ fprintf(stderr, "json_add_address called!\n"); abort(); }
/* Generated stub for json_add_address_internal */
void json_add_address_internal(struct json_stream *response UNNEEDED,
const char *fieldname UNNEEDED,
const struct wireaddr_internal *addr UNNEEDED)
{ fprintf(stderr, "json_add_address_internal called!\n"); abort(); }
json: rename json_add_amount_sat to json_add_amount_sat_compat. New fields don&#39;t have to be spelled out twice. The raw version are called _only, so we don&#39;t miss a call accidentally. We can rename them when we finally deprecated old fields. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for json_add_amount_msat_compat */
void json_add_amount_msat_compat(struct json_stream *result UNNEEDED,
struct amount_msat msat UNNEEDED,
const char *rawfieldname UNNEEDED,
const char *msatfieldname)
common/bolt11: use struct amount_msat Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
json: rename json_add_amount_sat to json_add_amount_sat_compat. New fields don&#39;t have to be spelled out twice. The raw version are called _only, so we don&#39;t miss a call accidentally. We can rename them when we finally deprecated old fields. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "json_add_amount_msat_compat called!\n"); abort(); }
/* Generated stub for json_add_amount_sat_compat */
void json_add_amount_sat_compat(struct json_stream *result UNNEEDED,
struct amount_sat sat UNNEEDED,
const char *rawfieldname UNNEEDED,
const char *msatfieldname)
listpeers: add all the alternate &#34;msat&#34; and &#34;sat&#34; fields for channels. These are undocumented, unfortunately, but at least that means I don&#39;t have to update the docs! Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
json: rename json_add_amount_sat to json_add_amount_sat_compat. New fields don&#39;t have to be spelled out twice. The raw version are called _only, so we don&#39;t miss a call accidentally. We can rename them when we finally deprecated old fields. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "json_add_amount_sat_compat called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for json_add_bool */
Rename `struct json_result` to `struct json_stream` (RENAMEONLY) Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void json_add_bool(struct json_stream *result UNNEEDED, const char *fieldname UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
bool value UNNEEDED)
{ fprintf(stderr, "json_add_bool called!\n"); abort(); }
/* Generated stub for json_add_escaped_string */
Rename `struct json_result` to `struct json_stream` (RENAMEONLY) Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void json_add_escaped_string(struct json_stream *result UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const char *fieldname UNNEEDED,
ccan: import ccan/json_out and ccan/json_escape. These are generalized from our internal implementations. The main difference is that &#39;struct json_escaped&#39; is now &#39;struct json_escape&#39;, so we replace that immediately. The difference between lightningd&#39;s json-writing ringbuffer and the more generic ccan/json_out is that the latter has a better API and handles escaping transparently if something slips through (though it does offer direct accessors so you can mess things up yourself!). Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const struct json_escape *esc TAKES UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "json_add_escaped_string called!\n"); abort(); }
/* Generated stub for json_add_hex */
Rename `struct json_result` to `struct json_stream` (RENAMEONLY) Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void json_add_hex(struct json_stream *result UNNEEDED, const char *fieldname UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const void *data UNNEEDED, size_t len UNNEEDED)
{ fprintf(stderr, "json_add_hex called!\n"); abort(); }
/* Generated stub for json_add_hex_talarr */
Rename `struct json_result` to `struct json_stream` (RENAMEONLY) Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void json_add_hex_talarr(struct json_stream *result UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const char *fieldname UNNEEDED,
const tal_t *data UNNEEDED)
{ fprintf(stderr, "json_add_hex_talarr called!\n"); abort(); }
/* Generated stub for json_add_log */
Rename `struct json_result` to `struct json_stream` (RENAMEONLY) Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void json_add_log(struct json_stream *result UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const struct log_book *lr UNNEEDED, enum log_level minlevel UNNEEDED)
{ fprintf(stderr, "json_add_log called!\n"); abort(); }
Use node_id everywhere for nodes. I tried to just do gossipd, but it was uncontainable, so this ended up being a complete sweep. We didn&#39;t get much space saving in gossipd, even though we should save 24 bytes per node. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for json_add_node_id */
void json_add_node_id(struct json_stream *response UNNEEDED,
const char *fieldname UNNEEDED,
const struct node_id *id UNNEEDED)
{ fprintf(stderr, "json_add_node_id called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for json_add_num */
Rename `struct json_result` to `struct json_stream` (RENAMEONLY) Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void json_add_num(struct json_stream *result UNNEEDED, const char *fieldname UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
unsigned int value UNNEEDED)
{ fprintf(stderr, "json_add_num called!\n"); abort(); }
/* Generated stub for json_add_short_channel_id */
Rename `struct json_result` to `struct json_stream` (RENAMEONLY) Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void json_add_short_channel_id(struct json_stream *response UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const char *fieldname UNNEEDED,
const struct short_channel_id *id UNNEEDED)
{ fprintf(stderr, "json_add_short_channel_id called!\n"); abort(); }
/* Generated stub for json_add_string */
Rename `struct json_result` to `struct json_stream` (RENAMEONLY) Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void json_add_string(struct json_stream *result UNNEEDED, const char *fieldname UNNEEDED, const char *value UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "json_add_string called!\n"); abort(); }
lightningd: add json_add_tx helper. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for json_add_tx */
void json_add_tx(struct json_stream *result UNNEEDED,
const char *fieldname UNNEEDED,
const struct bitcoin_tx *tx UNNEEDED)
{ fprintf(stderr, "json_add_tx called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for json_add_txid */
Rename `struct json_result` to `struct json_stream` (RENAMEONLY) Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void json_add_txid(struct json_stream *result UNNEEDED, const char *fieldname UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const struct bitcoin_txid *txid UNNEEDED)
{ fprintf(stderr, "json_add_txid called!\n"); abort(); }
/* Generated stub for json_add_u64 */
Rename `struct json_result` to `struct json_stream` (RENAMEONLY) Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void json_add_u64(struct json_stream *result UNNEEDED, const char *fieldname UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
uint64_t value UNNEEDED)
{ fprintf(stderr, "json_add_u64 called!\n"); abort(); }
/* Generated stub for json_add_uncommitted_channel */
Rename `struct json_result` to `struct json_stream` (RENAMEONLY) Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void json_add_uncommitted_channel(struct json_stream *response UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const struct uncommitted_channel *uc UNNEEDED)
{ fprintf(stderr, "json_add_uncommitted_channel called!\n"); abort(); }
/* Generated stub for json_array_end */
json_stream: disentangle JSON handling from command. We promote &#39;struct json_stream&#39; to contain the membuf; we only attach the json_stream to the command when we actually call json_stream_success / json_stream_fail. This means we are closer to &#39;struct json_stream&#39; being an independent layer; the tests are already modified to use it directly to create JSON. This is also the first step toward re-enabling non-serial command execution. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void json_array_end(struct json_stream *js UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "json_array_end called!\n"); abort(); }
/* Generated stub for json_array_start */
json_stream: disentangle JSON handling from command. We promote &#39;struct json_stream&#39; to contain the membuf; we only attach the json_stream to the command when we actually call json_stream_success / json_stream_fail. This means we are closer to &#39;struct json_stream&#39; being an independent layer; the tests are already modified to use it directly to create JSON. This is also the first step toward re-enabling non-serial command execution. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void json_array_start(struct json_stream *js UNNEEDED, const char *fieldname UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "json_array_start called!\n"); abort(); }
/* Generated stub for json_object_end */
json_stream: disentangle JSON handling from command. We promote &#39;struct json_stream&#39; to contain the membuf; we only attach the json_stream to the command when we actually call json_stream_success / json_stream_fail. This means we are closer to &#39;struct json_stream&#39; being an independent layer; the tests are already modified to use it directly to create JSON. This is also the first step toward re-enabling non-serial command execution. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void json_object_end(struct json_stream *js UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "json_object_end called!\n"); abort(); }
/* Generated stub for json_object_start */
json_stream: disentangle JSON handling from command. We promote &#39;struct json_stream&#39; to contain the membuf; we only attach the json_stream to the command when we actually call json_stream_success / json_stream_fail. This means we are closer to &#39;struct json_stream&#39; being an independent layer; the tests are already modified to use it directly to create JSON. This is also the first step toward re-enabling non-serial command execution. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void json_object_start(struct json_stream *ks UNNEEDED, const char *fieldname UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "json_object_start called!\n"); abort(); }
jsonrpc: declare up front whether a response is success or fail. Such an API is required for when we stream it directly. Almost all our handlers fit this pattern already, or nearly do. We remove new_json_result() in favor of explicit json_stream_success() and json_stream_fail(), but still allowing command_fail() if you just want a simple all-in-one fail wrapper. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for json_stream_fail */
Rename `struct json_result` to `struct json_stream` (RENAMEONLY) Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct json_stream *json_stream_fail(struct command *cmd UNNEEDED,
jsonrpc: declare up front whether a response is success or fail. Such an API is required for when we stream it directly. Almost all our handlers fit this pattern already, or nearly do. We remove new_json_result() in favor of explicit json_stream_success() and json_stream_fail(), but still allowing command_fail() if you just want a simple all-in-one fail wrapper. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
int code UNNEEDED,
const char *errmsg UNNEEDED)
{ fprintf(stderr, "json_stream_fail called!\n"); abort(); }
/* Generated stub for json_stream_success */
Rename `struct json_result` to `struct json_stream` (RENAMEONLY) Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct json_stream *json_stream_success(struct command *cmd UNNEEDED)
jsonrpc: declare up front whether a response is success or fail. Such an API is required for when we stream it directly. Almost all our handlers fit this pattern already, or nearly do. We remove new_json_result() in favor of explicit json_stream_success() and json_stream_fail(), but still allowing command_fail() if you just want a simple all-in-one fail wrapper. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "json_stream_success called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for json_tok_address_scriptpubkey */
enum address_parse_result json_tok_address_scriptpubkey(const tal_t *ctx UNNEEDED,
param: make json_tok_ handlers all return command_result, rename to param_ Handers of a specific form are both designed to be used as callbacks for param(), and also dispose of the command if something goes wrong. Make them return the &#39;struct command_result *&#39; from command_failed(), or NULL. Renaming them just makes sense: json_tok_XXX is used for non-command-freeing parsers too. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const struct chainparams *chainparams UNNEEDED,
const char *buffer UNNEEDED,
const jsmntok_t *tok UNNEEDED, const u8 **scriptpubkey UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "json_tok_address_scriptpubkey called!\n"); abort(); }
/* Generated stub for json_tok_channel_id */
bool json_tok_channel_id(const char *buffer UNNEEDED, const jsmntok_t *tok UNNEEDED,
struct channel_id *cid UNNEEDED)
{ fprintf(stderr, "json_tok_channel_id called!\n"); abort(); }
Use node_id everywhere for nodes. I tried to just do gossipd, but it was uncontainable, so this ended up being a complete sweep. We didn&#39;t get much space saving in gossipd, even though we should save 24 bytes per node. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for json_to_node_id */
bool json_to_node_id(const char *buffer UNNEEDED, const jsmntok_t *tok UNNEEDED,
struct node_id *id UNNEEDED)
{ fprintf(stderr, "json_to_node_id called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for json_to_short_channel_id */
bool json_to_short_channel_id(const char *buffer UNNEEDED, const jsmntok_t *tok UNNEEDED,
short_channel_id: don&#39;t accept :-separated in JSON if --allow-deprecated-apis=false We need to still accept it when parsing the database, but this flag should allow upgrade testing for devs building on top Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct short_channel_id *scid UNNEEDED,
bool may_be_deprecated_form UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "json_to_short_channel_id called!\n"); abort(); }
/* Generated stub for kill_uncommitted_channel */
void kill_uncommitted_channel(struct uncommitted_channel *uc UNNEEDED,
const char *why UNNEEDED)
{ fprintf(stderr, "kill_uncommitted_channel called!\n"); abort(); }
/* Generated stub for log_ */
log: add &#39;warning&#39; notification when log - Related Changes for `warning` notification Add a `bool` type parameter in `log_()` and `lov()`, this `bool` flag indicates if we should call `warning` notifier. 1) The process of copying `log_book` of every peer to the `log_book` of `ld` is usually included in `log_()` and `lov()`, and it may lead to repeated `warning` notification. So a `bool`, which explicitly indicates if the `warning` notification is disabled during this call, is necessary . 2) The `LOG_INFO` and `LOG_DEBUG` level don&#39;t need to call warning, so set that `bool` paramater as `FALSE` for these log level and only set it as `TRUE` for `LOG_UNUAUSL`/`LOG_BROKEN`. As for `LOG_IO`, it use `log_io()` to log, so we needn&#39;t think about notifier for it.
6 years ago
void log_(struct log *log UNNEEDED, enum log_level level UNNEEDED, bool call_notifier UNNEEDED, const char *fmt UNNEEDED, ...)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "log_ called!\n"); abort(); }
/* Generated stub for log_add */
void log_add(struct log *log UNNEEDED, const char *fmt UNNEEDED, ...)
{ fprintf(stderr, "log_add called!\n"); abort(); }
/* Generated stub for log_io */
void log_io(struct log *log UNNEEDED, enum log_level dir UNNEEDED, const char *comment UNNEEDED,
const void *data UNNEEDED, size_t len UNNEEDED)
{ fprintf(stderr, "log_io called!\n"); abort(); }
/* Generated stub for new_bolt11 */
common/bolt11: use struct amount_msat Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct bolt11 *new_bolt11(const tal_t *ctx UNNEEDED,
const struct amount_msat *msat TAKES UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "new_bolt11 called!\n"); abort(); }
/* Generated stub for new_log */
struct log *new_log(const tal_t *ctx UNNEEDED, struct log_book *record UNNEEDED, const char *fmt UNNEEDED, ...)
{ fprintf(stderr, "new_log called!\n"); abort(); }
/* Generated stub for new_log_book */
log: add &#39;warning&#39; notification when log - Related Changes for `warning` notification Add a `bool` type parameter in `log_()` and `lov()`, this `bool` flag indicates if we should call `warning` notifier. 1) The process of copying `log_book` of every peer to the `log_book` of `ld` is usually included in `log_()` and `lov()`, and it may lead to repeated `warning` notification. So a `bool`, which explicitly indicates if the `warning` notification is disabled during this call, is necessary . 2) The `LOG_INFO` and `LOG_DEBUG` level don&#39;t need to call warning, so set that `bool` paramater as `FALSE` for these log level and only set it as `TRUE` for `LOG_UNUAUSL`/`LOG_BROKEN`. As for `LOG_IO`, it use `log_io()` to log, so we needn&#39;t think about notifier for it.
6 years ago
struct log_book *new_log_book(struct lightningd *ld UNNEEDED, size_t max_mem UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
enum log_level printlevel UNNEEDED)
{ fprintf(stderr, "new_log_book called!\n"); abort(); }
/* Generated stub for new_reltimer_ */
struct oneshot *new_reltimer_(struct timers *timers UNNEEDED,
const tal_t *ctx UNNEEDED,
struct timerel expire UNNEEDED,
void (*cb)(void *) UNNEEDED, void *arg UNNEEDED)
{ fprintf(stderr, "new_reltimer_ called!\n"); abort(); }
Use node_id everywhere for nodes. I tried to just do gossipd, but it was uncontainable, so this ended up being a complete sweep. We didn&#39;t get much space saving in gossipd, even though we should save 24 bytes per node. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for node_id_cmp */
int node_id_cmp(const struct node_id *a UNNEEDED, const struct node_id *b UNNEEDED)
{ fprintf(stderr, "node_id_cmp called!\n"); abort(); }
/* Generated stub for node_id_to_hexstr */
char *node_id_to_hexstr(const tal_t *ctx UNNEEDED, const struct node_id *id UNNEEDED)
{ fprintf(stderr, "node_id_to_hexstr called!\n"); abort(); }
plugin: Add connect and disconnect notifications Signed-off-by: Christian Decker &lt;decker.christian@gmail.com&gt;
6 years ago
/* Generated stub for notify_connect */
Use node_id everywhere for nodes. I tried to just do gossipd, but it was uncontainable, so this ended up being a complete sweep. We didn&#39;t get much space saving in gossipd, even though we should save 24 bytes per node. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void notify_connect(struct lightningd *ld UNNEEDED, struct node_id *nodeid UNNEEDED,
plugin: Add connect and disconnect notifications Signed-off-by: Christian Decker &lt;decker.christian@gmail.com&gt;
6 years ago
struct wireaddr_internal *addr UNNEEDED)
{ fprintf(stderr, "notify_connect called!\n"); abort(); }
/* Generated stub for notify_disconnect */
Use node_id everywhere for nodes. I tried to just do gossipd, but it was uncontainable, so this ended up being a complete sweep. We didn&#39;t get much space saving in gossipd, even though we should save 24 bytes per node. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void notify_disconnect(struct lightningd *ld UNNEEDED, struct node_id *nodeid UNNEEDED)
plugin: Add connect and disconnect notifications Signed-off-by: Christian Decker &lt;decker.christian@gmail.com&gt;
6 years ago
{ fprintf(stderr, "notify_disconnect called!\n"); abort(); }
Plugins: Add a notification for invoice payment Similarly to the &#39;invoice_payment&#39; hook
6 years ago
/* Generated stub for notify_invoice_payment */
void notify_invoice_payment(struct lightningd *ld UNNEEDED, struct amount_msat amount UNNEEDED,
struct preimage preimage UNNEEDED, const struct json_escape *label UNNEEDED)
{ fprintf(stderr, "notify_invoice_payment called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for onchaind_funding_spent */
enum watch_result onchaind_funding_spent(struct channel *channel UNNEEDED,
const struct bitcoin_tx *tx UNNEEDED,
u32 blockheight UNNEEDED)
{ fprintf(stderr, "onchaind_funding_spent called!\n"); abort(); }
/* Generated stub for param */
bool param(struct command *cmd UNNEEDED, const char *buffer UNNEEDED,
const jsmntok_t params[] UNNEEDED, ...)
{ fprintf(stderr, "param called!\n"); abort(); }
param: make json_tok_ handlers all return command_result, rename to param_ Handers of a specific form are both designed to be used as callbacks for param(), and also dispose of the command if something goes wrong. Make them return the &#39;struct command_result *&#39; from command_failed(), or NULL. Renaming them just makes sense: json_tok_XXX is used for non-command-freeing parsers too. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for param_array */
struct command_result *param_array(struct command *cmd UNNEEDED, const char *name UNNEEDED,
const char *buffer UNNEEDED, const jsmntok_t *tok UNNEEDED,
const jsmntok_t **arr UNNEEDED)
{ fprintf(stderr, "param_array called!\n"); abort(); }
/* Generated stub for param_bool */
struct command_result *param_bool(struct command *cmd UNNEEDED, const char *name UNNEEDED,
const char *buffer UNNEEDED, const jsmntok_t *tok UNNEEDED,
bool **b UNNEEDED)
{ fprintf(stderr, "param_bool called!\n"); abort(); }
/* Generated stub for param_escaped_string */
struct command_result *param_escaped_string(struct command *cmd UNNEEDED,
const char *name UNNEEDED,
const char *buffer UNNEEDED,
const jsmntok_t *tok UNNEEDED,
const char **str UNNEEDED)
{ fprintf(stderr, "param_escaped_string called!\n"); abort(); }
/* Generated stub for param_label */
struct command_result *param_label(struct command *cmd UNNEEDED, const char *name UNNEEDED,
const char * buffer UNNEEDED, const jsmntok_t *tok UNNEEDED,
ccan: import ccan/json_out and ccan/json_escape. These are generalized from our internal implementations. The main difference is that &#39;struct json_escaped&#39; is now &#39;struct json_escape&#39;, so we replace that immediately. The difference between lightningd&#39;s json-writing ringbuffer and the more generic ccan/json_out is that the latter has a better API and handles escaping transparently if something slips through (though it does offer direct accessors so you can mess things up yourself!). Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct json_escape **label UNNEEDED)
param: make json_tok_ handlers all return command_result, rename to param_ Handers of a specific form are both designed to be used as callbacks for param(), and also dispose of the command if something goes wrong. Make them return the &#39;struct command_result *&#39; from command_failed(), or NULL. Renaming them just makes sense: json_tok_XXX is used for non-command-freeing parsers too. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "param_label called!\n"); abort(); }
/* Generated stub for param_loglevel */
struct command_result *param_loglevel(struct command *cmd UNNEEDED,
const char *name UNNEEDED,
const char *buffer UNNEEDED,
const jsmntok_t *tok UNNEEDED,
enum log_level **level UNNEEDED)
{ fprintf(stderr, "param_loglevel called!\n"); abort(); }
json: add cmd setchannelfee and wire to channeld * adds the channeld_specific_feerates wire message 1029 * adds a json command handler * adds u32 access methods for amount_msat
6 years ago
/* Generated stub for param_msat */
struct command_result *param_msat(struct command *cmd UNNEEDED, const char *name UNNEEDED,
const char *buffer UNNEEDED, const jsmntok_t *tok UNNEEDED,
struct amount_msat **msat UNNEEDED)
{ fprintf(stderr, "param_msat called!\n"); abort(); }
Use node_id everywhere for nodes. I tried to just do gossipd, but it was uncontainable, so this ended up being a complete sweep. We didn&#39;t get much space saving in gossipd, even though we should save 24 bytes per node. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for param_node_id */
struct command_result *param_node_id(struct command *cmd UNNEEDED,
const char *name UNNEEDED,
const char *buffer UNNEEDED,
const jsmntok_t *tok UNNEEDED,
struct node_id **id UNNEEDED)
{ fprintf(stderr, "param_node_id called!\n"); abort(); }
param: make json_tok_ handlers all return command_result, rename to param_ Handers of a specific form are both designed to be used as callbacks for param(), and also dispose of the command if something goes wrong. Make them return the &#39;struct command_result *&#39; from command_failed(), or NULL. Renaming them just makes sense: json_tok_XXX is used for non-command-freeing parsers too. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for param_number */
struct command_result *param_number(struct command *cmd UNNEEDED, const char *name UNNEEDED,
const char *buffer UNNEEDED, const jsmntok_t *tok UNNEEDED,
unsigned int **num UNNEEDED)
{ fprintf(stderr, "param_number called!\n"); abort(); }
/* Generated stub for param_short_channel_id */
struct command_result *param_short_channel_id(struct command *cmd UNNEEDED,
const char *name UNNEEDED,
const char *buffer UNNEEDED,
const jsmntok_t *tok UNNEEDED,
struct short_channel_id **scid UNNEEDED)
{ fprintf(stderr, "param_short_channel_id called!\n"); abort(); }
/* Generated stub for param_string */
struct command_result *param_string(struct command *cmd UNNEEDED, const char *name UNNEEDED,
const char * buffer UNNEEDED, const jsmntok_t *tok UNNEEDED,
const char **str UNNEEDED)
{ fprintf(stderr, "param_string called!\n"); abort(); }
/* Generated stub for param_tok */
struct command_result *param_tok(struct command *cmd UNNEEDED, const char *name UNNEEDED,
const char *buffer UNNEEDED, const jsmntok_t * tok UNNEEDED,
const jsmntok_t **out UNNEEDED)
{ fprintf(stderr, "param_tok called!\n"); abort(); }
/* Generated stub for param_u64 */
struct command_result *param_u64(struct command *cmd UNNEEDED, const char *name UNNEEDED,
const char *buffer UNNEEDED, const jsmntok_t *tok UNNEEDED,
uint64_t **num UNNEEDED)
{ fprintf(stderr, "param_u64 called!\n"); abort(); }
channeld: wire up dev_memleak. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for peer_memleak_done */
void peer_memleak_done(struct command *cmd UNNEEDED, struct subd *leaker UNNEEDED)
{ fprintf(stderr, "peer_memleak_done called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for peer_start_channeld */
void peer_start_channeld(struct channel *channel UNNEEDED,
common/per_per_state: generalize lightningd/peer_comm Part 1 Encapsulating the peer state was a win for lightningd; not surprisingly, it&#39;s even more of a win for the other daemons, especially as we want to add a little gossip information. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct per_peer_state *pps UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const u8 *funding_signed UNNEEDED,
bool reconnected UNNEEDED)
{ fprintf(stderr, "peer_start_channeld called!\n"); abort(); }
/* Generated stub for peer_start_closingd */
void peer_start_closingd(struct channel *channel UNNEEDED,
common/per_per_state: generalize lightningd/peer_comm Part 1 Encapsulating the peer state was a win for lightningd; not surprisingly, it&#39;s even more of a win for the other daemons, especially as we want to add a little gossip information. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct per_peer_state *pps UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
bool reconnected UNNEEDED,
const u8 *channel_reestablish UNNEEDED)
{ fprintf(stderr, "peer_start_closingd called!\n"); abort(); }
/* Generated stub for peer_start_openingd */
void peer_start_openingd(struct peer *peer UNNEEDED,
common/per_per_state: generalize lightningd/peer_comm Part 1 Encapsulating the peer state was a win for lightningd; not surprisingly, it&#39;s even more of a win for the other daemons, especially as we want to add a little gossip information. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct per_peer_state *pps UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const u8 *msg UNNEEDED)
{ fprintf(stderr, "peer_start_openingd called!\n"); abort(); }
common/per_per_state: generalize lightningd/peer_comm Part 1 Encapsulating the peer state was a win for lightningd; not surprisingly, it&#39;s even more of a win for the other daemons, especially as we want to add a little gossip information. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for per_peer_state_set_fds */
void per_peer_state_set_fds(struct per_peer_state *pps UNNEEDED,
int peer_fd UNNEEDED, int gossip_fd UNNEEDED, int gossip_store_fd UNNEEDED)
{ fprintf(stderr, "per_peer_state_set_fds called!\n"); abort(); }
plugin: Add `connected` hook This hook is used to let a plugin decide whether we should continue with the connection normally, or whether we should be dropping the connection. Possible use-cases include policy enforcement (dropping connections based on previous interactions), draining a node by allowing only peers with an active channel to reconnect, or temporarily preventing a channel from making progress. Signed-off-by: Christian Decker &lt;decker.christian@gmail.com&gt;
6 years ago
/* Generated stub for plugin_hook_call_ */
void plugin_hook_call_(struct lightningd *ld UNNEEDED, const struct plugin_hook *hook UNNEEDED,
void *payload UNNEEDED, void *cb_arg UNNEEDED)
{ fprintf(stderr, "plugin_hook_call_ called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for set_log_outfn_ */
void set_log_outfn_(struct log_book *lr UNNEEDED,
void (*print)(const char *prefix UNNEEDED,
enum log_level level UNNEEDED,
bool continued UNNEEDED,
const struct timeabs *time UNNEEDED,
const char *str UNNEEDED,
log: truncate giant IO logging. Adding a giant IO message simply causes it to be pruned immediately, so truncate it if it&#39;s more than 1/64 the max size. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const u8 *io UNNEEDED, size_t io_len UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
void *arg) UNNEEDED,
void *arg UNNEEDED)
{ fprintf(stderr, "set_log_outfn_ called!\n"); abort(); }
/* Generated stub for subd_release_channel */
void subd_release_channel(struct subd *owner UNNEEDED, void *channel UNNEEDED)
{ fprintf(stderr, "subd_release_channel called!\n"); abort(); }
/* Generated stub for subd_req_ */
void subd_req_(const tal_t *ctx UNNEEDED,
struct subd *sd UNNEEDED,
const u8 *msg_out UNNEEDED,
int fd_out UNNEEDED, size_t num_fds_in UNNEEDED,
void (*replycb)(struct subd * UNNEEDED, const u8 * UNNEEDED, const int * UNNEEDED, void *) UNNEEDED,
void *replycb_data UNNEEDED)
{ fprintf(stderr, "subd_req_ called!\n"); abort(); }
/* Generated stub for subd_send_msg */
void subd_send_msg(struct subd *sd UNNEEDED, const u8 *msg_out UNNEEDED)
{ fprintf(stderr, "subd_send_msg called!\n"); abort(); }
channeld: wire up dev_memleak. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for towire_channel_dev_memleak */
u8 *towire_channel_dev_memleak(const tal_t *ctx UNNEEDED)
{ fprintf(stderr, "towire_channel_dev_memleak called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for towire_channel_dev_reenable_commit */
u8 *towire_channel_dev_reenable_commit(const tal_t *ctx UNNEEDED)
{ fprintf(stderr, "towire_channel_dev_reenable_commit called!\n"); abort(); }
/* Generated stub for towire_channel_send_shutdown */
u8 *towire_channel_send_shutdown(const tal_t *ctx UNNEEDED)
{ fprintf(stderr, "towire_channel_send_shutdown called!\n"); abort(); }
json: add cmd setchannelfee and wire to channeld * adds the channeld_specific_feerates wire message 1029 * adds a json command handler * adds u32 access methods for amount_msat
6 years ago
/* Generated stub for towire_channel_specific_feerates */
u8 *towire_channel_specific_feerates(const tal_t *ctx UNNEEDED, u32 feerate_base UNNEEDED, u32 feerate_ppm UNNEEDED)
{ fprintf(stderr, "towire_channel_specific_feerates called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for towire_connectctl_connect_to_peer */
Use node_id everywhere for nodes. I tried to just do gossipd, but it was uncontainable, so this ended up being a complete sweep. We didn&#39;t get much space saving in gossipd, even though we should save 24 bytes per node. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
u8 *towire_connectctl_connect_to_peer(const tal_t *ctx UNNEEDED, const struct node_id *id UNNEEDED, u32 seconds_waited UNNEEDED, const struct wireaddr_internal *addrhint UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "towire_connectctl_connect_to_peer called!\n"); abort(); }
/* Generated stub for towire_connectctl_peer_disconnected */
Use node_id everywhere for nodes. I tried to just do gossipd, but it was uncontainable, so this ended up being a complete sweep. We didn&#39;t get much space saving in gossipd, even though we should save 24 bytes per node. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
u8 *towire_connectctl_peer_disconnected(const tal_t *ctx UNNEEDED, const struct node_id *id UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "towire_connectctl_peer_disconnected called!\n"); abort(); }
/* Generated stub for towire_errorfmt */
u8 *towire_errorfmt(const tal_t *ctx UNNEEDED,
const struct channel_id *channel UNNEEDED,
const char *fmt UNNEEDED, ...)
{ fprintf(stderr, "towire_errorfmt called!\n"); abort(); }
/* Generated stub for towire_gossip_get_incoming_channels */
wire-gen: move in-house wire delcarations to new format tidying things up!
6 years ago
u8 *towire_gossip_get_incoming_channels(const tal_t *ctx UNNEEDED, bool *private_too UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "towire_gossip_get_incoming_channels called!\n"); abort(); }
/* Generated stub for towire_hsm_get_channel_basepoints */
Use node_id everywhere for nodes. I tried to just do gossipd, but it was uncontainable, so this ended up being a complete sweep. We didn&#39;t get much space saving in gossipd, even though we should save 24 bytes per node. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
u8 *towire_hsm_get_channel_basepoints(const tal_t *ctx UNNEEDED, const struct node_id *peerid UNNEEDED, u64 dbid UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "towire_hsm_get_channel_basepoints called!\n"); abort(); }
/* Generated stub for towire_hsm_sign_commitment_tx */
Use node_id everywhere for nodes. I tried to just do gossipd, but it was uncontainable, so this ended up being a complete sweep. We didn&#39;t get much space saving in gossipd, even though we should save 24 bytes per node. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
u8 *towire_hsm_sign_commitment_tx(const tal_t *ctx UNNEEDED, const struct node_id *peer_id UNNEEDED, u64 channel_dbid UNNEEDED, const struct bitcoin_tx *tx UNNEEDED, const struct pubkey *remote_funding_key UNNEEDED, struct amount_sat funding_amount UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "towire_hsm_sign_commitment_tx called!\n"); abort(); }
/* Generated stub for towire_hsm_sign_invoice */
u8 *towire_hsm_sign_invoice(const tal_t *ctx UNNEEDED, const u8 *u5bytes UNNEEDED, const u8 *hrp UNNEEDED)
{ fprintf(stderr, "towire_hsm_sign_invoice called!\n"); abort(); }
onchaind: wire up dev_memleak. For onchaind we need to remove globals from memleak consideration; we also change the htlc pointer to an htlc copy, which simplifies things as well. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for towire_onchain_dev_memleak */
u8 *towire_onchain_dev_memleak(const tal_t *ctx UNNEEDED)
{ fprintf(stderr, "towire_onchain_dev_memleak called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for txfilter_add_scriptpubkey */
void txfilter_add_scriptpubkey(struct txfilter *filter UNNEEDED, const u8 *script TAKES UNNEEDED)
{ fprintf(stderr, "txfilter_add_scriptpubkey called!\n"); abort(); }
[test] update test mocks for getinfo rpc update
6 years ago
/* Generated stub for version */
const char *version(void)
{ fprintf(stderr, "version called!\n"); abort(); }
wallet: Don&#39;t delete channels from DB, mark them closed. Since we now have a couple of long-lived dependents it is time we stop removing channels from the table once they are fully closed, and instead just mark them as closed. This allows us to keep forwards and transactions foreign keys intact, and it may help us debug things after the fact. Fixes #2028 Signed-off-by: Christian Decker &lt;decker.christian@gmail.com&gt;
6 years ago
/* Generated stub for wallet_channel_close */
void wallet_channel_close(struct wallet *w UNNEEDED, u64 wallet_id UNNEEDED)
{ fprintf(stderr, "wallet_channel_close called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for wallet_channel_save */
void wallet_channel_save(struct wallet *w UNNEEDED, struct channel *chan UNNEEDED)
{ fprintf(stderr, "wallet_channel_save called!\n"); abort(); }
/* Generated stub for wallet_channels_load_active */
wallet: cleanup the tal context in wallet_channels_load_active() and wallet_stmt2channel() The original idea is to &#34;tal&#34; channel on the &#34;ctx&#34;(In fact, we&#39;d like to set ctx as &#34;ld&#34;). But we already tal channel on &#34;ld&#34; in new_channel(), so &#34;ctx&#34; is unused.
6 years ago
bool wallet_channels_load_active(struct wallet *w UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "wallet_channels_load_active called!\n"); abort(); }
/* Generated stub for wallet_channel_stats_load */
void wallet_channel_stats_load(struct wallet *w UNNEEDED, u64 cdbid UNNEEDED, struct channel_stats *stats UNNEEDED)
{ fprintf(stderr, "wallet_channel_stats_load called!\n"); abort(); }
/* Generated stub for wallet_channeltxs_add */
void wallet_channeltxs_add(struct wallet *w UNNEEDED, struct channel *chan UNNEEDED,
const int type UNNEEDED, const struct bitcoin_txid *txid UNNEEDED,
const u32 input_num UNNEEDED, const u32 blockheight UNNEEDED)
{ fprintf(stderr, "wallet_channeltxs_add called!\n"); abort(); }
/* Generated stub for wallet_htlcs_load_for_channel */
bool wallet_htlcs_load_for_channel(struct wallet *wallet UNNEEDED,
struct channel *chan UNNEEDED,
struct htlc_in_map *htlcs_in UNNEEDED,
struct htlc_out_map *htlcs_out UNNEEDED)
{ fprintf(stderr, "wallet_htlcs_load_for_channel called!\n"); abort(); }
/* Generated stub for wallet_invoice_create */
bool wallet_invoice_create(struct wallet *wallet UNNEEDED,
struct invoice *pinvoice UNNEEDED,
common/bolt11: use struct amount_msat Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const struct amount_msat *msat TAKES UNNEEDED,
ccan: import ccan/json_out and ccan/json_escape. These are generalized from our internal implementations. The main difference is that &#39;struct json_escaped&#39; is now &#39;struct json_escape&#39;, so we replace that immediately. The difference between lightningd&#39;s json-writing ringbuffer and the more generic ccan/json_out is that the latter has a better API and handles escaping transparently if something slips through (though it does offer direct accessors so you can mess things up yourself!). Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const struct json_escape *label TAKES UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
u64 expiry UNNEEDED,
const char *b11enc UNNEEDED,
const char *description UNNEEDED,
const struct preimage *r UNNEEDED,
const struct sha256 *rhash UNNEEDED)
{ fprintf(stderr, "wallet_invoice_create called!\n"); abort(); }
/* Generated stub for wallet_invoice_delete */
bool wallet_invoice_delete(struct wallet *wallet UNNEEDED,
struct invoice invoice UNNEEDED)
{ fprintf(stderr, "wallet_invoice_delete called!\n"); abort(); }
/* Generated stub for wallet_invoice_delete_expired */
void wallet_invoice_delete_expired(struct wallet *wallet UNNEEDED,
u64 max_expiry_time UNNEEDED)
{ fprintf(stderr, "wallet_invoice_delete_expired called!\n"); abort(); }
/* Generated stub for wallet_invoice_details */
const struct invoice_details *wallet_invoice_details(const tal_t *ctx UNNEEDED,
struct wallet *wallet UNNEEDED,
struct invoice invoice UNNEEDED)
{ fprintf(stderr, "wallet_invoice_details called!\n"); abort(); }
/* Generated stub for wallet_invoice_find_by_label */
bool wallet_invoice_find_by_label(struct wallet *wallet UNNEEDED,
struct invoice *pinvoice UNNEEDED,
ccan: import ccan/json_out and ccan/json_escape. These are generalized from our internal implementations. The main difference is that &#39;struct json_escaped&#39; is now &#39;struct json_escape&#39;, so we replace that immediately. The difference between lightningd&#39;s json-writing ringbuffer and the more generic ccan/json_out is that the latter has a better API and handles escaping transparently if something slips through (though it does offer direct accessors so you can mess things up yourself!). Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const struct json_escape *label UNNEEDED)
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
{ fprintf(stderr, "wallet_invoice_find_by_label called!\n"); abort(); }
/* Generated stub for wallet_invoice_find_by_rhash */
bool wallet_invoice_find_by_rhash(struct wallet *wallet UNNEEDED,
struct invoice *pinvoice UNNEEDED,
const struct sha256 *rhash UNNEEDED)
{ fprintf(stderr, "wallet_invoice_find_by_rhash called!\n"); abort(); }
lightningd: move local invoice resolution into invoice.c function. We&#39;re going to make it async, so start by moving the core code into invoice.c and having that directly call fail/success functions for the htlc. We add an extra check in fulfill_htlc() that the HTLC state is correct: that can&#39;t happen now, but may once we&#39;re async. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for wallet_invoice_find_unpaid */
bool wallet_invoice_find_unpaid(struct wallet *wallet UNNEEDED,
struct invoice *pinvoice UNNEEDED,
const struct sha256 *rhash UNNEEDED)
{ fprintf(stderr, "wallet_invoice_find_unpaid called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for wallet_invoice_iterate */
bool wallet_invoice_iterate(struct wallet *wallet UNNEEDED,
struct invoice_iterator *it UNNEEDED)
{ fprintf(stderr, "wallet_invoice_iterate called!\n"); abort(); }
/* Generated stub for wallet_invoice_iterator_deref */
const struct invoice_details *wallet_invoice_iterator_deref(const tal_t *ctx UNNEEDED,
struct wallet *wallet UNNEEDED,
const struct invoice_iterator *it UNNEEDED)
{ fprintf(stderr, "wallet_invoice_iterator_deref called!\n"); abort(); }
lightningd: move local invoice resolution into invoice.c function. We&#39;re going to make it async, so start by moving the core code into invoice.c and having that directly call fail/success functions for the htlc. We add an extra check in fulfill_htlc() that the HTLC state is correct: that can&#39;t happen now, but may once we&#39;re async. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for wallet_invoice_resolve */
void wallet_invoice_resolve(struct wallet *wallet UNNEEDED,
struct invoice invoice UNNEEDED,
struct amount_msat received UNNEEDED)
{ fprintf(stderr, "wallet_invoice_resolve called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for wallet_invoice_waitany */
void wallet_invoice_waitany(const tal_t *ctx UNNEEDED,
struct wallet *wallet UNNEEDED,
u64 lastpay_index UNNEEDED,
void (*cb)(const struct invoice * UNNEEDED, void*) UNNEEDED,
void *cbarg UNNEEDED)
{ fprintf(stderr, "wallet_invoice_waitany called!\n"); abort(); }
/* Generated stub for wallet_invoice_waitone */
void wallet_invoice_waitone(const tal_t *ctx UNNEEDED,
struct wallet *wallet UNNEEDED,
struct invoice invoice UNNEEDED,
void (*cb)(const struct invoice * UNNEEDED, void*) UNNEEDED,
void *cbarg UNNEEDED)
{ fprintf(stderr, "wallet_invoice_waitone called!\n"); abort(); }
/* Generated stub for wallet_peer_delete */
void wallet_peer_delete(struct wallet *w UNNEEDED, u64 peer_dbid UNNEEDED)
{ fprintf(stderr, "wallet_peer_delete called!\n"); abort(); }
[test] update test mocks for getinfo rpc update
6 years ago
/* Generated stub for wallet_total_forward_fees */
wallet: use amount_sat/amount_msat. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct amount_msat wallet_total_forward_fees(struct wallet *w UNNEEDED)
[test] update test mocks for getinfo rpc update
6 years ago
{ fprintf(stderr, "wallet_total_forward_fees called!\n"); abort(); }
onchaind: Store and annotate close transaction when we drop to chain Signed-off-by: Christian Decker &lt;decker.christian@gmail.com&gt;
6 years ago
/* Generated stub for wallet_transaction_add */
void wallet_transaction_add(struct wallet *w UNNEEDED, const struct bitcoin_tx *tx UNNEEDED,
const u32 blockheight UNNEEDED, const u32 txindex UNNEEDED)
{ fprintf(stderr, "wallet_transaction_add called!\n"); abort(); }
wallet: Annotate funding transaction in the database Signed-off-by: Christian Decker &lt;decker.christian@gmail.com&gt;
6 years ago
/* Generated stub for wallet_transaction_annotate */
void wallet_transaction_annotate(struct wallet *w UNNEEDED,
wallet: Rip out the txtypes type in favor of enum wallet_tx_type Suggested-by: Rusty Russell &lt;@rustyrussell&gt; Signed-off-by: Christian Decker &lt;decker.christian@gmail.com&gt;
6 years ago
const struct bitcoin_txid *txid UNNEEDED,
enum wallet_tx_type type UNNEEDED, u64 channel_id UNNEEDED)
wallet: Annotate funding transaction in the database Signed-off-by: Christian Decker &lt;decker.christian@gmail.com&gt;
6 years ago
{ fprintf(stderr, "wallet_transaction_annotate called!\n"); abort(); }
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* Generated stub for wallet_transaction_locate */
struct txlocator *wallet_transaction_locate(const tal_t *ctx UNNEEDED, struct wallet *w UNNEEDED,
const struct bitcoin_txid *txid UNNEEDED)
{ fprintf(stderr, "wallet_transaction_locate called!\n"); abort(); }
/* Generated stub for watch_txid */
struct txwatch *watch_txid(const tal_t *ctx UNNEEDED,
struct chain_topology *topo UNNEEDED,
struct channel *channel UNNEEDED,
const struct bitcoin_txid *txid UNNEEDED,
enum watch_result (*cb)(struct lightningd *ld UNNEEDED,
struct channel *channel UNNEEDED,
const struct bitcoin_txid * UNNEEDED,
lightningd: fix occasional missing txid detection. I was working on rewriting our (somewhat chaotic) tx watching code for 0.7.2, when I found this bug: we don&#39;t always notice the funding tx in corner cases where more than one block is detected at once. This is just the one commit needed to fix the problem: it has some unnecessary changes, but I&#39;d prefer not to diverge too far from my cleanup-txwatch branch. Fixes: #2352 Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
const struct bitcoin_tx * UNNEEDED,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
unsigned int depth))
{ fprintf(stderr, "watch_txid called!\n"); abort(); }
/* Generated stub for watch_txo */
struct txowatch *watch_txo(const tal_t *ctx UNNEEDED,
struct chain_topology *topo UNNEEDED,
struct channel *channel UNNEEDED,
const struct bitcoin_txid *txid UNNEEDED,
unsigned int output UNNEEDED,
enum watch_result (*cb)(struct channel *channel UNNEEDED,
const struct bitcoin_tx *tx UNNEEDED,
size_t input_num UNNEEDED,
const struct block *block))
{ fprintf(stderr, "watch_txo called!\n"); abort(); }
/* AUTOGENERATED MOCKS END */
#if DEVELOPER
/* Generated stub for dev_disconnect_permanent */
bool dev_disconnect_permanent(struct lightningd *ld UNNEEDED)
{ fprintf(stderr, "dev_disconnect_permanent called!\n"); abort(); }
#endif
static void add_inchan(struct route_info **inchans, int n)
{
utils: make tal_arr_expand safer. Christian and I both unwittingly used it in form: *tal_arr_expand(&amp;x) = tal(x, ...) Since &#39;=&#39; isn&#39;t a sequence point, the compiler can (and does!) cache the value of x, handing it to tal *after* tal_arr_expand() moves it due to tal_resize(). The new version is somewhat less convenient to use, but doesn&#39;t have this problem, since the assignment is always evaluated after the resize. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
struct route_info r;
memset(&r.pubkey, n, sizeof(r.pubkey));
memset(&r.short_channel_id, n, sizeof(r.short_channel_id));
r.fee_base_msat = r.fee_proportional_millionths = r.cltv_expiry_delta
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
= n;
utils: make tal_arr_expand safer. Christian and I both unwittingly used it in form: *tal_arr_expand(&amp;x) = tal(x, ...) Since &#39;=&#39; isn&#39;t a sequence point, the compiler can (and does!) cache the value of x, handing it to tal *after* tal_arr_expand() moves it due to tal_resize(). The new version is somewhat less convenient to use, but doesn&#39;t have this problem, since the assignment is always evaluated after the resize. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
tal_arr_expand(inchans, r);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
}
static void add_peer(struct lightningd *ld, int n, enum channel_state state,
bool connected)
{
struct peer *peer = tal(ld, struct peer);
struct channel *c = tal(peer, struct channel);
memset(&peer->id, n, sizeof(peer->id));
list_head_init(&peer->channels);
list_add_tail(&ld->peers, &peer->list);
c->state = state;
c->owner = connected ? (void *)peer : NULL;
/* Channel has incoming capacity n*1000 - 1 millisatoshi */
daemons: use amount_msat/amount_sat in all internal wire transfers. As a side-effect of using amount_msat in gossipd/routing.c, we explicitly handle overflows and don&#39;t need to pre-prune ridiculous-fee channels. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
c->funding.satoshis = n+1;
c->our_msat = AMOUNT_MSAT(1);
c->our_config.channel_reserve = AMOUNT_SAT(1);
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
c->channel_info.their_config.channel_reserve = AMOUNT_SAT(0);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
list_add_tail(&peer->channels, &c->list);
}
Use node_id everywhere for nodes. I tried to just do gossipd, but it was uncontainable, so this ended up being a complete sweep. We didn&#39;t get much space saving in gossipd, even though we should save 24 bytes per node. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* There *is* padding in this structure, after pubkey and after cltv_expiry_delta. */
STRUCTEQ_DEF(route_info,
ALIGNOF(struct short_channel_id) - 1 - sizeof(u16),
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
pubkey,
Use node_id everywhere for nodes. I tried to just do gossipd, but it was uncontainable, so this ended up being a complete sweep. We didn&#39;t get much space saving in gossipd, even though we should save 24 bytes per node. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
cltv_expiry_delta,
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
short_channel_id,
fee_base_msat,
Use node_id everywhere for nodes. I tried to just do gossipd, but it was uncontainable, so this ended up being a complete sweep. We didn&#39;t get much space saving in gossipd, even though we should save 24 bytes per node. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
fee_proportional_millionths);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
int main(void)
{
struct lightningd *ld;
bool any_offline;
struct route_info *inchans;
struct route_info **ret;
size_t n;
setup_locale();
secp256k1_ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY
| SECP256K1_CONTEXT_SIGN);
setup_tmpctx();
ld = tal(tmpctx, struct lightningd);
list_head_init(&ld->peers);
inchans = tal_arr(tmpctx, struct route_info, 0);
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
/* 1. Nothing to choose from -> NULL result. */
daemons: use amount_msat/amount_sat in all internal wire transfers. As a side-effect of using amount_msat in gossipd/routing.c, we explicitly handle overflows and don&#39;t need to pre-prune ridiculous-fee channels. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(select_inchan(tmpctx, ld, AMOUNT_MSAT(0), inchans, &any_offline) == NULL);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(any_offline == false);
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
/* 2. inchan but no corresponding peer -> NULL result. */
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
add_inchan(&inchans, 0);
daemons: use amount_msat/amount_sat in all internal wire transfers. As a side-effect of using amount_msat in gossipd/routing.c, we explicitly handle overflows and don&#39;t need to pre-prune ridiculous-fee channels. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(select_inchan(tmpctx, ld, AMOUNT_MSAT(0), inchans, &any_offline) == NULL);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(any_offline == false);
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
/* 3. inchan but its peer in awaiting lockin -> NULL result. */
add_peer(ld, 0, CHANNELD_AWAITING_LOCKIN, true);
daemons: use amount_msat/amount_sat in all internal wire transfers. As a side-effect of using amount_msat in gossipd/routing.c, we explicitly handle overflows and don&#39;t need to pre-prune ridiculous-fee channels. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(select_inchan(tmpctx, ld, AMOUNT_MSAT(0), inchans, &any_offline) == NULL);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(any_offline == false);
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
/* 4. connected peer but no corresponding inchan -> NULL result. */
add_peer(ld, 1, CHANNELD_NORMAL, true);
daemons: use amount_msat/amount_sat in all internal wire transfers. As a side-effect of using amount_msat in gossipd/routing.c, we explicitly handle overflows and don&#39;t need to pre-prune ridiculous-fee channels. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(select_inchan(tmpctx, ld, AMOUNT_MSAT(0), inchans, &any_offline) == NULL);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(any_offline == false);
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
/* 5. inchan but its peer (replaced with one) offline -> NULL result. */
list_del_from(&ld->peers, &list_tail(&ld->peers, struct peer, list)->list);
add_peer(ld, 1, CHANNELD_NORMAL, false);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
add_inchan(&inchans, 1);
daemons: use amount_msat/amount_sat in all internal wire transfers. As a side-effect of using amount_msat in gossipd/routing.c, we explicitly handle overflows and don&#39;t need to pre-prune ridiculous-fee channels. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(select_inchan(tmpctx, ld, AMOUNT_MSAT(0), inchans, &any_offline) == NULL);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(any_offline == true);
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
/* 6. Finally, a correct peer! */
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
add_inchan(&inchans, 2);
add_peer(ld, 2, CHANNELD_NORMAL, true);
daemons: use amount_msat/amount_sat in all internal wire transfers. As a side-effect of using amount_msat in gossipd/routing.c, we explicitly handle overflows and don&#39;t need to pre-prune ridiculous-fee channels. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
ret = select_inchan(tmpctx, ld, AMOUNT_MSAT(0), inchans, &any_offline);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(tal_count(ret) == 1);
assert(tal_count(ret[0]) == 1);
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
assert(any_offline == true); /* Peer 1 is offline */
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(route_info_eq(ret[0], &inchans[2]));
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
/* 7. Correct peer with just enough capacity_to_pay_us */
daemons: use amount_msat/amount_sat in all internal wire transfers. As a side-effect of using amount_msat in gossipd/routing.c, we explicitly handle overflows and don&#39;t need to pre-prune ridiculous-fee channels. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
ret = select_inchan(tmpctx, ld, AMOUNT_MSAT(1999), inchans, &any_offline);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(tal_count(ret) == 1);
assert(tal_count(ret[0]) == 1);
assert(any_offline == false); /* Other candidate insufficient funds. */
assert(route_info_eq(ret[0], &inchans[2]));
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
/* 8. Not if we ask for too much! Our balance is 1msat. */
daemons: use amount_msat/amount_sat in all internal wire transfers. As a side-effect of using amount_msat in gossipd/routing.c, we explicitly handle overflows and don&#39;t need to pre-prune ridiculous-fee channels. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
ret = select_inchan(tmpctx, ld, AMOUNT_MSAT(2000), inchans, &any_offline);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(ret == NULL);
assert(any_offline == false); /* Other candidate insufficient funds. */
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
/* 9. Add another peer */
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
add_inchan(&inchans, 3);
add_peer(ld, 3, CHANNELD_NORMAL, true);
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
/* Simulate selection ratios between excesses 25% and 50% of capacity*/
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
for (size_t i = n = 0; i < 1000; i++) {
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
ret = select_inchan(tmpctx, ld, AMOUNT_MSAT(1499), inchans, &any_offline);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(tal_count(ret) == 1);
assert(tal_count(ret[0]) == 1);
assert(any_offline == false); /* Other candidate insufficient funds. */
assert(route_info_eq(ret[0], &inchans[2])
|| route_info_eq(ret[0], &inchans[3]));
n += route_info_eq(ret[0], &inchans[2]);
}
/* Handwave over probability of this happening! Within 20% */
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
printf("Number of selections with excess 25 percent of capacity: %zu\n"
"Number of selections with excess 50 percent of capacity: %zu\n",
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
n, 1000 - n);
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
assert(n > 333 - 66 && n < 333 + 66);
/* 10. Last peer's capacity goes from 3 to 2 sat*/
list_tail(&list_tail(&ld->peers, struct peer, list)->channels, struct channel, list)->
channel_info.their_config.channel_reserve = AMOUNT_SAT(1);
ret = select_inchan(tmpctx, ld, AMOUNT_MSAT(1499), inchans, &any_offline);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
/* Simulate selection ratios between excesses 25% and 75% of capacity*/
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
for (size_t i = n = 0; i < 1000; i++) {
daemons: use amount_msat/amount_sat in all internal wire transfers. As a side-effect of using amount_msat in gossipd/routing.c, we explicitly handle overflows and don&#39;t need to pre-prune ridiculous-fee channels. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
ret = select_inchan(tmpctx, ld, AMOUNT_MSAT(1499), inchans, &any_offline);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
assert(tal_count(ret) == 1);
assert(tal_count(ret[0]) == 1);
assert(any_offline == false); /* Other candidate insufficient funds. */
assert(route_info_eq(ret[0], &inchans[2])
|| route_info_eq(ret[0], &inchans[3]));
n += route_info_eq(ret[0], &inchans[2]);
}
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
/* Handwave over probability of this happening! Within 20% */
printf("Number of selections with excess 25 percent of capacity: %zu\n"
"Number of selections with excess 75 percent of capacity: %zu\n",
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
n, 1000 - n);
lightningd: fix/refactor select_inchan for invoice route-hint, use fractional excess as weight Refactored the weighted-reservoir-sampling algo to make it more straightforward. It now uses the excess as fraction of capacity as weight. This favors channels that are more _relatively_ unbalanced to be used for incoming payment. Now passes test_invoice_routeboost_private() when using max fundamount=16777215.
6 years ago
assert(n > 250 - 50 && n < 250 + 50);
json-invoice: add routeboost, warnings. We split json_invoice(), as it now needs to round-trip to the gossipd, and uniqueness checks need to happen *after* gossipd replies to avoid a race. For every candidate channel gossipd gives us, we check that it&#39;s in state NORMAL (not shutting down, not still waiting for lockin), that it&#39;s connected, and that it has capacity. We then choose one with probability weighted by excess capacity, so larger channels are more likely. As a side effect of this, we can tell if an invoice is unpayble (no channels have sufficient incoming capacity) or difficuly (no *online* channels have sufficient capacity), so we add those warnings. Signed-off-by: Rusty Russell &lt;rusty@rustcorp.com.au&gt;
6 years ago
/* No memory leaks please */
secp256k1_context_destroy(secp256k1_ctx);
tal_free(tmpctx);
/* FIXME: Do BOLT comparison! */
return 0;
}