mirror of
https://github.com/ElementsProject/lightning.git
synced 2025-01-18 21:35:11 +01:00
lightningd: remove lightningd_state.
Some fields were redundant, some are simply moved into 'struct lightningd'. All routines updated to hand 'struct lightningd *ld' now. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
This commit is contained in:
Rusty Russell
Christian Decker
parent
77bcaf0a25
commit
153c622157
@ -9,7 +9,7 @@
|
||||
#include <stdbool.h>
|
||||
|
||||
struct sha256_double;
|
||||
struct lightningd_state;
|
||||
struct lightningd;
|
||||
struct ripemd160;
|
||||
struct bitcoin_tx;
|
||||
struct peer;
|
||||
|
||||
@ -503,13 +503,13 @@ void json_dev_broadcast(struct command *cmd,
|
||||
return;
|
||||
}
|
||||
|
||||
log_debug(cmd->dstate->base_log, "dev-broadcast: broadcast %s",
|
||||
log_debug(cmd->ld->log, "dev-broadcast: broadcast %s",
|
||||
enable ? "enabled" : "disabled");
|
||||
cmd->dstate->topology->dev_no_broadcast = !enable;
|
||||
cmd->ld->topology->dev_no_broadcast = !enable;
|
||||
|
||||
/* If enabling, flush and wait. */
|
||||
if (enable)
|
||||
rebroadcast_txs(cmd->dstate->topology, cmd);
|
||||
rebroadcast_txs(cmd->ld->topology, cmd);
|
||||
else
|
||||
command_success(cmd, null_response(cmd));
|
||||
}
|
||||
@ -517,7 +517,7 @@ void json_dev_broadcast(struct command *cmd,
|
||||
static void json_dev_blockheight(struct command *cmd,
|
||||
const char *buffer, const jsmntok_t *params)
|
||||
{
|
||||
struct chain_topology *topo = cmd->dstate->topology;
|
||||
struct chain_topology *topo = cmd->ld->topology;
|
||||
struct json_result *response;
|
||||
|
||||
response = new_json_result(cmd);
|
||||
@ -557,22 +557,22 @@ struct chain_topology *new_topology(const tal_t *ctx, struct log *log)
|
||||
topo->default_fee_rate = 40000;
|
||||
topo->override_fee_rate = 0;
|
||||
topo->dev_no_broadcast = false;
|
||||
topo->bitcoind = new_bitcoind(topo, log);
|
||||
|
||||
return topo;
|
||||
}
|
||||
|
||||
void setup_topology(struct chain_topology *topo, struct bitcoind *bitcoind,
|
||||
void setup_topology(struct chain_topology *topo,
|
||||
struct timers *timers,
|
||||
struct timerel poll_time, u32 first_peer_block)
|
||||
{
|
||||
topo->startup = true;
|
||||
topo->feerate = 0;
|
||||
topo->timers = timers;
|
||||
topo->bitcoind = bitcoind;
|
||||
topo->poll_time = poll_time;
|
||||
topo->first_blocknum = first_peer_block;
|
||||
|
||||
bitcoind_getblockcount(bitcoind, get_init_blockhash, topo);
|
||||
bitcoind_getblockcount(topo->bitcoind, get_init_blockhash, topo);
|
||||
|
||||
tal_add_destructor(topo, destroy_outgoing_txs);
|
||||
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
struct bitcoin_tx;
|
||||
struct bitcoind;
|
||||
struct command;
|
||||
struct lightningd_state;
|
||||
struct lightningd;
|
||||
struct peer;
|
||||
struct sha256_double;
|
||||
struct txwatch;
|
||||
@ -148,7 +148,7 @@ void broadcast_tx(struct chain_topology *topo,
|
||||
const char *err));
|
||||
|
||||
struct chain_topology *new_topology(const tal_t *ctx, struct log *log);
|
||||
void setup_topology(struct chain_topology *topology, struct bitcoind *bitcoind,
|
||||
void setup_topology(struct chain_topology *topology,
|
||||
struct timers *timers,
|
||||
struct timerel poll_time, u32 first_peer_block);
|
||||
|
||||
|
||||
@ -37,7 +37,6 @@ static bool ping_reply(struct subd *subd, const u8 *msg, const int *fds,
|
||||
static void json_dev_ping(struct command *cmd,
|
||||
const char *buffer, const jsmntok_t *params)
|
||||
{
|
||||
struct lightningd *ld = ld_from_dstate(cmd->dstate);
|
||||
struct peer *peer;
|
||||
u8 *msg;
|
||||
jsmntok_t *peeridtok, *lentok, *pongbytestok;
|
||||
@ -52,7 +51,7 @@ static void json_dev_ping(struct command *cmd,
|
||||
return;
|
||||
}
|
||||
|
||||
peer = peer_from_json(ld, buffer, peeridtok);
|
||||
peer = peer_from_json(cmd->ld, buffer, peeridtok);
|
||||
if (!peer) {
|
||||
command_fail(cmd, "Could not find peer with that peerid");
|
||||
return;
|
||||
|
||||
@ -16,11 +16,11 @@
|
||||
#include <sys/wait.h>
|
||||
|
||||
struct dns_async {
|
||||
struct lightningd_state *dstate;
|
||||
struct io_plan *(*init)(struct io_conn *, struct lightningd_state *,
|
||||
struct lightningd *ld;
|
||||
struct io_plan *(*init)(struct io_conn *, struct lightningd *,
|
||||
const struct netaddr *,
|
||||
void *);
|
||||
void (*fail)(struct lightningd_state *, void *arg);
|
||||
void (*fail)(struct lightningd *, void *arg);
|
||||
const char *name;
|
||||
void *arg;
|
||||
int pid;
|
||||
@ -77,7 +77,7 @@ static struct io_plan *connected(struct io_conn *conn, struct dns_async *d)
|
||||
/* No longer need to try more connections via connect_failed. */
|
||||
io_set_finish(conn, NULL, NULL);
|
||||
|
||||
plan = d->init(conn, d->dstate, &d->addresses[-1], d->arg);
|
||||
plan = d->init(conn, d->ld, &d->addresses[-1], d->arg);
|
||||
tal_free(d);
|
||||
|
||||
return plan;
|
||||
@ -116,7 +116,7 @@ static void try_connect_one(struct dns_async *d)
|
||||
|
||||
/* Now we can warn if it's overlength */
|
||||
if (a->addrlen > sizeof(a->saddr)) {
|
||||
log_broken(d->dstate->base_log,
|
||||
log_broken(d->ld->log,
|
||||
"DNS lookup gave overlength address for %s"
|
||||
" for family %u, len=%u",
|
||||
d->name, a->saddr.s.sa_family, a->addrlen);
|
||||
@ -124,7 +124,7 @@ static void try_connect_one(struct dns_async *d)
|
||||
/* Might not even be able to create eg. IPv6 sockets */
|
||||
fd = socket(a->saddr.s.sa_family, a->type, a->protocol);
|
||||
if (fd >= 0) {
|
||||
io_new_conn(d->dstate, fd, init_conn, d);
|
||||
io_new_conn(d->ld, fd, init_conn, d);
|
||||
return;
|
||||
}
|
||||
}
|
||||
@ -135,7 +135,7 @@ static void try_connect_one(struct dns_async *d)
|
||||
}
|
||||
|
||||
/* We're out of things to try. Fail. */
|
||||
d->fail(d->dstate, d->arg);
|
||||
d->fail(d->ld, d->arg);
|
||||
tal_free(d);
|
||||
}
|
||||
|
||||
@ -154,18 +154,18 @@ static struct io_plan *start_connecting(struct io_conn *conn,
|
||||
return io_close(conn);
|
||||
}
|
||||
|
||||
struct dns_async *multiaddress_connect_(struct lightningd_state *dstate,
|
||||
struct dns_async *multiaddress_connect_(struct lightningd *ld,
|
||||
const struct netaddr *addresses,
|
||||
struct io_plan *(*init)(struct io_conn *,
|
||||
struct lightningd_state *,
|
||||
struct lightningd *,
|
||||
const struct netaddr *,
|
||||
void *arg),
|
||||
void (*fail)(struct lightningd_state *, void *arg),
|
||||
void (*fail)(struct lightningd *, void *arg),
|
||||
void *arg)
|
||||
{
|
||||
struct dns_async *d = tal(dstate, struct dns_async);
|
||||
struct dns_async *d = tal(ld, struct dns_async);
|
||||
|
||||
d->dstate = dstate;
|
||||
d->ld = ld;
|
||||
d->init = init;
|
||||
d->fail = fail;
|
||||
d->arg = arg;
|
||||
@ -194,24 +194,24 @@ static struct io_plan *init_dns_conn(struct io_conn *conn, struct dns_async *d)
|
||||
static void dns_lookup_failed(struct io_conn *conn, struct dns_async *d)
|
||||
{
|
||||
waitpid(d->pid, NULL, 0);
|
||||
d->fail(d->dstate, d->arg);
|
||||
d->fail(d->ld, d->arg);
|
||||
tal_free(d);
|
||||
}
|
||||
|
||||
struct dns_async *dns_resolve_and_connect_(struct lightningd_state *dstate,
|
||||
struct dns_async *dns_resolve_and_connect_(struct lightningd *ld,
|
||||
const char *name, const char *port,
|
||||
struct io_plan *(*init)(struct io_conn *,
|
||||
struct lightningd_state *,
|
||||
struct lightningd *,
|
||||
const struct netaddr *,
|
||||
void *arg),
|
||||
void (*fail)(struct lightningd_state *, void *arg),
|
||||
void (*fail)(struct lightningd *, void *arg),
|
||||
void *arg)
|
||||
{
|
||||
int pfds[2];
|
||||
struct dns_async *d = tal(dstate, struct dns_async);
|
||||
struct dns_async *d = tal(ld, struct dns_async);
|
||||
struct io_conn *conn;
|
||||
|
||||
d->dstate = dstate;
|
||||
d->ld = ld;
|
||||
d->init = init;
|
||||
d->fail = fail;
|
||||
d->arg = arg;
|
||||
@ -219,7 +219,7 @@ struct dns_async *dns_resolve_and_connect_(struct lightningd_state *dstate,
|
||||
|
||||
/* First fork child to get addresses. */
|
||||
if (pipe(pfds) != 0) {
|
||||
log_unusual(dstate->base_log,
|
||||
log_unusual(ld->log,
|
||||
"Creating pipes for dns lookup: %s",
|
||||
strerror(errno));
|
||||
return NULL;
|
||||
@ -229,7 +229,7 @@ struct dns_async *dns_resolve_and_connect_(struct lightningd_state *dstate,
|
||||
d->pid = fork();
|
||||
switch (d->pid) {
|
||||
case -1:
|
||||
log_unusual(dstate->base_log, "forking for dns lookup: %s",
|
||||
log_unusual(ld->log, "forking for dns lookup: %s",
|
||||
strerror(errno));
|
||||
close(pfds[0]);
|
||||
close(pfds[1]);
|
||||
@ -241,7 +241,7 @@ struct dns_async *dns_resolve_and_connect_(struct lightningd_state *dstate,
|
||||
}
|
||||
|
||||
close(pfds[1]);
|
||||
conn = io_new_conn(dstate, pfds[0], init_dns_conn, d);
|
||||
conn = io_new_conn(ld, pfds[0], init_dns_conn, d);
|
||||
io_set_finish(conn, dns_lookup_failed, d);
|
||||
return d;
|
||||
}
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
#include <ccan/typesafe_cb/typesafe_cb.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
struct lightningd_state;
|
||||
struct lightningd;
|
||||
struct netaddr;
|
||||
|
||||
#define dns_resolve_and_connect(dstate, name, port, initfn, failfn, arg) \
|
||||
@ -14,19 +14,19 @@ struct netaddr;
|
||||
typesafe_cb_preargs(struct io_plan *, void *, \
|
||||
(initfn), (arg), \
|
||||
struct io_conn *, \
|
||||
struct lightningd_state *, \
|
||||
struct lightningd *, \
|
||||
const struct netaddr *), \
|
||||
typesafe_cb_preargs(void, void *, (failfn), (arg), \
|
||||
struct lightningd_state *), \
|
||||
struct lightningd *), \
|
||||
(arg))
|
||||
|
||||
struct dns_async *dns_resolve_and_connect_(struct lightningd_state *dstate,
|
||||
struct dns_async *dns_resolve_and_connect_(struct lightningd *ld,
|
||||
const char *name, const char *port,
|
||||
struct io_plan *(*init)(struct io_conn *,
|
||||
struct lightningd_state *,
|
||||
struct lightningd *,
|
||||
const struct netaddr *,
|
||||
void *arg),
|
||||
void (*fail)(struct lightningd_state *, void *arg),
|
||||
void (*fail)(struct lightningd *, void *arg),
|
||||
void *arg);
|
||||
|
||||
/* Don't do lookup, just try to connect to these addresses. */
|
||||
@ -35,19 +35,19 @@ struct dns_async *dns_resolve_and_connect_(struct lightningd_state *dstate,
|
||||
typesafe_cb_preargs(struct io_plan *, void *, \
|
||||
(initfn), (arg), \
|
||||
struct io_conn *, \
|
||||
struct lightningd_state *, \
|
||||
struct lightningd *, \
|
||||
const struct netaddr *), \
|
||||
typesafe_cb_preargs(void, void *, (failfn), (arg), \
|
||||
struct lightningd_state *), \
|
||||
struct lightningd *), \
|
||||
(arg))
|
||||
|
||||
struct dns_async *multiaddress_connect_(struct lightningd_state *dstate,
|
||||
struct dns_async *multiaddress_connect_(struct lightningd *ld,
|
||||
const struct netaddr *addresses,
|
||||
struct io_plan *(*init)(struct io_conn *,
|
||||
struct lightningd_state *,
|
||||
struct lightningd *,
|
||||
const struct netaddr *,
|
||||
void *arg),
|
||||
void (*fail)(struct lightningd_state *, void *arg),
|
||||
void (*fail)(struct lightningd *, void *arg),
|
||||
void *arg);
|
||||
|
||||
#endif /* LIGHTNING_LIGHTNINGD_DNS_H */
|
||||
|
||||
@ -77,8 +77,6 @@ size_t node_map_hash_key(const secp256k1_pubkey *key);
|
||||
bool node_map_node_eq(const struct node *n, const secp256k1_pubkey *key);
|
||||
HTABLE_DEFINE_TYPE(struct node, node_map_keyof_node, node_map_hash_key, node_map_node_eq, node_map);
|
||||
|
||||
struct lightningd_state;
|
||||
|
||||
struct routing_state {
|
||||
/* All known nodes. */
|
||||
struct node_map *nodes;
|
||||
|
||||
@ -151,7 +151,7 @@ void gossip_init(struct lightningd *ld)
|
||||
err(1, "Could not subdaemon gossip");
|
||||
|
||||
init = towire_gossipctl_init(tmpctx, ld->broadcast_interval,
|
||||
&ld->chainparams->genesis_blockhash);
|
||||
&get_chainparams(ld)->genesis_blockhash);
|
||||
subd_send_msg(ld->gossip, init);
|
||||
tal_free(tmpctx);
|
||||
}
|
||||
@ -191,9 +191,8 @@ static bool json_getnodes_reply(struct subd *gossip, const u8 *reply,
|
||||
static void json_getnodes(struct command *cmd, const char *buffer,
|
||||
const jsmntok_t *params)
|
||||
{
|
||||
struct lightningd *ld = ld_from_dstate(cmd->dstate);
|
||||
u8 *req = towire_gossip_getnodes_request(cmd);
|
||||
subd_req(cmd, ld->gossip, req, -1, 0, json_getnodes_reply, cmd);
|
||||
subd_req(cmd, cmd->ld->gossip, req, -1, 0, json_getnodes_reply, cmd);
|
||||
}
|
||||
|
||||
static const struct json_command getnodes_command = {
|
||||
@ -239,7 +238,8 @@ static void json_getroute(struct command *cmd, const char *buffer, const jsmntok
|
||||
jsmntok_t *idtok, *msatoshitok, *riskfactortok;
|
||||
u64 msatoshi;
|
||||
double riskfactor;
|
||||
struct lightningd *ld = ld_from_dstate(cmd->dstate);
|
||||
struct lightningd *ld = cmd->ld;
|
||||
|
||||
if (!json_get_params(buffer, params,
|
||||
"id", &idtok,
|
||||
"msatoshi", &msatoshitok,
|
||||
@ -268,7 +268,7 @@ static void json_getroute(struct command *cmd, const char *buffer, const jsmntok
|
||||
buffer + riskfactortok->start);
|
||||
return;
|
||||
}
|
||||
u8 *req = towire_gossip_getroute_request(cmd, &cmd->dstate->id, &id, msatoshi, riskfactor*1000);
|
||||
u8 *req = towire_gossip_getroute_request(cmd, &ld->id, &id, msatoshi, riskfactor*1000);
|
||||
subd_req(ld->gossip, ld->gossip, req, -1, 0, json_getroute_reply, cmd);
|
||||
}
|
||||
|
||||
@ -322,9 +322,9 @@ static bool json_getchannels_reply(struct subd *gossip, const u8 *reply,
|
||||
static void json_getchannels(struct command *cmd, const char *buffer,
|
||||
const jsmntok_t *params)
|
||||
{
|
||||
struct lightningd *ld = ld_from_dstate(cmd->dstate);
|
||||
u8 *req = towire_gossip_getchannels_request(cmd);
|
||||
subd_req(ld->gossip, ld->gossip, req, -1, 0, json_getchannels_reply, cmd);
|
||||
subd_req(cmd->ld->gossip, cmd->ld->gossip,
|
||||
req, -1, 0, json_getchannels_reply, cmd);
|
||||
}
|
||||
|
||||
static const struct json_command getchannels_command = {
|
||||
|
||||
@ -48,15 +48,13 @@ void hsm_init(struct lightningd *ld, bool newdir)
|
||||
if (!wire_sync_write(ld->hsm_fd, towire_hsmctl_init(tmpctx, create)))
|
||||
err(1, "Writing init msg to hsm");
|
||||
|
||||
ld->bip32_base = tal(ld, struct ext_key);
|
||||
ld->wallet->bip32_base = tal(ld->wallet, struct ext_key);
|
||||
msg = hsm_sync_read(tmpctx, ld);
|
||||
if (!fromwire_hsmctl_init_reply(msg, NULL,
|
||||
&ld->dstate.id,
|
||||
&ld->id,
|
||||
&ld->peer_seed,
|
||||
ld->bip32_base))
|
||||
ld->wallet->bip32_base))
|
||||
errx(1, "HSM did not give init reply");
|
||||
|
||||
/* FIXME... */
|
||||
ld->wallet->bip32_base = ld->bip32_base;
|
||||
tal_free(tmpctx);
|
||||
}
|
||||
|
||||
@ -102,18 +102,18 @@ static void tell_waiter(struct command *cmd, const struct invoice *paid)
|
||||
}
|
||||
|
||||
/* UNIFICATION FIXME */
|
||||
void db_resolve_invoice(struct lightningd_state *dstate,
|
||||
void db_resolve_invoice(struct lightningd *ld,
|
||||
const char *label, u64 paid_num);
|
||||
bool db_new_invoice(struct lightningd_state *dstate,
|
||||
bool db_new_invoice(struct lightningd *ld,
|
||||
u64 msatoshi,
|
||||
const char *label,
|
||||
const struct preimage *r);
|
||||
bool db_remove_invoice(struct lightningd_state *dstate, const char *label);
|
||||
bool db_remove_invoice(struct lightningd *ld, const char *label);
|
||||
|
||||
void resolve_invoice(struct lightningd_state *dstate, struct invoice *invoice)
|
||||
void resolve_invoice(struct lightningd *ld, struct invoice *invoice)
|
||||
{
|
||||
struct invoice_waiter *w;
|
||||
struct invoices *invs = dstate->invoices;
|
||||
struct invoices *invs = ld->invoices;
|
||||
|
||||
invoice->paid_num = ++invs->invoices_completed;
|
||||
list_del_from(&invs->unpaid, &invoice->list);
|
||||
@ -125,7 +125,7 @@ void resolve_invoice(struct lightningd_state *dstate, struct invoice *invoice)
|
||||
list)) != NULL)
|
||||
tell_waiter(w->cmd, invoice);
|
||||
|
||||
db_resolve_invoice(dstate, invoice->label, invoice->paid_num);
|
||||
db_resolve_invoice(ld, invoice->label, invoice->paid_num);
|
||||
}
|
||||
|
||||
static void json_invoice(struct command *cmd,
|
||||
@ -134,7 +134,7 @@ static void json_invoice(struct command *cmd,
|
||||
struct invoice *invoice;
|
||||
jsmntok_t *msatoshi, *r, *label;
|
||||
struct json_result *response = new_json_result(cmd);
|
||||
struct invoices *invs = cmd->dstate->invoices;
|
||||
struct invoices *invs = cmd->ld->invoices;
|
||||
|
||||
if (!json_get_params(buffer, params,
|
||||
"amount", &msatoshi,
|
||||
@ -187,7 +187,7 @@ static void json_invoice(struct command *cmd,
|
||||
}
|
||||
invoice->paid_num = 0;
|
||||
|
||||
if (!db_new_invoice(cmd->dstate, invoice->msatoshi, invoice->label,
|
||||
if (!db_new_invoice(cmd->ld, invoice->msatoshi, invoice->label,
|
||||
&invoice->r)) {
|
||||
command_fail(cmd, "database error");
|
||||
return;
|
||||
@ -238,7 +238,7 @@ static void json_listinvoice(struct command *cmd,
|
||||
{
|
||||
jsmntok_t *label = NULL;
|
||||
struct json_result *response = new_json_result(cmd);
|
||||
struct invoices *invs = cmd->dstate->invoices;
|
||||
struct invoices *invs = cmd->ld->invoices;
|
||||
|
||||
if (!json_get_params(buffer, params,
|
||||
"?label", &label,
|
||||
@ -270,7 +270,7 @@ static void json_delinvoice(struct command *cmd,
|
||||
jsmntok_t *labeltok;
|
||||
struct json_result *response = new_json_result(cmd);
|
||||
const char *label;
|
||||
struct invoices *invs = cmd->dstate->invoices;
|
||||
struct invoices *invs = cmd->ld->invoices;
|
||||
|
||||
if (!json_get_params(buffer, params,
|
||||
"label", &labeltok,
|
||||
@ -286,7 +286,7 @@ static void json_delinvoice(struct command *cmd,
|
||||
command_fail(cmd, "Unknown invoice");
|
||||
return;
|
||||
}
|
||||
if (!db_remove_invoice(cmd->dstate, i->label)) {
|
||||
if (!db_remove_invoice(cmd->ld, i->label)) {
|
||||
command_fail(cmd, "Database error");
|
||||
return;
|
||||
}
|
||||
@ -316,7 +316,7 @@ static void json_waitanyinvoice(struct command *cmd,
|
||||
jsmntok_t *labeltok;
|
||||
const char *label = NULL;
|
||||
struct invoice_waiter *w;
|
||||
struct invoices *invs = cmd->dstate->invoices;
|
||||
struct invoices *invs = cmd->ld->invoices;
|
||||
|
||||
if (!json_get_params(buffer, params,
|
||||
"?label", &labeltok,
|
||||
@ -372,7 +372,7 @@ static void json_waitinvoice(struct command *cmd,
|
||||
jsmntok_t *labeltok;
|
||||
const char *label = NULL;
|
||||
struct invoice_waiter *w;
|
||||
struct invoices *invs = cmd->dstate->invoices;
|
||||
struct invoices *invs = cmd->ld->invoices;
|
||||
|
||||
if (!json_get_params(buffer, params, "label", &labeltok, NULL)) {
|
||||
command_fail(cmd, "Missing {label}");
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
#include <ccan/tal/tal.h>
|
||||
|
||||
struct invoices;
|
||||
struct lightningd_state;
|
||||
struct lightningd;
|
||||
|
||||
struct invoice {
|
||||
struct list_node list;
|
||||
@ -27,7 +27,7 @@ void invoice_add(struct invoices *i,
|
||||
const char *label,
|
||||
u64 complete);
|
||||
|
||||
void resolve_invoice(struct lightningd_state *dstate, struct invoice *invoice);
|
||||
void resolve_invoice(struct lightningd *ld, struct invoice *invoice);
|
||||
|
||||
struct invoice *find_unpaid(struct invoices *i,
|
||||
const struct sha256 *rhash);
|
||||
|
||||
@ -136,7 +136,7 @@ static void json_getlog(struct command *cmd,
|
||||
const char *buffer, const jsmntok_t *params)
|
||||
{
|
||||
struct log_info info;
|
||||
struct log_book *lr = cmd->dstate->log_book;
|
||||
struct log_book *lr = cmd->ld->log_book;
|
||||
jsmntok_t *level;
|
||||
|
||||
json_get_params(buffer, params, "?level", &level, NULL);
|
||||
@ -237,15 +237,14 @@ static void json_getinfo(struct command *cmd,
|
||||
struct json_result *response = new_json_result(cmd);
|
||||
|
||||
json_object_start(response, NULL);
|
||||
json_add_pubkey(response, "id", &cmd->dstate->id);
|
||||
json_add_pubkey(response, "id", &cmd->ld->id);
|
||||
/* FIXME: Keep netaddrs and list them all. */
|
||||
if (cmd->dstate->portnum)
|
||||
json_add_num(response, "port", cmd->dstate->portnum);
|
||||
if (cmd->ld->portnum)
|
||||
json_add_num(response, "port", cmd->ld->portnum);
|
||||
json_add_string(response, "network",
|
||||
ld_from_dstate(cmd->dstate)->chainparams->network_name);
|
||||
get_chainparams(cmd->ld)->network_name);
|
||||
json_add_string(response, "version", version());
|
||||
json_add_num(response, "blockheight",
|
||||
get_block_height(cmd->dstate->topology));
|
||||
json_add_num(response, "blockheight", get_block_height(cmd->ld->topology));
|
||||
json_object_end(response);
|
||||
command_success(cmd, response);
|
||||
}
|
||||
@ -377,7 +376,7 @@ void command_success(struct command *cmd, struct json_result *result)
|
||||
struct json_connection *jcon = cmd->jcon;
|
||||
|
||||
if (!jcon) {
|
||||
log_unusual(cmd->dstate->base_log,
|
||||
log_unusual(cmd->ld->log,
|
||||
"Command returned result after jcon close");
|
||||
tal_free(cmd);
|
||||
return;
|
||||
@ -395,7 +394,7 @@ void command_fail(struct command *cmd, const char *fmt, ...)
|
||||
va_list ap;
|
||||
|
||||
if (!jcon) {
|
||||
log_unusual(cmd->dstate->base_log,
|
||||
log_unusual(cmd->ld->log,
|
||||
"Command failed after jcon close");
|
||||
tal_free(cmd);
|
||||
return;
|
||||
@ -454,9 +453,9 @@ static void parse_request(struct json_connection *jcon, const jsmntok_t tok[])
|
||||
|
||||
/* This is a convenient tal parent for durarion of command
|
||||
* (which may outlive the conn!). */
|
||||
jcon->current = tal(jcon->dstate, struct command);
|
||||
jcon->current = tal(jcon->ld, struct command);
|
||||
jcon->current->jcon = jcon;
|
||||
jcon->current->dstate = jcon->dstate;
|
||||
jcon->current->ld = jcon->ld;
|
||||
jcon->current->id = tal_strndup(jcon->current,
|
||||
json_tok_contents(jcon->buffer, id),
|
||||
json_tok_len(id));
|
||||
@ -499,7 +498,7 @@ static struct io_plan *write_json(struct io_conn *conn,
|
||||
if (jcon->stop) {
|
||||
log_unusual(jcon->log, "JSON-RPC shutdown");
|
||||
/* Return us to toplevel lightningd.c */
|
||||
io_break(jcon->dstate);
|
||||
io_break(jcon->ld);
|
||||
return io_close(conn);
|
||||
}
|
||||
|
||||
@ -533,7 +532,7 @@ again:
|
||||
toks = json_parse_input(jcon->buffer, jcon->used, &valid);
|
||||
if (!toks) {
|
||||
if (!valid) {
|
||||
log_unusual(jcon->dstate->base_log,
|
||||
log_unusual(jcon->ld->log,
|
||||
"Invalid token in json input: '%.*s'",
|
||||
(int)jcon->used, jcon->buffer);
|
||||
return io_close(conn);
|
||||
@ -573,18 +572,18 @@ read_more:
|
||||
}
|
||||
|
||||
static struct io_plan *jcon_connected(struct io_conn *conn,
|
||||
struct lightningd_state *dstate)
|
||||
struct lightningd *ld)
|
||||
{
|
||||
struct json_connection *jcon;
|
||||
|
||||
jcon = tal(dstate, struct json_connection);
|
||||
jcon->dstate = dstate;
|
||||
jcon = tal(ld, struct json_connection);
|
||||
jcon->ld = ld;
|
||||
jcon->used = 0;
|
||||
jcon->buffer = tal_arr(jcon, char, 64);
|
||||
jcon->stop = false;
|
||||
jcon->current = NULL;
|
||||
jcon->log = new_log(jcon, dstate->log_book, "%sjcon fd %i:",
|
||||
log_prefix(dstate->base_log), io_conn_fd(conn));
|
||||
jcon->log = new_log(jcon, ld->log_book, "%sjcon fd %i:",
|
||||
log_prefix(ld->log), io_conn_fd(conn));
|
||||
list_head_init(&jcon->output);
|
||||
|
||||
io_set_finish(conn, finish_jcon, jcon);
|
||||
@ -597,13 +596,13 @@ static struct io_plan *jcon_connected(struct io_conn *conn,
|
||||
}
|
||||
|
||||
static struct io_plan *incoming_jcon_connected(struct io_conn *conn,
|
||||
struct lightningd_state *dstate)
|
||||
struct lightningd *ld)
|
||||
{
|
||||
log_info(dstate->base_log, "Connected json input");
|
||||
return jcon_connected(conn, dstate);
|
||||
log_info(ld->log, "Connected json input");
|
||||
return jcon_connected(conn, ld);
|
||||
}
|
||||
|
||||
void setup_jsonrpc(struct lightningd_state *dstate, const char *rpc_filename)
|
||||
void setup_jsonrpc(struct lightningd *ld, const char *rpc_filename)
|
||||
{
|
||||
struct sockaddr_un addr;
|
||||
int fd, old_umask;
|
||||
@ -615,7 +614,7 @@ void setup_jsonrpc(struct lightningd_state *dstate, const char *rpc_filename)
|
||||
fd = open(rpc_filename, O_RDWR);
|
||||
if (fd == -1)
|
||||
err(1, "Opening %s", rpc_filename);
|
||||
io_new_conn(dstate, fd, jcon_connected, dstate);
|
||||
io_new_conn(ld, fd, jcon_connected, ld);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -639,5 +638,5 @@ void setup_jsonrpc(struct lightningd_state *dstate, const char *rpc_filename)
|
||||
if (listen(fd, 1) != 0)
|
||||
err(1, "Listening on '%s'", rpc_filename);
|
||||
|
||||
io_new_listener(dstate, fd, incoming_jcon_connected, dstate);
|
||||
io_new_listener(ld, fd, incoming_jcon_connected, ld);
|
||||
}
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
* You can allocate off this for temporary objects. */
|
||||
struct command {
|
||||
/* The global state */
|
||||
struct lightningd_state *dstate;
|
||||
struct lightningd *ld;
|
||||
/* The 'id' which we need to include in the response. */
|
||||
const char *id;
|
||||
/* The connection, or NULL if it closed. */
|
||||
@ -18,7 +18,7 @@ struct command {
|
||||
|
||||
struct json_connection {
|
||||
/* The global state */
|
||||
struct lightningd_state *dstate;
|
||||
struct lightningd *ld;
|
||||
|
||||
/* Logging for this json connection. */
|
||||
struct log *log;
|
||||
@ -70,7 +70,7 @@ void json_add_address(struct json_result *response, const char *fieldname,
|
||||
|
||||
|
||||
/* For initialization */
|
||||
void setup_jsonrpc(struct lightningd_state *dstate, const char *rpc_filename);
|
||||
void setup_jsonrpc(struct lightningd *ld, const char *rpc_filename);
|
||||
|
||||
AUTODATA_TYPE(json_command, struct json_command);
|
||||
#endif /* LIGHTNING_LIGHTNINGD_JSONRPC_H */
|
||||
|
||||
@ -4,6 +4,7 @@
|
||||
#include "peer_control.h"
|
||||
#include "subd.h"
|
||||
#include <ccan/array_size/array_size.h>
|
||||
#include <ccan/cast/cast.h>
|
||||
#include <ccan/crypto/hkdf_sha256/hkdf_sha256.h>
|
||||
#include <ccan/err/err.h>
|
||||
#include <ccan/io/fdpass/fdpass.h>
|
||||
@ -30,12 +31,6 @@ char *bitcoin_datadir;
|
||||
|
||||
#define FIXME_IMPLEMENT() errx(1, "FIXME: Implement %s", __func__)
|
||||
|
||||
struct peer *find_peer(struct lightningd_state *dstate, const struct pubkey *id);
|
||||
struct peer *find_peer(struct lightningd_state *dstate, const struct pubkey *id)
|
||||
{
|
||||
FIXME_IMPLEMENT();
|
||||
}
|
||||
|
||||
struct peer *find_peer_by_unique_id(struct lightningd *ld, u64 unique_id)
|
||||
{
|
||||
struct peer *peer;
|
||||
@ -52,19 +47,19 @@ void notify_new_block(struct chain_topology *topo, u32 height)
|
||||
/* FIXME */
|
||||
}
|
||||
|
||||
void db_resolve_invoice(struct lightningd_state *dstate,
|
||||
void db_resolve_invoice(struct lightningd *ld,
|
||||
const char *label, u64 paid_num);
|
||||
void db_resolve_invoice(struct lightningd_state *dstate,
|
||||
void db_resolve_invoice(struct lightningd *ld,
|
||||
const char *label, u64 paid_num)
|
||||
{
|
||||
/* FIXME */
|
||||
}
|
||||
|
||||
bool db_new_invoice(struct lightningd_state *dstate,
|
||||
bool db_new_invoice(struct lightningd *ld,
|
||||
u64 msatoshi,
|
||||
const char *label,
|
||||
const struct preimage *r);
|
||||
bool db_new_invoice(struct lightningd_state *dstate,
|
||||
bool db_new_invoice(struct lightningd *ld,
|
||||
u64 msatoshi,
|
||||
const char *label,
|
||||
const struct preimage *r)
|
||||
@ -73,9 +68,8 @@ bool db_new_invoice(struct lightningd_state *dstate,
|
||||
return true;
|
||||
}
|
||||
|
||||
bool db_remove_invoice(struct lightningd_state *dstate, const char *label);
|
||||
bool db_remove_invoice(struct lightningd_state *dstate,
|
||||
const char *label)
|
||||
bool db_remove_invoice(struct lightningd *ld, const char *label);
|
||||
bool db_remove_invoice(struct lightningd *ld, const char *label)
|
||||
{
|
||||
/* FIXME */
|
||||
return true;
|
||||
@ -91,29 +85,16 @@ static struct lightningd *new_lightningd(const tal_t *ctx)
|
||||
htlc_in_map_init(&ld->htlcs_in);
|
||||
htlc_out_map_init(&ld->htlcs_out);
|
||||
ld->dev_disconnect_fd = -1;
|
||||
ld->dstate.log_book = new_log_book(&ld->dstate, 20*1024*1024,LOG_INFORM);
|
||||
ld->log = ld->dstate.base_log = new_log(&ld->dstate,
|
||||
ld->dstate.log_book,
|
||||
"lightningd(%u):",
|
||||
(int)getpid());
|
||||
ld->log_book = new_log_book(ld, 20*1024*1024, LOG_INFORM);
|
||||
ld->log = new_log(ld, ld->log_book, "lightningd(%u):", (int)getpid());
|
||||
|
||||
list_head_init(&ld->dstate.peers);
|
||||
list_head_init(&ld->dstate.pay_commands);
|
||||
ld->dstate.portnum = DEFAULT_PORT;
|
||||
ld->dstate.testnet = true;
|
||||
timers_init(&ld->dstate.timers, time_mono());
|
||||
list_head_init(&ld->dstate.wallet);
|
||||
list_head_init(&ld->dstate.addresses);
|
||||
ld->dstate.dev_never_routefail = false;
|
||||
ld->dstate.reexec = NULL;
|
||||
ld->dstate.external_ip = NULL;
|
||||
ld->dstate.announce = NULL;
|
||||
ld->topology = ld->dstate.topology = new_topology(ld, ld->log);
|
||||
ld->bitcoind = ld->dstate.bitcoind = new_bitcoind(ld, ld->log);
|
||||
ld->chainparams = chainparams_for_network("testnet");
|
||||
list_head_init(&ld->pay_commands);
|
||||
ld->portnum = DEFAULT_PORT;
|
||||
timers_init(&ld->timers, time_mono());
|
||||
ld->topology = new_topology(ld, ld->log);
|
||||
|
||||
/* FIXME: Move into invoice daemon. */
|
||||
ld->dstate.invoices = invoices_init(&ld->dstate);
|
||||
ld->invoices = invoices_init(ld);
|
||||
return ld;
|
||||
}
|
||||
|
||||
@ -140,7 +121,7 @@ static void test_daemons(const struct lightningd *ld)
|
||||
pid_t pid = pipecmd(&outfd, NULL, &outfd,
|
||||
dpath, "--version", NULL);
|
||||
|
||||
log_debug(ld->dstate.base_log, "testing %s", dpath);
|
||||
log_debug(ld->log, "testing %s", dpath);
|
||||
if (pid == -1)
|
||||
err(1, "Could not run %s", dpath);
|
||||
verstring = grab_fd(ctx, outfd);
|
||||
@ -191,6 +172,12 @@ static void shutdown_subdaemons(struct lightningd *ld)
|
||||
subd_shutdown(p->owner, 0);
|
||||
}
|
||||
|
||||
struct chainparams *get_chainparams(const struct lightningd *ld)
|
||||
{
|
||||
return cast_const(struct chainparams *,
|
||||
ld->topology->bitcoind->chainparams);
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
struct lightningd *ld = new_lightningd(NULL);
|
||||
@ -204,7 +191,7 @@ int main(int argc, char *argv[])
|
||||
/* Figure out where we are first. */
|
||||
ld->daemon_dir = find_my_path(ld, argv[0]);
|
||||
|
||||
register_opts(&ld->dstate);
|
||||
register_opts(ld);
|
||||
opt_register_arg("--dev-debugger=<subdaemon>", opt_subd_debug, NULL,
|
||||
ld, "Wait for gdb attach at start of <subdaemon>");
|
||||
|
||||
@ -220,7 +207,7 @@ int main(int argc, char *argv[])
|
||||
ld->broadcast_interval = 30000;
|
||||
|
||||
/* Handle options and config; move to .lightningd */
|
||||
newdir = handle_opts(&ld->dstate, argc, argv);
|
||||
newdir = handle_opts(ld, argc, argv);
|
||||
|
||||
/* Activate crash log now we're in the right place. */
|
||||
crashlog_activate(ld->log);
|
||||
@ -244,8 +231,9 @@ int main(int argc, char *argv[])
|
||||
gossip_init(ld);
|
||||
|
||||
/* Initialize block topology. */
|
||||
setup_topology(ld->topology, ld->bitcoind, &ld->dstate.timers,
|
||||
ld->dstate.config.poll_time,
|
||||
setup_topology(ld->topology,
|
||||
&ld->timers,
|
||||
ld->config.poll_time,
|
||||
/* FIXME: Load from peers. */
|
||||
0);
|
||||
|
||||
@ -262,7 +250,7 @@ int main(int argc, char *argv[])
|
||||
}
|
||||
|
||||
/* Create RPC socket (if any) */
|
||||
setup_jsonrpc(&ld->dstate, ld->dstate.rpc_filename);
|
||||
setup_jsonrpc(ld, ld->rpc_filename);
|
||||
|
||||
/* Ready for connections from peers. */
|
||||
setup_listeners(ld);
|
||||
@ -274,14 +262,14 @@ int main(int argc, char *argv[])
|
||||
|
||||
for (;;) {
|
||||
struct timer *expired;
|
||||
void *v = io_loop(&ld->dstate.timers, &expired);
|
||||
void *v = io_loop(&ld->timers, &expired);
|
||||
|
||||
/* We use io_break(dstate) to shut down. */
|
||||
if (v == ld)
|
||||
break;
|
||||
|
||||
if (expired)
|
||||
timer_expired(&ld->dstate, expired);
|
||||
timer_expired(ld, expired);
|
||||
}
|
||||
|
||||
shutdown_subdaemons(ld);
|
||||
|
||||
@ -72,85 +72,29 @@ struct config {
|
||||
struct ipaddr ipaddr;
|
||||
};
|
||||
|
||||
/* Here's where the global variables hide! */
|
||||
struct lightningd_state {
|
||||
/* Where all our logging goes. */
|
||||
struct log_book *log_book;
|
||||
struct log *base_log;
|
||||
FILE *logf;
|
||||
struct lightningd {
|
||||
/* The directory to find all the subdaemons. */
|
||||
const char *daemon_dir;
|
||||
|
||||
/* Our config dir, and rpc file */
|
||||
char *config_dir;
|
||||
char *rpc_filename;
|
||||
|
||||
/* Port we're listening on */
|
||||
u16 portnum;
|
||||
|
||||
/* We're on testnet. */
|
||||
bool testnet;
|
||||
|
||||
/* Configuration settings. */
|
||||
struct config config;
|
||||
|
||||
/* The database where we keep our stuff. */
|
||||
struct db *db;
|
||||
|
||||
/* Any pending timers. */
|
||||
struct timers timers;
|
||||
|
||||
/* Cached block topology. */
|
||||
struct chain_topology *topology;
|
||||
|
||||
/* Our peers. */
|
||||
struct list_head peers;
|
||||
|
||||
/* Addresses to contact peers. */
|
||||
struct list_head addresses;
|
||||
|
||||
/* Any outstanding "pay" commands. */
|
||||
struct list_head pay_commands;
|
||||
|
||||
/* Our private key */
|
||||
struct privkey *privkey;
|
||||
/* Log for general stuff. */
|
||||
struct log_book *log_book;
|
||||
struct log *log;
|
||||
|
||||
/* This is us. */
|
||||
struct pubkey id;
|
||||
|
||||
/* Our tame bitcoind. */
|
||||
struct bitcoind *bitcoind;
|
||||
/* Any pending timers. */
|
||||
struct timers timers;
|
||||
|
||||
/* Wallet addresses we maintain. */
|
||||
struct list_head wallet;
|
||||
|
||||
/* Maintained by invoices.c */
|
||||
struct invoices *invoices;
|
||||
|
||||
/* Routing information */
|
||||
struct routing_state *rstate;
|
||||
|
||||
/* For testing: don't fail if we can't route. */
|
||||
bool dev_never_routefail;
|
||||
|
||||
/* Re-exec hack for testing. */
|
||||
char **reexec;
|
||||
|
||||
/* IP/hostname to be announced for incoming connections */
|
||||
char *external_ip;
|
||||
|
||||
/* Announce timer. */
|
||||
struct oneshot *announce;
|
||||
};
|
||||
|
||||
/* FIXME: This is two structures, during the migration from old setup to new */
|
||||
struct lightningd {
|
||||
/* Must be first, since things assume we can tal() off it */
|
||||
struct lightningd_state dstate;
|
||||
|
||||
/* The directory to find all the subdaemons. */
|
||||
const char *daemon_dir;
|
||||
|
||||
/* Log for general stuff. */
|
||||
struct log *log;
|
||||
/* Port we're listening on */
|
||||
u16 portnum;
|
||||
|
||||
/* Bearer of all my secrets. */
|
||||
int hsm_fd;
|
||||
@ -165,12 +109,6 @@ struct lightningd {
|
||||
/* Used to give a unique seed to every peer. */
|
||||
u64 peer_counter;
|
||||
|
||||
/* Public base for bip32 keys, and max we've ever used. */
|
||||
struct ext_key *bip32_base;
|
||||
|
||||
/* Our bitcoind context. */
|
||||
struct bitcoind *bitcoind;
|
||||
|
||||
/* Our chain topology. */
|
||||
struct chain_topology *topology;
|
||||
|
||||
@ -188,7 +126,11 @@ struct lightningd {
|
||||
|
||||
struct wallet *wallet;
|
||||
|
||||
const struct chainparams *chainparams;
|
||||
/* Maintained by invoices.c */
|
||||
struct invoices *invoices;
|
||||
|
||||
/* Any outstanding "pay" commands. */
|
||||
struct list_head pay_commands;
|
||||
};
|
||||
|
||||
/**
|
||||
@ -209,10 +151,6 @@ void derive_peer_seed(struct lightningd *ld, struct privkey *peer_seed,
|
||||
const struct pubkey *peer_id, const u64 channel_id);
|
||||
|
||||
struct peer *find_peer_by_unique_id(struct lightningd *ld, u64 unique_id);
|
||||
/* FIXME */
|
||||
static inline struct lightningd *
|
||||
ld_from_dstate(const struct lightningd_state *dstate)
|
||||
{
|
||||
return container_of(dstate, struct lightningd, dstate);
|
||||
}
|
||||
|
||||
struct chainparams *get_chainparams(const struct lightningd *ld);
|
||||
#endif /* LIGHTNING_LIGHTNINGD_LIGHTNINGD_H */
|
||||
|
||||
@ -7,7 +7,6 @@
|
||||
#include <stdarg.h>
|
||||
|
||||
struct timerel;
|
||||
struct lightningd_state;
|
||||
|
||||
enum log_level {
|
||||
/* Logging all IO. */
|
||||
|
||||
@ -235,10 +235,9 @@ static struct io_plan *hsm_then_handshake(struct io_conn *conn,
|
||||
tal_steal(handshaked, c);
|
||||
|
||||
if (c->known_id) {
|
||||
msg = towire_handshake_initiator(tmpctx, &ld->dstate.id,
|
||||
c->known_id);
|
||||
msg = towire_handshake_initiator(tmpctx, &ld->id, c->known_id);
|
||||
} else {
|
||||
msg = towire_handshake_responder(tmpctx, &ld->dstate.id);
|
||||
msg = towire_handshake_responder(tmpctx, &ld->id);
|
||||
}
|
||||
|
||||
/* Now hand peer request to the handshake daemon: hands it
|
||||
@ -257,12 +256,12 @@ error:
|
||||
}
|
||||
|
||||
struct io_plan *connection_out(struct io_conn *conn,
|
||||
struct lightningd_state *dstate,
|
||||
struct lightningd *ld,
|
||||
const struct netaddr *netaddr,
|
||||
struct connection *c)
|
||||
{
|
||||
c->netaddr = *netaddr;
|
||||
return hsm_then_handshake(conn, ld_from_dstate(dstate), c);
|
||||
return hsm_then_handshake(conn, ld, c);
|
||||
}
|
||||
|
||||
struct io_plan *connection_in(struct io_conn *conn, struct lightningd *ld)
|
||||
|
||||
@ -6,7 +6,6 @@
|
||||
struct command;
|
||||
struct io_conn;
|
||||
struct lightningd;
|
||||
struct lightningd_state;
|
||||
struct netaddr;
|
||||
struct pubkey;
|
||||
|
||||
@ -16,7 +15,7 @@ struct connection *new_connection(const tal_t *ctx,
|
||||
const struct pubkey *known_id);
|
||||
|
||||
struct io_plan *connection_out(struct io_conn *conn,
|
||||
struct lightningd_state *dstate,
|
||||
struct lightningd *dstate,
|
||||
const struct netaddr *netaddr,
|
||||
struct connection *c);
|
||||
|
||||
|
||||
@ -153,11 +153,9 @@ static void opt_show_u16(char buf[OPT_SHOW_LEN], const u16 *u)
|
||||
|
||||
static char *opt_set_network(const char *arg, struct lightningd *ld)
|
||||
{
|
||||
ld->chainparams = chainparams_for_network(arg);
|
||||
if (!ld->chainparams)
|
||||
ld->topology->bitcoind->chainparams = chainparams_for_network(arg);
|
||||
if (!ld->topology->bitcoind->chainparams)
|
||||
return tal_fmt(NULL, "Unknown network name '%s'", arg);
|
||||
ld->dstate.testnet = ld->chainparams->testnet;
|
||||
ld->bitcoind->chainparams = ld->chainparams;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -170,87 +168,84 @@ static void opt_show_network(char buf[OPT_SHOW_LEN],
|
||||
}
|
||||
*/
|
||||
|
||||
static void config_register_opts(struct lightningd_state *dstate)
|
||||
static void config_register_opts(struct lightningd *ld)
|
||||
{
|
||||
opt_register_arg("--locktime-blocks", opt_set_u32, opt_show_u32,
|
||||
&dstate->config.locktime_blocks,
|
||||
&ld->config.locktime_blocks,
|
||||
"Blocks before peer can unilaterally spend funds");
|
||||
opt_register_arg("--max-locktime-blocks", opt_set_u32, opt_show_u32,
|
||||
&dstate->config.locktime_max,
|
||||
&ld->config.locktime_max,
|
||||
"Maximum seconds peer can lock up our funds");
|
||||
opt_register_arg("--anchor-onchain", opt_set_u32, opt_show_u32,
|
||||
&dstate->config.anchor_onchain_wait,
|
||||
&ld->config.anchor_onchain_wait,
|
||||
"Blocks before we give up on pending anchor transaction");
|
||||
opt_register_arg("--anchor-confirms", opt_set_u32, opt_show_u32,
|
||||
&dstate->config.anchor_confirms,
|
||||
&ld->config.anchor_confirms,
|
||||
"Confirmations required for anchor transaction");
|
||||
opt_register_arg("--max-anchor-confirms", opt_set_u32, opt_show_u32,
|
||||
&dstate->config.anchor_confirms_max,
|
||||
&ld->config.anchor_confirms_max,
|
||||
"Maximum confirmations other side can wait for anchor transaction");
|
||||
opt_register_arg("--forever-confirms", opt_set_u32, opt_show_u32,
|
||||
&dstate->config.forever_confirms,
|
||||
&ld->config.forever_confirms,
|
||||
"Confirmations after which we consider a reorg impossible");
|
||||
opt_register_arg("--commit-fee-min=<percent>", opt_set_u32, opt_show_u32,
|
||||
&dstate->config.commitment_fee_min_percent,
|
||||
&ld->config.commitment_fee_min_percent,
|
||||
"Minimum percentage of fee to accept for commitment");
|
||||
opt_register_arg("--commit-fee-max=<percent>", opt_set_u32, opt_show_u32,
|
||||
&dstate->config.commitment_fee_max_percent,
|
||||
&ld->config.commitment_fee_max_percent,
|
||||
"Maximum percentage of fee to accept for commitment (0 for unlimited)");
|
||||
opt_register_arg("--commit-fee=<percent>", opt_set_u32, opt_show_u32,
|
||||
&dstate->config.commitment_fee_percent,
|
||||
&ld->config.commitment_fee_percent,
|
||||
"Percentage of fee to request for their commitment");
|
||||
opt_register_arg("--override-fee-rate", opt_set_u64, opt_show_u64,
|
||||
&dstate->topology->override_fee_rate,
|
||||
&ld->topology->override_fee_rate,
|
||||
"Force a specific rate in satoshis per kb regardless of estimated fees");
|
||||
opt_register_arg("--default-fee-rate", opt_set_u64, opt_show_u64,
|
||||
&dstate->topology->default_fee_rate,
|
||||
&ld->topology->default_fee_rate,
|
||||
"Satoshis per kb if can't estimate fees");
|
||||
opt_register_arg("--min-htlc-expiry", opt_set_u32, opt_show_u32,
|
||||
&dstate->config.min_htlc_expiry,
|
||||
&ld->config.min_htlc_expiry,
|
||||
"Minimum number of blocks to accept an HTLC before expiry");
|
||||
opt_register_arg("--max-htlc-expiry", opt_set_u32, opt_show_u32,
|
||||
&dstate->config.max_htlc_expiry,
|
||||
&ld->config.max_htlc_expiry,
|
||||
"Maximum number of blocks to accept an HTLC before expiry");
|
||||
opt_register_arg("--deadline-blocks", opt_set_u32, opt_show_u32,
|
||||
&dstate->config.deadline_blocks,
|
||||
&ld->config.deadline_blocks,
|
||||
"Number of blocks before HTLC timeout before we drop connection");
|
||||
opt_register_arg("--bitcoind-poll", opt_set_time, opt_show_time,
|
||||
&dstate->config.poll_time,
|
||||
&ld->config.poll_time,
|
||||
"Time between polling for new transactions");
|
||||
opt_register_arg("--commit-time", opt_set_time, opt_show_time,
|
||||
&dstate->config.commit_time,
|
||||
&ld->config.commit_time,
|
||||
"Time after changes before sending out COMMIT");
|
||||
opt_register_arg("--fee-base", opt_set_u32, opt_show_u32,
|
||||
&dstate->config.fee_base,
|
||||
&ld->config.fee_base,
|
||||
"Millisatoshi minimum to charge for HTLC");
|
||||
opt_register_arg("--fee-per-satoshi", opt_set_s32, opt_show_s32,
|
||||
&dstate->config.fee_per_satoshi,
|
||||
&ld->config.fee_per_satoshi,
|
||||
"Microsatoshi fee for every satoshi in HTLC");
|
||||
opt_register_noarg("--disable-irc", opt_set_invbool,
|
||||
&dstate->config.use_irc,
|
||||
&ld->config.use_irc,
|
||||
"Disable IRC peer discovery for routing");
|
||||
|
||||
opt_register_noarg("--ignore-dbversion", opt_set_bool,
|
||||
&dstate->config.db_version_ignore,
|
||||
&ld->config.db_version_ignore,
|
||||
"Continue despite invalid database version (DANGEROUS!)");
|
||||
|
||||
opt_register_arg("--ipaddr", opt_set_ipaddr, NULL,
|
||||
&dstate->config.ipaddr,
|
||||
&ld->config.ipaddr,
|
||||
"Set the IP address (v4 or v6) to announce to the network for incoming connections");
|
||||
|
||||
/* FIXME: Register opt_show_network with the option */
|
||||
opt_register_arg("--network", opt_set_network, NULL,
|
||||
ld_from_dstate(dstate),
|
||||
"Select the network parameters (bitcoin, testnet, "
|
||||
"regtest, or litecoin)");
|
||||
opt_register_early_arg("--network", opt_set_network, NULL, ld,
|
||||
"Select the network parameters (bitcoin, testnet, "
|
||||
"regtest, or litecoin)");
|
||||
}
|
||||
|
||||
static void dev_register_opts(struct lightningd_state *dstate)
|
||||
static void dev_register_opts(struct lightningd *ld)
|
||||
{
|
||||
opt_register_noarg("--dev-no-routefail", opt_set_bool,
|
||||
&dstate->dev_never_routefail, opt_hidden);
|
||||
opt_register_noarg("--dev-no-broadcast", opt_set_bool,
|
||||
&dstate->topology->dev_no_broadcast, opt_hidden);
|
||||
&ld->topology->dev_no_broadcast, opt_hidden);
|
||||
}
|
||||
|
||||
static const struct config testnet_config = {
|
||||
@ -380,22 +375,22 @@ static const struct config mainnet_config = {
|
||||
.ipaddr.type = 0,
|
||||
};
|
||||
|
||||
static void check_config(struct lightningd_state *dstate)
|
||||
static void check_config(struct lightningd *ld)
|
||||
{
|
||||
/* We do this by ensuring it's less than the minimum we would accept. */
|
||||
if (dstate->config.commitment_fee_max_percent != 0
|
||||
&& dstate->config.commitment_fee_max_percent
|
||||
< dstate->config.commitment_fee_min_percent)
|
||||
if (ld->config.commitment_fee_max_percent != 0
|
||||
&& ld->config.commitment_fee_max_percent
|
||||
< ld->config.commitment_fee_min_percent)
|
||||
fatal("Commitment fee invalid min-max %u-%u",
|
||||
dstate->config.commitment_fee_min_percent,
|
||||
dstate->config.commitment_fee_max_percent);
|
||||
ld->config.commitment_fee_min_percent,
|
||||
ld->config.commitment_fee_max_percent);
|
||||
|
||||
if (dstate->config.forever_confirms < 100 && !dstate->testnet)
|
||||
log_unusual(dstate->base_log,
|
||||
if (ld->config.forever_confirms < 100 && !get_chainparams(ld)->testnet)
|
||||
log_unusual(ld->log,
|
||||
"Warning: forever-confirms of %u is less than 100!",
|
||||
dstate->config.forever_confirms);
|
||||
ld->config.forever_confirms);
|
||||
|
||||
if (dstate->config.anchor_confirms == 0)
|
||||
if (ld->config.anchor_confirms == 0)
|
||||
fatal("anchor-confirms must be greater than zero");
|
||||
|
||||
/* FIXME-OLD #2:
|
||||
@ -403,18 +398,18 @@ static void check_config(struct lightningd_state *dstate)
|
||||
* a node MUST estimate the deadline for successful redemption
|
||||
* for each HTLC it offers. A node MUST NOT offer a HTLC
|
||||
* after this deadline */
|
||||
if (dstate->config.deadline_blocks >= dstate->config.min_htlc_expiry)
|
||||
if (ld->config.deadline_blocks >= ld->config.min_htlc_expiry)
|
||||
fatal("Deadline %u can't be more than minimum expiry %u",
|
||||
dstate->config.deadline_blocks,
|
||||
dstate->config.min_htlc_expiry);
|
||||
ld->config.deadline_blocks,
|
||||
ld->config.min_htlc_expiry);
|
||||
}
|
||||
|
||||
static void setup_default_config(struct lightningd_state *dstate)
|
||||
static void setup_default_config(struct lightningd *ld)
|
||||
{
|
||||
if (dstate->testnet)
|
||||
dstate->config = testnet_config;
|
||||
if (get_chainparams(ld)->testnet)
|
||||
ld->config = testnet_config;
|
||||
else
|
||||
dstate->config = mainnet_config;
|
||||
ld->config = mainnet_config;
|
||||
}
|
||||
|
||||
|
||||
@ -444,27 +439,27 @@ static void config_log_stderr_exit(const char *fmt, ...)
|
||||
}
|
||||
|
||||
/* We turn the config file into cmdline arguments. */
|
||||
static void opt_parse_from_config(struct lightningd_state *dstate)
|
||||
static void opt_parse_from_config(struct lightningd *ld)
|
||||
{
|
||||
char *contents, **lines;
|
||||
char **argv;
|
||||
int i, argc;
|
||||
|
||||
contents = grab_file(dstate, "config");
|
||||
contents = grab_file(ld, "config");
|
||||
/* Doesn't have to exist. */
|
||||
if (!contents) {
|
||||
if (errno != ENOENT)
|
||||
fatal("Opening and reading config: %s",
|
||||
strerror(errno));
|
||||
/* Now we can set up defaults, since no config file. */
|
||||
setup_default_config(dstate);
|
||||
setup_default_config(ld);
|
||||
return;
|
||||
}
|
||||
|
||||
lines = tal_strsplit(contents, contents, "\r\n", STR_NO_EMPTY);
|
||||
|
||||
/* We have to keep argv around, since opt will point into it */
|
||||
argv = tal_arr(dstate, char *, argc = 1);
|
||||
argv = tal_arr(ld, char *, argc = 1);
|
||||
argv[0] = "lightning config file";
|
||||
|
||||
for (i = 0; i < tal_count(lines) - 1; i++) {
|
||||
@ -480,13 +475,13 @@ static void opt_parse_from_config(struct lightningd_state *dstate)
|
||||
|
||||
opt_early_parse(argc, argv, config_log_stderr_exit);
|
||||
/* Now we can set up defaults, depending on whether testnet or not */
|
||||
setup_default_config(dstate);
|
||||
setup_default_config(ld);
|
||||
|
||||
opt_parse(&argc, argv, config_log_stderr_exit);
|
||||
tal_free(contents);
|
||||
}
|
||||
|
||||
void register_opts(struct lightningd_state *dstate)
|
||||
void register_opts(struct lightningd *ld)
|
||||
{
|
||||
opt_set_alloc(opt_allocfn, tal_reallocfn, tal_freefn);
|
||||
|
||||
@ -494,21 +489,20 @@ void register_opts(struct lightningd_state *dstate)
|
||||
"\n"
|
||||
"A bitcoin lightning daemon.",
|
||||
"Print this message.");
|
||||
opt_register_arg("--port", opt_set_u16, opt_show_u16, &dstate->portnum,
|
||||
opt_register_arg("--port", opt_set_u16, opt_show_u16, &ld->portnum,
|
||||
"Port to bind to (0 means don't listen)");
|
||||
opt_register_arg("--bitcoin-datadir", opt_set_charp, NULL,
|
||||
&dstate->bitcoind->datadir,
|
||||
&ld->topology->bitcoind->datadir,
|
||||
"-datadir arg for bitcoin-cli");
|
||||
opt_register_logging(dstate->base_log);
|
||||
opt_register_logging(ld->log);
|
||||
opt_register_version();
|
||||
|
||||
configdir_register_opts(dstate,
|
||||
&dstate->config_dir, &dstate->rpc_filename);
|
||||
config_register_opts(dstate);
|
||||
dev_register_opts(dstate);
|
||||
configdir_register_opts(ld, &ld->config_dir, &ld->rpc_filename);
|
||||
config_register_opts(ld);
|
||||
dev_register_opts(ld);
|
||||
}
|
||||
|
||||
bool handle_opts(struct lightningd_state *dstate, int argc, char *argv[])
|
||||
bool handle_opts(struct lightningd *ld, int argc, char *argv[])
|
||||
{
|
||||
bool newdir = false;
|
||||
|
||||
@ -516,27 +510,27 @@ bool handle_opts(struct lightningd_state *dstate, int argc, char *argv[])
|
||||
opt_early_parse(argc, argv, opt_log_stderr_exit);
|
||||
|
||||
/* Move to config dir, to save ourselves the hassle of path manip. */
|
||||
if (chdir(dstate->config_dir) != 0) {
|
||||
log_unusual(dstate->base_log, "Creating lightningd dir %s"
|
||||
if (chdir(ld->config_dir) != 0) {
|
||||
log_unusual(ld->log, "Creating lightningd dir %s"
|
||||
" (because chdir gave %s)",
|
||||
dstate->config_dir, strerror(errno));
|
||||
if (mkdir(dstate->config_dir, 0700) != 0)
|
||||
ld->config_dir, strerror(errno));
|
||||
if (mkdir(ld->config_dir, 0700) != 0)
|
||||
fatal("Could not make directory %s: %s",
|
||||
dstate->config_dir, strerror(errno));
|
||||
if (chdir(dstate->config_dir) != 0)
|
||||
ld->config_dir, strerror(errno));
|
||||
if (chdir(ld->config_dir) != 0)
|
||||
fatal("Could not change directory %s: %s",
|
||||
dstate->config_dir, strerror(errno));
|
||||
ld->config_dir, strerror(errno));
|
||||
newdir = true;
|
||||
}
|
||||
|
||||
/* Now look for config file */
|
||||
opt_parse_from_config(dstate);
|
||||
opt_parse_from_config(ld);
|
||||
|
||||
dstate->config.ipaddr.port = dstate->portnum;
|
||||
ld->config.ipaddr.port = ld->portnum;
|
||||
opt_parse(&argc, argv, opt_log_stderr_exit);
|
||||
if (argc != 1)
|
||||
errx(1, "no arguments accepted");
|
||||
|
||||
check_config(dstate);
|
||||
check_config(ld);
|
||||
return newdir;
|
||||
}
|
||||
|
||||
@ -3,14 +3,14 @@
|
||||
#include "config.h"
|
||||
#include <ccan/tal/tal.h>
|
||||
|
||||
struct lightningd_state;
|
||||
struct lightningd;
|
||||
|
||||
/* You can register additional options *after* this if you want. */
|
||||
void register_opts(struct lightningd_state *dstate);
|
||||
void register_opts(struct lightningd *ld);
|
||||
|
||||
/* After this, we're in the .lightning dir, config file parsed.
|
||||
* If we just created the dir, returns true.
|
||||
*/
|
||||
bool handle_opts(struct lightningd_state *dstate, int argc, char *argv[]);
|
||||
bool handle_opts(struct lightningd *ld, int argc, char *argv[]);
|
||||
|
||||
#endif /* LIGHTNING_LIGHTNINGD_OPTIONS_H */
|
||||
|
||||
@ -131,7 +131,7 @@ static struct pay_command *find_pay_command(struct lightningd *ld,
|
||||
{
|
||||
struct pay_command *pc;
|
||||
|
||||
list_for_each(&ld->dstate.pay_commands, pc, list) {
|
||||
list_for_each(&ld->pay_commands, pc, list) {
|
||||
if (structeq(rhash, &pc->rhash))
|
||||
return pc;
|
||||
}
|
||||
@ -146,7 +146,6 @@ static void pay_command_destroyed(struct pay_command *pc)
|
||||
static void json_sendpay(struct command *cmd,
|
||||
const char *buffer, const jsmntok_t *params)
|
||||
{
|
||||
struct lightningd *ld = ld_from_dstate(cmd->dstate);
|
||||
struct pubkey *ids;
|
||||
jsmntok_t *routetok, *rhashtok;
|
||||
const jsmntok_t *t, *end;
|
||||
@ -189,7 +188,7 @@ static void json_sendpay(struct command *cmd,
|
||||
}
|
||||
|
||||
/* Expiry for HTLCs is absolute. And add one to give some margin. */
|
||||
base_expiry = get_block_height(cmd->dstate->topology) + 1;
|
||||
base_expiry = get_block_height(cmd->ld->topology) + 1;
|
||||
|
||||
end = json_next(routetok);
|
||||
n_hops = 0;
|
||||
@ -267,17 +266,17 @@ static void json_sendpay(struct command *cmd,
|
||||
hop_data[n_hops-1].outgoing_cltv = base_expiry + delay;
|
||||
memset(&hop_data[n_hops-1].channel_id, 0, sizeof(struct short_channel_id));
|
||||
|
||||
pc = find_pay_command(ld, &rhash);
|
||||
pc = find_pay_command(cmd->ld, &rhash);
|
||||
if (pc) {
|
||||
log_debug(ld->log, "json_sendpay: found previous");
|
||||
log_debug(cmd->ld->log, "json_sendpay: found previous");
|
||||
if (pc->out) {
|
||||
log_add(ld->log, "... still in progress");
|
||||
log_add(cmd->ld->log, "... still in progress");
|
||||
command_fail(cmd, "still in progress");
|
||||
return;
|
||||
}
|
||||
if (pc->rval) {
|
||||
size_t old_nhops = tal_count(pc->ids);
|
||||
log_add(ld->log, "... succeeded");
|
||||
log_add(cmd->ld->log, "... succeeded");
|
||||
/* Must match successful payment parameters. */
|
||||
if (pc->msatoshi != lastamount) {
|
||||
command_fail(cmd,
|
||||
@ -298,10 +297,10 @@ static void json_sendpay(struct command *cmd,
|
||||
return;
|
||||
}
|
||||
/* FIXME: We can free failed ones... */
|
||||
log_add(ld->log, "... retrying");
|
||||
log_add(cmd->ld->log, "... retrying");
|
||||
}
|
||||
|
||||
peer = peer_by_id(ld, &ids[0]);
|
||||
peer = peer_by_id(cmd->ld, &ids[0]);
|
||||
if (!peer) {
|
||||
command_fail(cmd, "no connection to first peer found");
|
||||
return;
|
||||
@ -317,8 +316,8 @@ static void json_sendpay(struct command *cmd,
|
||||
if (pc)
|
||||
pc->ids = tal_free(pc->ids);
|
||||
else {
|
||||
pc = tal(ld, struct pay_command);
|
||||
list_add_tail(&cmd->dstate->pay_commands, &pc->list);
|
||||
pc = tal(cmd->ld, struct pay_command);
|
||||
list_add_tail(&cmd->ld->pay_commands, &pc->list);
|
||||
tal_add_destructor(pc, pay_command_destroyed);
|
||||
}
|
||||
pc->cmd = cmd;
|
||||
@ -328,7 +327,7 @@ static void json_sendpay(struct command *cmd,
|
||||
pc->msatoshi = lastamount;
|
||||
pc->path_secrets = tal_steal(pc, path_secrets);
|
||||
|
||||
log_info(ld->log, "Sending %"PRIu64" over %zu hops to deliver %"PRIu64,
|
||||
log_info(cmd->ld->log, "Sending %"PRIu64" over %zu hops to deliver %"PRIu64,
|
||||
amount, n_hops, lastamount);
|
||||
|
||||
/* Wait until we get response. */
|
||||
|
||||
@ -62,11 +62,10 @@ void peer_debug(struct peer *peer, const char *fmt, ...)
|
||||
/* Mutual recursion, sets timer. */
|
||||
static void peer_reconnect(struct peer *peer);
|
||||
|
||||
static void reconnect_failed(struct lightningd_state *dstate,
|
||||
static void reconnect_failed(struct lightningd *ld,
|
||||
struct connection *c)
|
||||
{
|
||||
/* Figure out what peer, set reconnect timer. */
|
||||
struct lightningd *ld = ld_from_dstate(dstate);
|
||||
struct peer *peer = peer_by_id(ld, connection_known_id(c));
|
||||
|
||||
log_debug(peer->log, "reconnect_failed");
|
||||
@ -94,14 +93,14 @@ static void try_reconnect(struct peer *peer)
|
||||
/* FIXME: Combine known address with gossip addresses and possibly
|
||||
* DNS seed addresses. */
|
||||
addrs = tal_dup_arr(c, struct netaddr, &peer->netaddr, 1, 0);
|
||||
multiaddress_connect(&peer->ld->dstate, addrs,
|
||||
multiaddress_connect(peer->ld, addrs,
|
||||
connection_out, reconnect_failed, c);
|
||||
}
|
||||
|
||||
static void peer_reconnect(struct peer *peer)
|
||||
{
|
||||
new_reltimer(&peer->ld->dstate.timers,
|
||||
peer, peer->ld->dstate.config.poll_time,
|
||||
new_reltimer(&peer->ld->timers,
|
||||
peer, peer->ld->config.poll_time,
|
||||
try_reconnect, peer);
|
||||
}
|
||||
|
||||
@ -574,7 +573,7 @@ void populate_peer(struct lightningd *ld, struct peer *peer)
|
||||
|
||||
/* Max 128k per peer. */
|
||||
peer->log_book = new_log_book(peer, 128*1024,
|
||||
get_log_level(ld->dstate.log_book));
|
||||
get_log_level(ld->log_book));
|
||||
peer->log = new_log(peer, peer->log_book, "peer %s:", idname);
|
||||
set_log_outfn(peer->log_book, copy_to_parent_log, peer);
|
||||
tal_free(idname);
|
||||
@ -735,7 +734,7 @@ void setup_listeners(struct lightningd *ld)
|
||||
socklen_t len;
|
||||
int fd1, fd2;
|
||||
|
||||
if (!ld->dstate.portnum) {
|
||||
if (!ld->portnum) {
|
||||
log_debug(ld->log, "Zero portnum, not listening for incoming");
|
||||
return;
|
||||
}
|
||||
@ -743,12 +742,12 @@ void setup_listeners(struct lightningd *ld)
|
||||
memset(&addr, 0, sizeof(addr));
|
||||
addr.sin_family = AF_INET;
|
||||
addr.sin_addr.s_addr = INADDR_ANY;
|
||||
addr.sin_port = htons(ld->dstate.portnum);
|
||||
addr.sin_port = htons(ld->portnum);
|
||||
|
||||
memset(&addr6, 0, sizeof(addr6));
|
||||
addr6.sin6_family = AF_INET6;
|
||||
addr6.sin6_addr = in6addr_any;
|
||||
addr6.sin6_port = htons(ld->dstate.portnum);
|
||||
addr6.sin6_port = htons(ld->portnum);
|
||||
|
||||
/* IPv6, since on Linux that (usually) binds to IPv4 too. */
|
||||
fd1 = make_listen_fd(ld, AF_INET6, &addr6, sizeof(addr6));
|
||||
@ -763,9 +762,9 @@ void setup_listeners(struct lightningd *ld)
|
||||
fd1 = -1;
|
||||
} else {
|
||||
addr.sin_port = in6.sin6_port;
|
||||
assert(ld->dstate.portnum == ntohs(addr.sin_port));
|
||||
assert(ld->portnum == ntohs(addr.sin_port));
|
||||
log_debug(ld->log, "Creating IPv6 listener on port %u",
|
||||
ld->dstate.portnum);
|
||||
ld->portnum);
|
||||
io_new_listener(ld, fd1, connection_in, ld);
|
||||
}
|
||||
}
|
||||
@ -780,19 +779,19 @@ void setup_listeners(struct lightningd *ld)
|
||||
close_noerr(fd2);
|
||||
fd2 = -1;
|
||||
} else {
|
||||
assert(ld->dstate.portnum == ntohs(addr.sin_port));
|
||||
assert(ld->portnum == ntohs(addr.sin_port));
|
||||
log_debug(ld->log, "Creating IPv4 listener on port %u",
|
||||
ld->dstate.portnum);
|
||||
ld->portnum);
|
||||
io_new_listener(ld, fd2, connection_in, ld);
|
||||
}
|
||||
}
|
||||
|
||||
if (fd1 < 0 && fd2 < 0)
|
||||
fatal("Could not bind to a network address on port %u",
|
||||
ld->dstate.portnum);
|
||||
ld->portnum);
|
||||
}
|
||||
|
||||
static void connect_failed(struct lightningd_state *dstate,
|
||||
static void connect_failed(struct lightningd *ld,
|
||||
struct connection *c)
|
||||
{
|
||||
tal_free(c);
|
||||
@ -801,7 +800,6 @@ static void connect_failed(struct lightningd_state *dstate,
|
||||
static void json_connect(struct command *cmd,
|
||||
const char *buffer, const jsmntok_t *params)
|
||||
{
|
||||
struct lightningd *ld = ld_from_dstate(cmd->dstate);
|
||||
struct connection *c;
|
||||
jsmntok_t *host, *porttok, *idtok;
|
||||
const tal_t *tmpctx = tal_tmpctx(cmd);
|
||||
@ -825,13 +823,13 @@ static void json_connect(struct command *cmd,
|
||||
return;
|
||||
}
|
||||
|
||||
c = new_connection(cmd, ld, cmd, &id);
|
||||
c = new_connection(cmd, cmd->ld, cmd, &id);
|
||||
name = tal_strndup(tmpctx,
|
||||
buffer + host->start, host->end - host->start);
|
||||
port = tal_strndup(tmpctx,
|
||||
buffer + porttok->start,
|
||||
porttok->end - porttok->start);
|
||||
if (!dns_resolve_and_connect(cmd->dstate, name, port,
|
||||
if (!dns_resolve_and_connect(cmd->ld, name, port,
|
||||
connection_out, connect_failed, c)) {
|
||||
command_fail(cmd, "DNS failed");
|
||||
return;
|
||||
@ -851,7 +849,6 @@ AUTODATA(json_command, &connect_command);
|
||||
static void json_dev_fail(struct command *cmd,
|
||||
const char *buffer, const jsmntok_t *params)
|
||||
{
|
||||
struct lightningd *ld = ld_from_dstate(cmd->dstate);
|
||||
jsmntok_t *peertok;
|
||||
struct peer *peer;
|
||||
|
||||
@ -862,7 +859,7 @@ static void json_dev_fail(struct command *cmd,
|
||||
return;
|
||||
}
|
||||
|
||||
peer = peer_from_json(ld, buffer, peertok);
|
||||
peer = peer_from_json(cmd->ld, buffer, peertok);
|
||||
if (!peer) {
|
||||
command_fail(cmd, "Could not find peer with that id");
|
||||
return;
|
||||
@ -903,7 +900,6 @@ static void log_to_json(unsigned int skipped,
|
||||
static void json_getpeers(struct command *cmd,
|
||||
const char *buffer, const jsmntok_t *params)
|
||||
{
|
||||
struct lightningd *ld = ld_from_dstate(cmd->dstate);
|
||||
struct peer *p;
|
||||
struct json_result *response = new_json_result(cmd);
|
||||
jsmntok_t *leveltok;
|
||||
@ -928,7 +924,7 @@ static void json_getpeers(struct command *cmd,
|
||||
|
||||
json_object_start(response, NULL);
|
||||
json_array_start(response, "peers");
|
||||
list_for_each(&ld->peers, p, list) {
|
||||
list_for_each(&cmd->ld->peers, p, list) {
|
||||
json_object_start(response, NULL);
|
||||
json_add_u64(response, "unique_id", p->unique_id);
|
||||
json_add_string(response, "state", peer_state_name(p->state));
|
||||
@ -1207,7 +1203,7 @@ static u8 *p2wpkh_for_keyidx(const tal_t *ctx, struct lightningd *ld, u64 keyidx
|
||||
{
|
||||
struct pubkey shutdownkey;
|
||||
|
||||
if (!bip32_pubkey(ld->bip32_base, &shutdownkey, keyidx))
|
||||
if (!bip32_pubkey(ld->wallet->bip32_base, &shutdownkey, keyidx))
|
||||
return NULL;
|
||||
|
||||
return scriptpubkey_p2wpkh(ctx, &shutdownkey);
|
||||
@ -1259,7 +1255,7 @@ static enum watch_result funding_spent(struct peer *peer,
|
||||
return DELETE_WATCH;
|
||||
}
|
||||
|
||||
if (!bip32_pubkey(peer->ld->bip32_base, &ourkey, keyindex)) {
|
||||
if (!bip32_pubkey(peer->ld->wallet->bip32_base, &ourkey, keyindex)) {
|
||||
peer_internal_error(peer,
|
||||
"Can't get shutdown key %"PRIu64,
|
||||
keyindex);
|
||||
@ -1392,7 +1388,7 @@ static void opening_got_hsm_funding_sig(struct funding_channel *fc,
|
||||
for (i = 0; i < tal_count(tx->input); i++) {
|
||||
struct pubkey key;
|
||||
|
||||
if (!bip32_pubkey(fc->peer->ld->bip32_base,
|
||||
if (!bip32_pubkey(fc->peer->ld->wallet->bip32_base,
|
||||
&key, fc->utxomap[i]->keyindex))
|
||||
fatal("Cannot generate BIP32 key for UTXO %u",
|
||||
fc->utxomap[i]->keyindex);
|
||||
@ -1441,13 +1437,13 @@ static u8 *create_node_announcement(const tal_t *ctx, struct lightningd *ld,
|
||||
sig = tal(ctx, secp256k1_ecdsa_signature);
|
||||
memset(sig, 0, sizeof(*sig));
|
||||
}
|
||||
if (ld->dstate.config.ipaddr.type != ADDR_TYPE_PADDING) {
|
||||
towire_ipaddr(&addresses, &ld->dstate.config.ipaddr);
|
||||
if (ld->config.ipaddr.type != ADDR_TYPE_PADDING) {
|
||||
towire_ipaddr(&addresses, &ld->config.ipaddr);
|
||||
}
|
||||
memset(alias, 0, sizeof(alias));
|
||||
announcement =
|
||||
towire_node_announcement(ctx, sig, features, timestamp,
|
||||
&ld->dstate.id, rgb, alias, addresses);
|
||||
&ld->id, rgb, alias, addresses);
|
||||
return announcement;
|
||||
}
|
||||
|
||||
@ -1938,7 +1934,7 @@ static bool peer_start_channeld(struct peer *peer,
|
||||
const tal_t *tmpctx = tal_tmpctx(peer);
|
||||
u8 *msg, *initmsg;
|
||||
int hsmfd;
|
||||
const struct config *cfg = &peer->ld->dstate.config;
|
||||
const struct config *cfg = &peer->ld->config;
|
||||
struct added_htlc *htlcs;
|
||||
enum htlc_state *htlc_states;
|
||||
struct fulfilled_htlc *fulfilled_htlcs;
|
||||
@ -2010,7 +2006,8 @@ static bool peer_start_channeld(struct peer *peer,
|
||||
num_revocations = revocations_received(&peer->their_shachain.chain);
|
||||
|
||||
initmsg = towire_channel_init(tmpctx,
|
||||
&peer->ld->chainparams->genesis_blockhash,
|
||||
&get_chainparams(peer->ld)
|
||||
->genesis_blockhash,
|
||||
peer->funding_txid,
|
||||
peer->funding_outnum,
|
||||
peer->funding_satoshi,
|
||||
@ -2030,7 +2027,7 @@ static bool peer_start_channeld(struct peer *peer,
|
||||
cfg->fee_per_satoshi,
|
||||
*peer->our_msatoshi,
|
||||
peer->seed,
|
||||
&peer->ld->dstate.id,
|
||||
&peer->ld->id,
|
||||
&peer->id,
|
||||
time_to_msec(cfg->commit_time),
|
||||
cfg->deadline_blocks,
|
||||
@ -2115,7 +2112,7 @@ static bool opening_funder_finished(struct subd *opening, const u8 *resp,
|
||||
|
||||
/* Generate the funding tx. */
|
||||
if (fc->change
|
||||
&& !bip32_pubkey(fc->peer->ld->bip32_base,
|
||||
&& !bip32_pubkey(fc->peer->ld->wallet->bip32_base,
|
||||
&changekey, fc->change_keyindex))
|
||||
fatal("Error deriving change key %u", fc->change_keyindex);
|
||||
|
||||
@ -2126,7 +2123,7 @@ static bool opening_funder_finished(struct subd *opening, const u8 *resp,
|
||||
&local_fundingkey,
|
||||
&channel_info->remote_fundingkey,
|
||||
fc->change, &changekey,
|
||||
fc->peer->ld->bip32_base);
|
||||
fc->peer->ld->wallet->bip32_base);
|
||||
fc->peer->funding_txid = tal(fc->peer, struct sha256_double);
|
||||
bitcoin_txid(fc->funding_tx, fc->peer->funding_txid);
|
||||
|
||||
@ -2253,8 +2250,8 @@ static void channel_config(struct lightningd *ld,
|
||||
u64 *min_effective_htlc_capacity_msat)
|
||||
{
|
||||
/* FIXME: depend on feerate. */
|
||||
*max_to_self_delay = ld->dstate.config.locktime_max;
|
||||
*max_minimum_depth = ld->dstate.config.anchor_confirms_max;
|
||||
*max_to_self_delay = ld->config.locktime_max;
|
||||
*max_minimum_depth = ld->config.anchor_confirms_max;
|
||||
/* This is 1c at $1000/BTC */
|
||||
*min_effective_htlc_capacity_msat = 1000000;
|
||||
|
||||
@ -2276,7 +2273,7 @@ static void channel_config(struct lightningd *ld,
|
||||
* the sender can irreversibly spend a commitment transaction
|
||||
* output in case of misbehavior by the receiver.
|
||||
*/
|
||||
ours->to_self_delay = ld->dstate.config.locktime_blocks;
|
||||
ours->to_self_delay = ld->config.locktime_blocks;
|
||||
|
||||
/* BOLT #2:
|
||||
*
|
||||
@ -2332,7 +2329,7 @@ void peer_fundee_open(struct peer *peer, const u8 *from_peer,
|
||||
* considers reasonable to avoid double-spending of the funding
|
||||
* transaction.
|
||||
*/
|
||||
peer->minimum_depth = ld->dstate.config.anchor_confirms;
|
||||
peer->minimum_depth = ld->config.anchor_confirms;
|
||||
|
||||
channel_config(ld, &peer->our_config,
|
||||
&max_to_self_delay, &max_minimum_depth,
|
||||
@ -2348,7 +2345,7 @@ void peer_fundee_open(struct peer *peer, const u8 *from_peer,
|
||||
peer->seed = tal(peer, struct privkey);
|
||||
derive_peer_seed(ld, peer->seed, &peer->id, peer->channel->id);
|
||||
|
||||
msg = towire_opening_init(peer, ld->chainparams->index,
|
||||
msg = towire_opening_init(peer, get_chainparams(ld)->index,
|
||||
&peer->our_config,
|
||||
max_to_self_delay,
|
||||
min_effective_htlc_capacity_msat,
|
||||
@ -2426,7 +2423,8 @@ static bool gossip_peer_released(struct subd *gossip,
|
||||
|
||||
fc->peer->channel_flags = OUR_CHANNEL_FLAGS;
|
||||
|
||||
msg = towire_opening_init(fc, ld->chainparams->index,
|
||||
msg = towire_opening_init(fc,
|
||||
get_chainparams(ld)->index,
|
||||
&fc->peer->our_config,
|
||||
max_to_self_delay,
|
||||
min_effective_htlc_capacity_msat,
|
||||
@ -2442,7 +2440,7 @@ static bool gossip_peer_released(struct subd *gossip,
|
||||
15000, max_minimum_depth,
|
||||
fc->change, fc->change_keyindex,
|
||||
fc->peer->channel_flags,
|
||||
utxos, fc->peer->ld->bip32_base);
|
||||
utxos, fc->peer->ld->wallet->bip32_base);
|
||||
subd_req(fc, opening, take(msg), -1, 2, opening_funder_finished, fc);
|
||||
return true;
|
||||
}
|
||||
@ -2450,7 +2448,6 @@ static bool gossip_peer_released(struct subd *gossip,
|
||||
static void json_fund_channel(struct command *cmd,
|
||||
const char *buffer, const jsmntok_t *params)
|
||||
{
|
||||
struct lightningd *ld = ld_from_dstate(cmd->dstate);
|
||||
jsmntok_t *peertok, *satoshitok;
|
||||
struct funding_channel *fc = tal(cmd, struct funding_channel);
|
||||
u8 *msg;
|
||||
@ -2464,12 +2461,12 @@ static void json_fund_channel(struct command *cmd,
|
||||
}
|
||||
|
||||
fc->cmd = cmd;
|
||||
fc->peer = peer_from_json(ld, buffer, peertok);
|
||||
fc->peer = peer_from_json(cmd->ld, buffer, peertok);
|
||||
if (!fc->peer) {
|
||||
command_fail(cmd, "Could not find peer with that peerid");
|
||||
return;
|
||||
}
|
||||
if (fc->peer->owner != ld->gossip) {
|
||||
if (fc->peer->owner != cmd->ld->gossip) {
|
||||
command_fail(cmd, "Peer not ready for connection");
|
||||
return;
|
||||
}
|
||||
@ -2484,8 +2481,8 @@ static void json_fund_channel(struct command *cmd,
|
||||
|
||||
/* Try to do this now, so we know if insufficient funds. */
|
||||
/* FIXME: Feerate & dustlimit */
|
||||
fc->utxomap = build_utxos(fc, ld, fc->peer->funding_satoshi, 15000, 600,
|
||||
&fc->change, &fc->change_keyindex);
|
||||
fc->utxomap = build_utxos(fc, cmd->ld, fc->peer->funding_satoshi,
|
||||
15000, 600, &fc->change, &fc->change_keyindex);
|
||||
if (!fc->utxomap) {
|
||||
command_fail(cmd, "Cannot afford funding transaction");
|
||||
return;
|
||||
@ -2496,7 +2493,7 @@ static void json_fund_channel(struct command *cmd,
|
||||
/* Tie this fc lifetime (and hence utxo release) to the peer */
|
||||
tal_steal(fc->peer, fc);
|
||||
tal_add_destructor(fc, fail_fundchannel_command);
|
||||
subd_req(fc, ld->gossip, msg, -1, 2, gossip_peer_released, fc);
|
||||
subd_req(fc, cmd->ld->gossip, msg, -1, 2, gossip_peer_released, fc);
|
||||
}
|
||||
|
||||
static const struct json_command fund_channel_command = {
|
||||
@ -2510,7 +2507,6 @@ AUTODATA(json_command, &fund_channel_command);
|
||||
static void json_close(struct command *cmd,
|
||||
const char *buffer, const jsmntok_t *params)
|
||||
{
|
||||
struct lightningd *ld = ld_from_dstate(cmd->dstate);
|
||||
jsmntok_t *peertok;
|
||||
struct peer *peer;
|
||||
|
||||
@ -2521,7 +2517,7 @@ static void json_close(struct command *cmd,
|
||||
return;
|
||||
}
|
||||
|
||||
peer = peer_from_json(ld, buffer, peertok);
|
||||
peer = peer_from_json(cmd->ld, buffer, peertok);
|
||||
if (!peer) {
|
||||
command_fail(cmd, "Could not find peer with that id");
|
||||
return;
|
||||
|
||||
@ -329,7 +329,7 @@ static void handle_localpay(struct htlc_in *hin,
|
||||
goto fail;
|
||||
}
|
||||
|
||||
invoice = find_unpaid(ld->dstate.invoices, payment_hash);
|
||||
invoice = find_unpaid(ld->invoices, payment_hash);
|
||||
if (!invoice) {
|
||||
failcode = WIRE_UNKNOWN_PAYMENT_HASH;
|
||||
goto fail;
|
||||
@ -357,13 +357,13 @@ static void handle_localpay(struct htlc_in *hin,
|
||||
*
|
||||
* If the `cltv_expiry` is too low, the final node MUST fail the HTLC:
|
||||
*/
|
||||
if (get_block_height(ld->topology) + ld->dstate.config.deadline_blocks
|
||||
if (get_block_height(ld->topology) + ld->config.deadline_blocks
|
||||
>= cltv_expiry) {
|
||||
log_debug(hin->key.peer->log,
|
||||
"Expiry cltv %u too close to current %u + deadline %u",
|
||||
cltv_expiry,
|
||||
get_block_height(ld->topology),
|
||||
ld->dstate.config.deadline_blocks);
|
||||
ld->config.deadline_blocks);
|
||||
failcode = WIRE_FINAL_EXPIRY_TOO_SOON;
|
||||
goto fail;
|
||||
}
|
||||
@ -371,7 +371,7 @@ static void handle_localpay(struct htlc_in *hin,
|
||||
log_info(ld->log, "Resolving invoice '%s' with HTLC %"PRIu64,
|
||||
invoice->label, hin->key.id);
|
||||
fulfill_htlc(hin, &invoice->r);
|
||||
resolve_invoice(&ld->dstate, invoice);
|
||||
resolve_invoice(ld, invoice);
|
||||
return;
|
||||
|
||||
fail:
|
||||
@ -495,19 +495,19 @@ static void forward_htlc(struct htlc_in *hin,
|
||||
* fee_base_msat + amount_msat * fee_proportional_millionths / 1000000
|
||||
*/
|
||||
if (mul_overflows_u64(amt_to_forward,
|
||||
ld->dstate.config.fee_per_satoshi)) {
|
||||
ld->config.fee_per_satoshi)) {
|
||||
failcode = WIRE_FEE_INSUFFICIENT;
|
||||
goto fail;
|
||||
}
|
||||
fee = ld->dstate.config.fee_base
|
||||
+ amt_to_forward * ld->dstate.config.fee_per_satoshi / 1000000;
|
||||
fee = ld->config.fee_base
|
||||
+ amt_to_forward * ld->config.fee_per_satoshi / 1000000;
|
||||
if (!check_amount(hin, amt_to_forward, hin->msatoshi, fee)) {
|
||||
failcode = WIRE_FEE_INSUFFICIENT;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (!check_ctlv(hin, cltv_expiry, outgoing_cltv_value,
|
||||
ld->dstate.config.deadline_blocks)) {
|
||||
ld->config.deadline_blocks)) {
|
||||
failcode = WIRE_INCORRECT_CLTV_EXPIRY;
|
||||
goto fail;
|
||||
}
|
||||
@ -522,12 +522,12 @@ static void forward_htlc(struct htlc_in *hin,
|
||||
* * [`len`:`channel_update`]
|
||||
*/
|
||||
if (get_block_height(next->ld->topology)
|
||||
+ next->ld->dstate.config.deadline_blocks >= outgoing_cltv_value) {
|
||||
+ next->ld->config.deadline_blocks >= outgoing_cltv_value) {
|
||||
log_debug(hin->key.peer->log,
|
||||
"Expiry cltv %u too close to current %u + deadline %u",
|
||||
outgoing_cltv_value,
|
||||
get_block_height(next->ld->topology),
|
||||
next->ld->dstate.config.deadline_blocks);
|
||||
next->ld->config.deadline_blocks);
|
||||
failcode = WIRE_EXPIRY_TOO_SOON;
|
||||
goto fail;
|
||||
}
|
||||
@ -576,7 +576,7 @@ static bool channel_resolve_reply(struct subd *gossip, const u8 *msg,
|
||||
}
|
||||
|
||||
/* Get the other peer matching the id that is not us */
|
||||
if (pubkey_cmp(&nodes[0], &gossip->ld->dstate.id) == 0) {
|
||||
if (pubkey_cmp(&nodes[0], &gossip->ld->id) == 0) {
|
||||
peer_id = &nodes[1];
|
||||
} else {
|
||||
peer_id = &nodes[0];
|
||||
|
||||
@ -429,7 +429,7 @@ struct subd *new_subd(const tal_t *ctx,
|
||||
return tal_free(sd);
|
||||
}
|
||||
sd->ld = ld;
|
||||
sd->log = new_log(sd, ld->dstate.log_book, "%s(%u):", name, sd->pid);
|
||||
sd->log = new_log(sd, ld->log_book, "%s(%u):", name, sd->pid);
|
||||
sd->name = name;
|
||||
sd->finished = finished;
|
||||
sd->msgname = msgname;
|
||||
|
||||
@ -10,7 +10,6 @@
|
||||
|
||||
struct bitcoin_tx;
|
||||
struct block;
|
||||
struct lightningd_state;
|
||||
|
||||
enum watch_result {
|
||||
DELETE_WATCH = -1,
|
||||
|
||||
@ -74,7 +74,7 @@ static void wallet_withdrawal_broadcast(struct bitcoind *bitcoind,
|
||||
struct withdrawal *withdraw)
|
||||
{
|
||||
struct command *cmd = withdraw->cmd;
|
||||
struct lightningd *ld = ld_from_dstate(withdraw->cmd->dstate);
|
||||
struct lightningd *ld = withdraw->cmd->ld;
|
||||
struct bitcoin_tx *tx;
|
||||
u64 change_satoshi = 0;
|
||||
|
||||
@ -112,7 +112,6 @@ static void wallet_withdrawal_broadcast(struct bitcoind *bitcoind,
|
||||
static void json_withdraw(struct command *cmd,
|
||||
const char *buffer, const jsmntok_t *params)
|
||||
{
|
||||
struct lightningd *ld = ld_from_dstate(cmd->dstate);
|
||||
jsmntok_t *desttok, *sattok;
|
||||
struct withdrawal *withdraw;
|
||||
bool testnet;
|
||||
@ -149,7 +148,8 @@ static void json_withdraw(struct command *cmd,
|
||||
}
|
||||
|
||||
/* Select the coins */
|
||||
withdraw->utxos = wallet_select_coins(cmd, ld->wallet, withdraw->amount,
|
||||
withdraw->utxos = wallet_select_coins(cmd, cmd->ld->wallet,
|
||||
withdraw->amount,
|
||||
feerate_per_kw, &fee_estimate,
|
||||
&withdraw->changesatoshi);
|
||||
if (!withdraw->utxos) {
|
||||
@ -161,7 +161,7 @@ static void json_withdraw(struct command *cmd,
|
||||
if (withdraw->changesatoshi <= 546)
|
||||
withdraw->changesatoshi = 0;
|
||||
|
||||
withdraw->change_key_index = wallet_get_newindex(ld);
|
||||
withdraw->change_key_index = wallet_get_newindex(cmd->ld);
|
||||
|
||||
utxos = from_utxoptr_arr(withdraw, withdraw->utxos);
|
||||
u8 *msg = towire_hsmctl_sign_withdrawal(cmd,
|
||||
@ -172,17 +172,18 @@ static void json_withdraw(struct command *cmd,
|
||||
utxos);
|
||||
tal_free(utxos);
|
||||
|
||||
if (!wire_sync_write(ld->hsm_fd, take(msg)))
|
||||
if (!wire_sync_write(cmd->ld->hsm_fd, take(msg)))
|
||||
fatal("Could not write sign_withdrawal to HSM: %s",
|
||||
strerror(errno));
|
||||
|
||||
msg = hsm_sync_read(cmd, ld);
|
||||
msg = hsm_sync_read(cmd, cmd->ld);
|
||||
|
||||
if (!fromwire_hsmctl_sign_withdrawal_reply(withdraw, msg, NULL, &sigs))
|
||||
fatal("HSM gave bad sign_withdrawal_reply %s",
|
||||
tal_hex(withdraw, msg));
|
||||
|
||||
if (bip32_key_from_parent(ld->bip32_base, withdraw->change_key_index,
|
||||
if (bip32_key_from_parent(cmd->ld->wallet->bip32_base,
|
||||
withdraw->change_key_index,
|
||||
BIP32_FLAG_KEY_PUBLIC, &ext) != WALLY_OK) {
|
||||
command_fail(cmd, "Changekey generation failure");
|
||||
return;
|
||||
@ -191,7 +192,7 @@ static void json_withdraw(struct command *cmd,
|
||||
pubkey_from_der(ext.pub_key, sizeof(ext.pub_key), &changekey);
|
||||
tx = withdraw_tx(withdraw, withdraw->utxos, &withdraw->destination,
|
||||
withdraw->amount, &changekey, withdraw->changesatoshi,
|
||||
ld->bip32_base);
|
||||
cmd->ld->wallet->bip32_base);
|
||||
|
||||
if (tal_count(sigs) != tal_count(tx->input))
|
||||
fatal("HSM gave %zu sigs, needed %zu",
|
||||
@ -201,7 +202,7 @@ static void json_withdraw(struct command *cmd,
|
||||
for (size_t i = 0; i < tal_count(tx->input); i++) {
|
||||
struct pubkey key;
|
||||
|
||||
if (!bip32_pubkey(ld->bip32_base,
|
||||
if (!bip32_pubkey(cmd->ld->wallet->bip32_base,
|
||||
&key, withdraw->utxos[i]->keyindex))
|
||||
fatal("Cannot generate BIP32 key for UTXO %u",
|
||||
withdraw->utxos[i]->keyindex);
|
||||
@ -213,7 +214,7 @@ static void json_withdraw(struct command *cmd,
|
||||
|
||||
/* Now broadcast the transaction */
|
||||
withdraw->hextx = tal_hex(withdraw, linearize_tx(cmd, tx));
|
||||
bitcoind_sendrawtx(ld->topology->bitcoind, withdraw->hextx,
|
||||
bitcoind_sendrawtx(cmd->ld->topology->bitcoind, withdraw->hextx,
|
||||
wallet_withdrawal_broadcast, withdraw);
|
||||
}
|
||||
|
||||
@ -229,7 +230,6 @@ static void json_newaddr(struct command *cmd,
|
||||
const char *buffer, const jsmntok_t *params)
|
||||
{
|
||||
struct json_result *response = new_json_result(cmd);
|
||||
struct lightningd *ld = ld_from_dstate(cmd->dstate);
|
||||
struct ext_key ext;
|
||||
struct sha256 h;
|
||||
struct ripemd160 p2sh;
|
||||
@ -237,13 +237,13 @@ static void json_newaddr(struct command *cmd,
|
||||
u8 *redeemscript;
|
||||
s64 keyidx;
|
||||
|
||||
keyidx = wallet_get_newindex(ld);
|
||||
keyidx = wallet_get_newindex(cmd->ld);
|
||||
if (keyidx < 0) {
|
||||
command_fail(cmd, "Keys exhausted ");
|
||||
return;
|
||||
}
|
||||
|
||||
if (bip32_key_from_parent(ld->bip32_base, keyidx,
|
||||
if (bip32_key_from_parent(cmd->ld->wallet->bip32_base, keyidx,
|
||||
BIP32_FLAG_KEY_PUBLIC, &ext) != WALLY_OK) {
|
||||
command_fail(cmd, "Keys generation failure");
|
||||
return;
|
||||
@ -261,7 +261,8 @@ static void json_newaddr(struct command *cmd,
|
||||
|
||||
json_object_start(response, NULL);
|
||||
json_add_string(response, "address",
|
||||
p2sh_to_base58(cmd, cmd->dstate->testnet, &p2sh));
|
||||
p2sh_to_base58(cmd, get_chainparams(cmd->ld)->testnet,
|
||||
&p2sh));
|
||||
json_object_end(response);
|
||||
command_success(cmd, response);
|
||||
}
|
||||
@ -277,7 +278,6 @@ AUTODATA(json_command, &newaddr_command);
|
||||
static void json_addfunds(struct command *cmd,
|
||||
const char *buffer, const jsmntok_t *params)
|
||||
{
|
||||
struct lightningd *ld = ld_from_dstate(cmd->dstate);
|
||||
struct json_result *response = new_json_result(cmd);
|
||||
jsmntok_t *txtok;
|
||||
struct bitcoin_tx *tx;
|
||||
@ -301,7 +301,7 @@ static void json_addfunds(struct command *cmd,
|
||||
|
||||
/* Find an output we know how to spend. */
|
||||
num_utxos =
|
||||
wallet_extract_owned_outputs(ld->wallet, tx, &total_satoshi);
|
||||
wallet_extract_owned_outputs(cmd->ld->wallet, tx, &total_satoshi);
|
||||
if (num_utxos < 0) {
|
||||
command_fail(cmd, "Could not add outputs to wallet");
|
||||
return;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user