From 0bcff1e76d6796e20a26c883ad83bc8fad17efeb Mon Sep 17 00:00:00 2001 From: Rusty Russell Date: Fri, 14 Jul 2023 09:58:46 +0930 Subject: [PATCH] db/bindings: now bindings are always in order, remove index. Simply always bind the next one. No arithmetic required now! Signed-off-by: Rusty Russell --- db/bindings.c | 124 ++--- db/bindings.h | 65 ++- db/exec.c | 12 +- plugins/bkpr/db.c | 4 +- plugins/bkpr/incomestmt.c | 2 +- plugins/bkpr/recorder.c | 212 ++++---- wallet/db.c | 58 +- wallet/invoices.c | 72 +-- wallet/test/run-wallet.c | 2 +- wallet/wallet.c | 1069 ++++++++++++++++++------------------- 10 files changed, 804 insertions(+), 816 deletions(-) diff --git a/db/bindings.c b/db/bindings.c index 1b223e66d..37aac237e 100644 --- a/db/bindings.c +++ b/db/bindings.c @@ -16,18 +16,11 @@ #define NSEC_IN_SEC 1000000000 -static int check_bind_pos(struct db_stmt *stmt, int pos) +static size_t check_bind_pos(struct db_stmt *stmt) { - if (pos == BIND_NEXT) { - /* Don't mix BIND_NEXT with other args! */ - assert(stmt->bindings[stmt->bind_pos+1].type == DB_BINDING_UNINITIALIZED); - return ++stmt->bind_pos; - } - - /* Don't mix BIND_NEXT with other args! */ - assert(stmt->bind_pos == -1); - assert(pos >= 0); + size_t pos = ++stmt->bind_pos; assert(pos < tal_count(stmt->bindings)); + return pos; } @@ -50,9 +43,9 @@ static bool db_column_null_warn(struct db_stmt *stmt, const char *colname, return true; } -void db_bind_int(struct db_stmt *stmt, int pos, int val) +void db_bind_int(struct db_stmt *stmt, int val) { - pos = check_bind_pos(stmt, pos); + size_t pos = check_bind_pos(stmt); memcheck(&val, sizeof(val)); stmt->bindings[pos].type = DB_BINDING_INT; stmt->bindings[pos].v.i = val; @@ -73,58 +66,59 @@ int db_col_is_null(struct db_stmt *stmt, const char *colname) return db_column_is_null(stmt, db_query_colnum(stmt, colname)); } -void db_bind_null(struct db_stmt *stmt, int pos) +void db_bind_null(struct db_stmt *stmt) { - pos = check_bind_pos(stmt, pos); + size_t pos = check_bind_pos(stmt); stmt->bindings[pos].type = DB_BINDING_NULL; } -void db_bind_u64(struct db_stmt *stmt, int pos, u64 val) +void db_bind_u64(struct db_stmt *stmt, u64 val) { + size_t pos = check_bind_pos(stmt); + memcheck(&val, sizeof(val)); - pos = check_bind_pos(stmt, pos); stmt->bindings[pos].type = DB_BINDING_UINT64; stmt->bindings[pos].v.u64 = val; } -void db_bind_blob(struct db_stmt *stmt, int pos, const u8 *val, size_t len) +void db_bind_blob(struct db_stmt *stmt, const u8 *val, size_t len) { - pos = check_bind_pos(stmt, pos); + size_t pos = check_bind_pos(stmt); stmt->bindings[pos].type = DB_BINDING_BLOB; stmt->bindings[pos].v.blob = memcheck(val, len); stmt->bindings[pos].len = len; } -void db_bind_text(struct db_stmt *stmt, int pos, const char *val) +void db_bind_text(struct db_stmt *stmt, const char *val) { - pos = check_bind_pos(stmt, pos); + size_t pos = check_bind_pos(stmt); stmt->bindings[pos].type = DB_BINDING_TEXT; stmt->bindings[pos].v.text = val; stmt->bindings[pos].len = strlen(val); } -void db_bind_preimage(struct db_stmt *stmt, int pos, const struct preimage *p) +void db_bind_preimage(struct db_stmt *stmt, const struct preimage *p) { - db_bind_blob(stmt, pos, p->r, sizeof(struct preimage)); + db_bind_blob(stmt, p->r, sizeof(struct preimage)); } -void db_bind_sha256(struct db_stmt *stmt, int pos, const struct sha256 *s) +void db_bind_sha256(struct db_stmt *stmt, const struct sha256 *s) { - db_bind_blob(stmt, pos, s->u.u8, sizeof(struct sha256)); + db_bind_blob(stmt, s->u.u8, sizeof(struct sha256)); } -void db_bind_sha256d(struct db_stmt *stmt, int pos, const struct sha256_double *s) +void db_bind_sha256d(struct db_stmt *stmt, const struct sha256_double *s) { - db_bind_sha256(stmt, pos, &s->sha); + db_bind_sha256(stmt, &s->sha); } -void db_bind_secret(struct db_stmt *stmt, int pos, const struct secret *s) +void db_bind_secret(struct db_stmt *stmt, const struct secret *s) { assert(sizeof(s->data) == 32); - db_bind_blob(stmt, pos, s->data, sizeof(s->data)); + db_bind_blob(stmt, s->data, sizeof(s->data)); } -void db_bind_secret_arr(struct db_stmt *stmt, int col, const struct secret *s) +void db_bind_secret_arr(struct db_stmt *stmt, const struct secret *s) { size_t num = tal_count(s), elsize = sizeof(s->data); u8 *ser = tal_arr(stmt, u8, num * elsize); @@ -132,30 +126,30 @@ void db_bind_secret_arr(struct db_stmt *stmt, int col, const struct secret *s) for (size_t i = 0; i < num; ++i) memcpy(ser + i * elsize, &s[i], elsize); - db_bind_blob(stmt, col, ser, tal_count(ser)); + db_bind_blob(stmt, ser, tal_count(ser)); } -void db_bind_txid(struct db_stmt *stmt, int pos, const struct bitcoin_txid *t) +void db_bind_txid(struct db_stmt *stmt, const struct bitcoin_txid *t) { - db_bind_sha256d(stmt, pos, &t->shad); + db_bind_sha256d(stmt, &t->shad); } -void db_bind_channel_id(struct db_stmt *stmt, int pos, const struct channel_id *id) +void db_bind_channel_id(struct db_stmt *stmt, const struct channel_id *id) { - db_bind_blob(stmt, pos, id->id, sizeof(id->id)); + db_bind_blob(stmt, id->id, sizeof(id->id)); } -void db_bind_channel_type(struct db_stmt *stmt, int pos, const struct channel_type *type) +void db_bind_channel_type(struct db_stmt *stmt, const struct channel_type *type) { - db_bind_talarr(stmt, pos, type->features); + db_bind_talarr(stmt, type->features); } -void db_bind_node_id(struct db_stmt *stmt, int pos, const struct node_id *id) +void db_bind_node_id(struct db_stmt *stmt, const struct node_id *id) { - db_bind_blob(stmt, pos, id->k, sizeof(id->k)); + db_bind_blob(stmt, id->k, sizeof(id->k)); } -void db_bind_node_id_arr(struct db_stmt *stmt, int col, +void db_bind_node_id_arr(struct db_stmt *stmt, const struct node_id *ids) { /* Copy into contiguous array: ARM will add padding to struct node_id! */ @@ -168,23 +162,23 @@ void db_bind_node_id_arr(struct db_stmt *stmt, int col, ids[i].k, sizeof(ids[i].k)); } - db_bind_blob(stmt, col, arr, tal_count(arr)); + db_bind_blob(stmt, arr, tal_count(arr)); } -void db_bind_pubkey(struct db_stmt *stmt, int pos, const struct pubkey *pk) +void db_bind_pubkey(struct db_stmt *stmt, const struct pubkey *pk) { u8 *der = tal_arr(stmt, u8, PUBKEY_CMPR_LEN); pubkey_to_der(der, pk); - db_bind_blob(stmt, pos, der, PUBKEY_CMPR_LEN); + db_bind_blob(stmt, der, PUBKEY_CMPR_LEN); } -void db_bind_short_channel_id(struct db_stmt *stmt, int col, +void db_bind_short_channel_id(struct db_stmt *stmt, const struct short_channel_id *id) { - db_bind_u64(stmt, col, id->u64); + db_bind_u64(stmt, id->u64); } -void db_bind_short_channel_id_arr(struct db_stmt *stmt, int col, +void db_bind_short_channel_id_arr(struct db_stmt *stmt, const struct short_channel_id *id) { u8 *ser = tal_arr(stmt, u8, 0); @@ -193,69 +187,69 @@ void db_bind_short_channel_id_arr(struct db_stmt *stmt, int col, for (size_t i = 0; i < num; ++i) towire_short_channel_id(&ser, &id[i]); - db_bind_talarr(stmt, col, ser); + db_bind_talarr(stmt, ser); } -void db_bind_signature(struct db_stmt *stmt, int col, +void db_bind_signature(struct db_stmt *stmt, const secp256k1_ecdsa_signature *sig) { u8 *buf = tal_arr(stmt, u8, 64); int ret = secp256k1_ecdsa_signature_serialize_compact(secp256k1_ctx, buf, sig); assert(ret == 1); - db_bind_blob(stmt, col, buf, 64); + db_bind_blob(stmt, buf, 64); } -void db_bind_timeabs(struct db_stmt *stmt, int col, struct timeabs t) +void db_bind_timeabs(struct db_stmt *stmt, struct timeabs t) { u64 timestamp = t.ts.tv_nsec + (((u64) t.ts.tv_sec) * ((u64) NSEC_IN_SEC)); - db_bind_u64(stmt, col, timestamp); + db_bind_u64(stmt, timestamp); } -void db_bind_tx(struct db_stmt *stmt, int col, const struct wally_tx *tx) +void db_bind_tx(struct db_stmt *stmt, const struct wally_tx *tx) { u8 *ser = linearize_wtx(stmt, tx); assert(ser); - db_bind_talarr(stmt, col, ser); + db_bind_talarr(stmt, ser); } -void db_bind_psbt(struct db_stmt *stmt, int col, const struct wally_psbt *psbt) +void db_bind_psbt(struct db_stmt *stmt, const struct wally_psbt *psbt) { size_t bytes_written; const u8 *ser = psbt_get_bytes(stmt, psbt, &bytes_written); assert(ser); - db_bind_blob(stmt, col, ser, bytes_written); + db_bind_blob(stmt, ser, bytes_written); } -void db_bind_amount_msat(struct db_stmt *stmt, int pos, +void db_bind_amount_msat(struct db_stmt *stmt, const struct amount_msat *msat) { - db_bind_u64(stmt, pos, msat->millisatoshis); /* Raw: low level function */ + db_bind_u64(stmt, msat->millisatoshis); /* Raw: low level function */ } -void db_bind_amount_sat(struct db_stmt *stmt, int pos, +void db_bind_amount_sat(struct db_stmt *stmt, const struct amount_sat *sat) { - db_bind_u64(stmt, pos, sat->satoshis); /* Raw: low level function */ + db_bind_u64(stmt, sat->satoshis); /* Raw: low level function */ } -void db_bind_json_escape(struct db_stmt *stmt, int pos, +void db_bind_json_escape(struct db_stmt *stmt, const struct json_escape *esc) { - db_bind_text(stmt, pos, esc->s); + db_bind_text(stmt, esc->s); } -void db_bind_onionreply(struct db_stmt *stmt, int pos, const struct onionreply *r) +void db_bind_onionreply(struct db_stmt *stmt, const struct onionreply *r) { - db_bind_talarr(stmt, pos, r->contents); + db_bind_talarr(stmt, r->contents); } -void db_bind_talarr(struct db_stmt *stmt, int col, const u8 *arr) +void db_bind_talarr(struct db_stmt *stmt, const u8 *arr) { if (!arr) - db_bind_null(stmt, col); + db_bind_null(stmt); else - db_bind_blob(stmt, col, arr, tal_bytelen(arr)); + db_bind_blob(stmt, arr, tal_bytelen(arr)); } static size_t db_column_bytes(struct db_stmt *stmt, int col) diff --git a/db/bindings.h b/db/bindings.h index c946cbb7a..66da63da5 100644 --- a/db/bindings.h +++ b/db/bindings.h @@ -17,55 +17,50 @@ struct onionreply; struct wally_psbt; struct wally_tx; -/* Magic pos argument meaning "the next field" */ -#define BIND_NEXT -77 - -int db_col_is_null(struct db_stmt *stmt, const char *colname); - -void db_bind_int(struct db_stmt *stmt, int pos, int val); -int db_col_int(struct db_stmt *stmt, const char *colname); - -void db_bind_null(struct db_stmt *stmt, int pos); -void db_bind_int(struct db_stmt *stmt, int pos, int val); -void db_bind_u64(struct db_stmt *stmt, int pos, u64 val); -void db_bind_blob(struct db_stmt *stmt, int pos, const u8 *val, size_t len); -void db_bind_text(struct db_stmt *stmt, int pos, const char *val); -void db_bind_preimage(struct db_stmt *stmt, int pos, const struct preimage *p); -void db_bind_sha256(struct db_stmt *stmt, int pos, const struct sha256 *s); -void db_bind_sha256d(struct db_stmt *stmt, int pos, const struct sha256_double *s); -void db_bind_secret(struct db_stmt *stmt, int pos, const struct secret *s); -void db_bind_secret_arr(struct db_stmt *stmt, int col, const struct secret *s); -void db_bind_txid(struct db_stmt *stmt, int pos, const struct bitcoin_txid *t); -void db_bind_channel_id(struct db_stmt *stmt, int pos, const struct channel_id *id); -void db_bind_channel_type(struct db_stmt *stmt, int pos, const struct channel_type *type); -void db_bind_node_id(struct db_stmt *stmt, int pos, const struct node_id *ni); -void db_bind_node_id_arr(struct db_stmt *stmt, int col, +/* These bind the next `?` in stmt (they keep an internal counter). */ +void db_bind_null(struct db_stmt *stmt); +void db_bind_int(struct db_stmt *stmt, int val); +void db_bind_u64(struct db_stmt *stmt, u64 val); +void db_bind_blob(struct db_stmt *stmt, const u8 *val, size_t len); +void db_bind_text(struct db_stmt *stmt, const char *val); +void db_bind_preimage(struct db_stmt *stmt, const struct preimage *p); +void db_bind_sha256(struct db_stmt *stmt, const struct sha256 *s); +void db_bind_sha256d(struct db_stmt *stmt, const struct sha256_double *s); +void db_bind_secret(struct db_stmt *stmt, const struct secret *s); +void db_bind_secret_arr(struct db_stmt *stmt, const struct secret *s); +void db_bind_txid(struct db_stmt *stmt, const struct bitcoin_txid *t); +void db_bind_channel_id(struct db_stmt *stmt, const struct channel_id *id); +void db_bind_channel_type(struct db_stmt *stmt, const struct channel_type *type); +void db_bind_node_id(struct db_stmt *stmt, const struct node_id *ni); +void db_bind_node_id_arr(struct db_stmt *stmt, const struct node_id *ids); -void db_bind_pubkey(struct db_stmt *stmt, int pos, const struct pubkey *p); -void db_bind_short_channel_id(struct db_stmt *stmt, int col, +void db_bind_pubkey(struct db_stmt *stmt, const struct pubkey *p); +void db_bind_short_channel_id(struct db_stmt *stmt, const struct short_channel_id *id); -void db_bind_short_channel_id_arr(struct db_stmt *stmt, int col, +void db_bind_short_channel_id_arr(struct db_stmt *stmt, const struct short_channel_id *id); -void db_bind_signature(struct db_stmt *stmt, int col, +void db_bind_signature(struct db_stmt *stmt, const secp256k1_ecdsa_signature *sig); -void db_bind_timeabs(struct db_stmt *stmt, int col, struct timeabs t); -void db_bind_tx(struct db_stmt *stmt, int col, const struct wally_tx *tx); -void db_bind_psbt(struct db_stmt *stmt, int col, const struct wally_psbt *psbt); -void db_bind_amount_msat(struct db_stmt *stmt, int pos, +void db_bind_timeabs(struct db_stmt *stmt, struct timeabs t); +void db_bind_tx(struct db_stmt *stmt, const struct wally_tx *tx); +void db_bind_psbt(struct db_stmt *stmt, const struct wally_psbt *psbt); +void db_bind_amount_msat(struct db_stmt *stmt, const struct amount_msat *msat); -void db_bind_amount_sat(struct db_stmt *stmt, int pos, +void db_bind_amount_sat(struct db_stmt *stmt, const struct amount_sat *sat); -void db_bind_json_escape(struct db_stmt *stmt, int pos, +void db_bind_json_escape(struct db_stmt *stmt, const struct json_escape *esc); -void db_bind_onionreply(struct db_stmt *stmt, int col, +void db_bind_onionreply(struct db_stmt *stmt, const struct onionreply *r); -void db_bind_talarr(struct db_stmt *stmt, int col, const u8 *arr); +void db_bind_talarr(struct db_stmt *stmt, const u8 *arr); /* Modern variants: get columns by name from SELECT */ /* Bridge function to get column number from SELECT (must exist) */ size_t db_query_colnum(const struct db_stmt *stmt, const char *colname); +int db_col_is_null(struct db_stmt *stmt, const char *colname); +int db_col_int(struct db_stmt *stmt, const char *colname); u64 db_col_u64(struct db_stmt *stmt, const char *colname); size_t db_col_bytes(struct db_stmt *stmt, const char *colname); const void* db_col_blob(struct db_stmt *stmt, const char *colname); diff --git a/db/exec.c b/db/exec.c index da2f8926d..6d16d4588 100644 --- a/db/exec.c +++ b/db/exec.c @@ -62,16 +62,16 @@ void db_set_intvar(struct db *db, const char *varname, s64 val) { size_t changes; struct db_stmt *stmt = db_prepare_v2(db, SQL("UPDATE vars SET intval=? WHERE name=?;")); - db_bind_int(stmt, BIND_NEXT, val); - db_bind_text(stmt, BIND_NEXT, varname); + db_bind_int(stmt, val); + db_bind_text(stmt, varname); db_exec_prepared_v2(stmt); changes = db_count_changes(stmt); tal_free(stmt); if (changes == 0) { stmt = db_prepare_v2(db, SQL("INSERT INTO vars (name, intval) VALUES (?, ?);")); - db_bind_text(stmt, BIND_NEXT, varname); - db_bind_int(stmt, BIND_NEXT, val); + db_bind_text(stmt, varname); + db_bind_int(stmt, val); db_exec_prepared_v2(stmt); tal_free(stmt); } @@ -82,7 +82,7 @@ s64 db_get_intvar(struct db *db, const char *varname, s64 defval) s64 res = defval; struct db_stmt *stmt = db_prepare_v2( db, SQL("SELECT intval FROM vars WHERE name= ? LIMIT 1")); - db_bind_text(stmt, BIND_NEXT, varname); + db_bind_text(stmt, varname); if (db_query_prepared_canfail(stmt) && db_step(stmt)) res = db_col_int(stmt, "intval"); @@ -110,7 +110,7 @@ static void db_data_version_incr(struct db *db) "SET intval = intval + 1 " "WHERE name = 'data_version'" " AND intval = ?")); - db_bind_int(stmt, BIND_NEXT, db->data_version); + db_bind_int(stmt, db->data_version); db_exec_prepared_v2(stmt); if (db_count_changes(stmt) != 1) db_fatal(stmt->db, "Optimistic lock on the database failed. There" diff --git a/plugins/bkpr/db.c b/plugins/bkpr/db.c index c3bf570a7..56d2da8de 100644 --- a/plugins/bkpr/db.c +++ b/plugins/bkpr/db.c @@ -136,7 +136,7 @@ static bool db_migrate(struct plugin *p, struct db *db, bool *created) /* Finally, update the version number in the version table */ stmt = db_prepare_v2(db, SQL("UPDATE version SET version=?;")); - db_bind_int(stmt, BIND_NEXT, available); + db_bind_int(stmt, available); db_exec_prepared_v2(take(stmt)); return current != orig; @@ -179,7 +179,7 @@ static void migration_remove_dupe_lease_fees(struct plugin *p, struct db *db) /* same acct as last, we found a duplicate */ del_stmt = db_prepare_v2(db, SQL("DELETE FROM channel_events" " WHERE id=?")); - db_bind_u64(del_stmt, BIND_NEXT, id); + db_bind_u64(del_stmt, id); db_exec_prepared_v2(take(del_stmt)); } tal_free(stmt); diff --git a/plugins/bkpr/incomestmt.c b/plugins/bkpr/incomestmt.c index edff9e737..51dda2456 100644 --- a/plugins/bkpr/incomestmt.c +++ b/plugins/bkpr/incomestmt.c @@ -192,7 +192,7 @@ static struct income_event *maybe_chain_income(const tal_t *ctx, " WHERE " " e.spending_txid = ?")); - db_bind_txid(stmt, BIND_NEXT, &ev->outpoint.txid); + db_bind_txid(stmt, &ev->outpoint.txid); db_query_prepared(stmt); if (!db_step(stmt)) { tal_free(stmt); diff --git a/plugins/bkpr/recorder.c b/plugins/bkpr/recorder.c index d06c512b5..8f797fb9e 100644 --- a/plugins/bkpr/recorder.c +++ b/plugins/bkpr/recorder.c @@ -170,8 +170,8 @@ struct chain_event **list_chain_events_timebox(const tal_t *ctx, " AND e.timestamp <= ?" " ORDER BY e.timestamp, e.id;")); - db_bind_u64(stmt, BIND_NEXT, start_time); - db_bind_u64(stmt, BIND_NEXT, end_time); + db_bind_u64(stmt, start_time); + db_bind_u64(stmt, end_time); return find_chain_events(ctx, take(stmt)); } @@ -211,7 +211,7 @@ struct chain_event **account_get_chain_events(const tal_t *ctx, " WHERE e.account_id = ?" " ORDER BY e.timestamp, e.id")); - db_bind_int(stmt, BIND_NEXT, acct->db_id); + db_bind_int(stmt, acct->db_id); return find_chain_events(ctx, take(stmt)); } @@ -250,7 +250,7 @@ static struct chain_event **find_txos_for_tx(const tal_t *ctx, ", e.spending_txid NULLS FIRST" ", e.blockheight")); - db_bind_txid(stmt, BIND_NEXT, txid); + db_bind_txid(stmt, txid); return find_chain_events(ctx, take(stmt)); } @@ -317,8 +317,8 @@ u64 onchain_fee_last_timestamp(struct db *db, " ORDER BY timestamp DESC")); - db_bind_u64(stmt, BIND_NEXT, acct_db_id); - db_bind_txid(stmt, BIND_NEXT, txid); + db_bind_u64(stmt, acct_db_id); + db_bind_txid(stmt, txid); db_query_prepared(stmt); if (db_step(stmt)) @@ -345,7 +345,7 @@ struct fee_sum **find_account_onchain_fees(const tal_t *ctx, " GROUP BY txid, update_count" " ORDER BY txid, update_count")); - db_bind_u64(stmt, BIND_NEXT, acct->db_id); + db_bind_u64(stmt, acct->db_id); db_query_prepared(stmt); sums = tal_arr(ctx, struct fee_sum *, 0); @@ -551,8 +551,8 @@ struct account *find_close_account(const tal_t *ctx, " e.tag = ?" " AND e.spending_txid = ?")); - db_bind_text(stmt, BIND_NEXT, mvt_tag_str(CHANNEL_CLOSE)); - db_bind_txid(stmt, BIND_NEXT, txid); + db_bind_text(stmt, mvt_tag_str(CHANNEL_CLOSE)); + db_bind_txid(stmt, txid); db_query_prepared(stmt); if (db_step(stmt)) { @@ -607,7 +607,7 @@ void maybe_mark_account_onchain(struct db *db, struct account *acct) " ORDER BY blockheight DESC" " LIMIT 1")); - db_bind_u64(stmt, BIND_NEXT, acct->db_id); + db_bind_u64(stmt, acct->db_id); db_query_prepared(stmt); ok = db_step(stmt); assert(ok); @@ -620,8 +620,8 @@ void maybe_mark_account_onchain(struct db *db, struct account *acct) " onchain_resolved_block = ?" " WHERE" " id = ?")); - db_bind_int(stmt, BIND_NEXT, acct->onchain_resolved_block); - db_bind_u64(stmt, BIND_NEXT, acct->db_id); + db_bind_int(stmt, acct->onchain_resolved_block); + db_bind_u64(stmt, acct->db_id); db_exec_prepared_v2(take(stmt)); } @@ -639,8 +639,8 @@ void add_payment_hash_desc(struct db *db, " ev_desc = ?" " WHERE" " payment_id = ?")); - db_bind_text(stmt, BIND_NEXT, desc); - db_bind_sha256(stmt, BIND_NEXT, payment_hash); + db_bind_text(stmt, desc); + db_bind_sha256(stmt, payment_hash); db_exec_prepared_v2(take(stmt)); /* Ok, now we update the account with this blockheight */ @@ -648,8 +648,8 @@ void add_payment_hash_desc(struct db *db, " ev_desc = ?" " WHERE" " payment_id = ?")); - db_bind_text(stmt, BIND_NEXT, desc); - db_bind_sha256(stmt, BIND_NEXT, payment_hash); + db_bind_text(stmt, desc); + db_bind_sha256(stmt, payment_hash); db_exec_prepared_v2(take(stmt)); } @@ -685,7 +685,7 @@ struct chain_event *find_chain_event_by_id(const tal_t *ctx, " WHERE " " e.id = ?")); - db_bind_u64(stmt, BIND_NEXT, event_db_id); + db_bind_u64(stmt, event_db_id); db_query_prepared(stmt); if (db_step(stmt)) e = stmt2chain_event(ctx, stmt); @@ -735,7 +735,7 @@ static struct chain_event *find_chain_event(const tal_t *ctx, " AND e.account_id = ?" " AND e.utxo_txid = ?" " AND e.outnum = ?")); - db_bind_txid(stmt, BIND_NEXT, spending_txid); + db_bind_txid(stmt, spending_txid); } else { stmt = db_prepare_v2(db, SQL("SELECT" " e.id" @@ -765,12 +765,12 @@ static struct chain_event *find_chain_event(const tal_t *ctx, " AND e.utxo_txid = ?" " AND e.outnum = ?" " AND e.spending_txid IS NULL")); - db_bind_text(stmt, BIND_NEXT, tag); + db_bind_text(stmt, tag); } - db_bind_u64(stmt, BIND_NEXT, acct->db_id); - db_bind_txid(stmt, BIND_NEXT, &outpoint->txid); - db_bind_int(stmt, BIND_NEXT, outpoint->n); + db_bind_u64(stmt, acct->db_id); + db_bind_txid(stmt, &outpoint->txid); + db_bind_int(stmt, outpoint->n); db_query_prepared(stmt); if (db_step(stmt)) @@ -803,10 +803,10 @@ char *account_get_balance(const tal_t *ctx, " AND ce.ignored != ?" " GROUP BY ce.currency")); - db_bind_text(stmt, BIND_NEXT, acct_name); + db_bind_text(stmt, acct_name); /* We populate ignored with a 0 or 1, * if we want both 0+1, we just ignore everything with a 2 */ - db_bind_int(stmt, BIND_NEXT, skip_ignored ? 1 : 2); + db_bind_int(stmt, skip_ignored ? 1 : 2); db_query_prepared(stmt); *balances = tal_arr(ctx, struct acct_balance *, 0); if (account_exists) @@ -836,7 +836,7 @@ char *account_get_balance(const tal_t *ctx, " ON a.id = ce.account_id" " WHERE a.name = ?" " GROUP BY ce.currency")); - db_bind_text(stmt, BIND_NEXT, acct_name); + db_bind_text(stmt, acct_name); db_query_prepared(stmt); while (db_step(stmt)) { @@ -924,8 +924,8 @@ struct channel_event **list_channel_events_timebox(const tal_t *ctx, " AND e.timestamp <= ?" " ORDER BY e.timestamp, e.id;")); - db_bind_u64(stmt, BIND_NEXT, start_time); - db_bind_u64(stmt, BIND_NEXT, end_time); + db_bind_u64(stmt, start_time); + db_bind_u64(stmt, end_time); db_query_prepared(stmt); results = tal_arr(ctx, struct channel_event *, 0); @@ -971,7 +971,7 @@ struct channel_event **account_get_channel_events(const tal_t *ctx, " WHERE e.account_id = ?" " ORDER BY e.timestamp, e.id")); - db_bind_u64(stmt, BIND_NEXT, acct->db_id); + db_bind_u64(stmt, acct->db_id); db_query_prepared(stmt); results = tal_arr(ctx, struct channel_event *, 0); @@ -1025,7 +1025,7 @@ struct onchain_fee **account_get_chain_fees(const tal_t *ctx, struct db *db, ", of.txid" ", of.update_count")); - db_bind_u64(stmt, BIND_NEXT, acct->db_id); + db_bind_u64(stmt, acct->db_id); db_query_prepared(stmt); results = tal_arr(ctx, struct onchain_fee *, 0); @@ -1064,8 +1064,8 @@ struct onchain_fee **list_chain_fees_timebox(const tal_t *ctx, struct db *db, ", of.txid" ", of.update_count")); - db_bind_u64(stmt, BIND_NEXT, start_time); - db_bind_u64(stmt, BIND_NEXT, end_time); + db_bind_u64(stmt, start_time); + db_bind_u64(stmt, end_time); db_query_prepared(stmt); results = tal_arr(ctx, struct onchain_fee *, 0); @@ -1142,7 +1142,7 @@ struct account *find_account(const tal_t *ctx, " FROM accounts" " WHERE name = ?")); - db_bind_text(stmt, BIND_NEXT, name); + db_bind_text(stmt, name); db_query_prepared(stmt); if (db_step(stmt)) @@ -1176,7 +1176,7 @@ struct onchain_fee **account_onchain_fees(const tal_t *ctx, " ON a.id = of.account_id" " WHERE of.account_id = ?;")); - db_bind_u64(stmt, BIND_NEXT, acct->db_id); + db_bind_u64(stmt, acct->db_id); db_query_prepared(stmt); results = tal_arr(ctx, struct onchain_fee *, 0); @@ -1233,14 +1233,14 @@ void account_add(struct db *db, struct account *acct) " VALUES" " (?, ?, ?, ?, ?);")); - db_bind_text(stmt, BIND_NEXT, acct->name); + db_bind_text(stmt, acct->name); if (acct->peer_id) - db_bind_node_id(stmt, BIND_NEXT, acct->peer_id); + db_bind_node_id(stmt, acct->peer_id); else - db_bind_null(stmt, BIND_NEXT); - db_bind_int(stmt, BIND_NEXT, acct->is_wallet ? 1 : 0); - db_bind_int(stmt, BIND_NEXT, acct->we_opened ? 1 : 0); - db_bind_int(stmt, BIND_NEXT, acct->leased ? 1 : 0); + db_bind_null(stmt); + db_bind_int(stmt, acct->is_wallet ? 1 : 0); + db_bind_int(stmt, acct->we_opened ? 1 : 0); + db_bind_int(stmt, acct->leased ? 1 : 0); db_exec_prepared_v2(stmt); acct->db_id = db_last_insert_id_v2(stmt); @@ -1328,24 +1328,24 @@ void maybe_update_account(struct db *db, " name = ?")); if (acct->open_event_db_id) - db_bind_u64(stmt, BIND_NEXT, *acct->open_event_db_id); + db_bind_u64(stmt, *acct->open_event_db_id); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); if (acct->closed_event_db_id) - db_bind_u64(stmt, BIND_NEXT, *acct->closed_event_db_id); + db_bind_u64(stmt, *acct->closed_event_db_id); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); - db_bind_int(stmt, BIND_NEXT, acct->we_opened ? 1 : 0); - db_bind_int(stmt, BIND_NEXT, acct->leased ? 1 : 0); - db_bind_int(stmt, BIND_NEXT, acct->closed_count); + db_bind_int(stmt, acct->we_opened ? 1 : 0); + db_bind_int(stmt, acct->leased ? 1 : 0); + db_bind_int(stmt, acct->closed_count); if (acct->peer_id) - db_bind_node_id(stmt, BIND_NEXT, acct->peer_id); + db_bind_node_id(stmt, acct->peer_id); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); - db_bind_text(stmt, BIND_NEXT, acct->name); + db_bind_text(stmt, acct->name); db_exec_prepared_v2(take(stmt)); } @@ -1373,27 +1373,27 @@ void log_channel_event(struct db *db, " VALUES" " (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);")); - db_bind_u64(stmt, BIND_NEXT, acct->db_id); - db_bind_text(stmt, BIND_NEXT, e->tag); - db_bind_amount_msat(stmt, BIND_NEXT, &e->credit); - db_bind_amount_msat(stmt, BIND_NEXT, &e->debit); - db_bind_amount_msat(stmt, BIND_NEXT, &e->fees); - db_bind_text(stmt, BIND_NEXT, e->currency); + db_bind_u64(stmt, acct->db_id); + db_bind_text(stmt, e->tag); + db_bind_amount_msat(stmt, &e->credit); + db_bind_amount_msat(stmt, &e->debit); + db_bind_amount_msat(stmt, &e->fees); + db_bind_text(stmt, e->currency); if (e->payment_id) - db_bind_sha256(stmt, BIND_NEXT, e->payment_id); + db_bind_sha256(stmt, e->payment_id); else - db_bind_null(stmt, BIND_NEXT); - db_bind_int(stmt, BIND_NEXT, e->part_id); - db_bind_u64(stmt, BIND_NEXT, e->timestamp); + db_bind_null(stmt); + db_bind_int(stmt, e->part_id); + db_bind_u64(stmt, e->timestamp); if (e->desc) - db_bind_text(stmt, BIND_NEXT, e->desc); + db_bind_text(stmt, e->desc); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); if (e->rebalance_id) - db_bind_u64(stmt, BIND_NEXT, *e->rebalance_id); + db_bind_u64(stmt, *e->rebalance_id); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); db_exec_prepared_v2(stmt); e->db_id = db_last_insert_id_v2(stmt); @@ -1433,8 +1433,8 @@ static struct chain_event **find_chain_events_bytxid(const tal_t *ctx, struct db " OR (e.utxo_txid = ? AND e.spending_txid IS NULL)" " ORDER BY e.account_id")); - db_bind_txid(stmt, BIND_NEXT, txid); - db_bind_txid(stmt, BIND_NEXT, txid); + db_bind_txid(stmt, txid); + db_bind_txid(stmt, txid); return find_chain_events(ctx, take(stmt)); } @@ -1448,7 +1448,7 @@ static u64 find_acct_id(struct db *db, const char *name) " FROM accounts" " WHERE name = ?")); - db_bind_text(stmt, BIND_NEXT, name); + db_bind_text(stmt, name); db_query_prepared(stmt); if (db_step(stmt)) acct_id = db_col_u64(stmt, "id"); @@ -1481,8 +1481,8 @@ static void insert_chain_fees_diff(struct db *db, " AND account_id = ?" " ORDER BY update_count")); - db_bind_txid(stmt, BIND_NEXT, txid); - db_bind_u64(stmt, BIND_NEXT, acct_id); + db_bind_txid(stmt, txid); + db_bind_u64(stmt, acct_id); db_query_prepared(stmt); /* If there's no current record, add it */ @@ -1527,13 +1527,13 @@ static void insert_chain_fees_diff(struct db *db, ") VALUES" " (?, ?, ?, ?, ?, ?, ?);")); - db_bind_u64(stmt, BIND_NEXT, acct_id); - db_bind_txid(stmt, BIND_NEXT, txid); - db_bind_amount_msat(stmt, BIND_NEXT, &credit); - db_bind_amount_msat(stmt, BIND_NEXT, &debit); - db_bind_text(stmt, BIND_NEXT, currency); - db_bind_u64(stmt, BIND_NEXT, timestamp); - db_bind_int(stmt, BIND_NEXT, ++update_count); + db_bind_u64(stmt, acct_id); + db_bind_txid(stmt, txid); + db_bind_amount_msat(stmt, &credit); + db_bind_amount_msat(stmt, &debit); + db_bind_text(stmt, currency); + db_bind_u64(stmt, timestamp); + db_bind_int(stmt, ++update_count); db_exec_prepared_v2(take(stmt)); } @@ -1702,8 +1702,8 @@ void maybe_record_rebalance(struct db *db, " AND e.credit = ?" " AND e.rebalance_id IS NULL")); - db_bind_sha256(stmt, BIND_NEXT, out->payment_id); - db_bind_amount_msat(stmt, BIND_NEXT, &credit); + db_bind_sha256(stmt, out->payment_id); + db_bind_amount_msat(stmt, &credit); db_query_prepared(stmt); if (!db_step(stmt)) { @@ -1722,16 +1722,16 @@ void maybe_record_rebalance(struct db *db, " rebalance_id = ?" " WHERE" " id = ?")); - db_bind_u64(stmt, BIND_NEXT, *out->rebalance_id); - db_bind_u64(stmt, BIND_NEXT, out->db_id); + db_bind_u64(stmt, *out->rebalance_id); + db_bind_u64(stmt, out->db_id); db_exec_prepared_v2(take(stmt)); stmt = db_prepare_v2(db, SQL("UPDATE channel_events SET" " rebalance_id = ?" " WHERE" " id = ?")); - db_bind_u64(stmt, BIND_NEXT, out->db_id); - db_bind_u64(stmt, BIND_NEXT, *out->rebalance_id); + db_bind_u64(stmt, out->db_id); + db_bind_u64(stmt, *out->rebalance_id); db_exec_prepared_v2(take(stmt)); } @@ -1953,9 +1953,9 @@ void maybe_closeout_external_deposits(struct db *db, " AND a.name = ?")); /* Blockheight for unconfirmeds is zero */ - db_bind_int(stmt, BIND_NEXT, 0); - db_bind_txid(stmt, BIND_NEXT, ev->spending_txid); - db_bind_text(stmt, BIND_NEXT, EXTERNAL_ACCT); + db_bind_int(stmt, 0); + db_bind_txid(stmt, ev->spending_txid); + db_bind_text(stmt, EXTERNAL_ACCT); db_query_prepared(stmt); while (db_step(stmt)) { @@ -1967,8 +1967,8 @@ void maybe_closeout_external_deposits(struct db *db, " blockheight = ?" " WHERE id = ?")); - db_bind_int(update_stmt, BIND_NEXT, ev->blockheight); - db_bind_u64(update_stmt, BIND_NEXT, id); + db_bind_int(update_stmt, ev->blockheight); + db_bind_u64(update_stmt, id); db_exec_prepared_v2(take(update_stmt)); } @@ -2009,37 +2009,37 @@ bool log_chain_event(struct db *db, " VALUES " "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);")); - db_bind_u64(stmt, BIND_NEXT, acct->db_id); + db_bind_u64(stmt, acct->db_id); if (e->origin_acct) - db_bind_text(stmt, BIND_NEXT, e->origin_acct); + db_bind_text(stmt, e->origin_acct); else - db_bind_null(stmt, BIND_NEXT); - db_bind_text(stmt, BIND_NEXT, e->tag); - db_bind_amount_msat(stmt, BIND_NEXT, &e->credit); - db_bind_amount_msat(stmt, BIND_NEXT, &e->debit); - db_bind_amount_msat(stmt, BIND_NEXT, &e->output_value); - db_bind_text(stmt, BIND_NEXT, e->currency); - db_bind_u64(stmt, BIND_NEXT, e->timestamp); - db_bind_int(stmt, BIND_NEXT, e->blockheight); - db_bind_txid(stmt, BIND_NEXT, &e->outpoint.txid); - db_bind_int(stmt, BIND_NEXT, e->outpoint.n); + db_bind_null(stmt); + db_bind_text(stmt, e->tag); + db_bind_amount_msat(stmt, &e->credit); + db_bind_amount_msat(stmt, &e->debit); + db_bind_amount_msat(stmt, &e->output_value); + db_bind_text(stmt, e->currency); + db_bind_u64(stmt, e->timestamp); + db_bind_int(stmt, e->blockheight); + db_bind_txid(stmt, &e->outpoint.txid); + db_bind_int(stmt, e->outpoint.n); if (e->payment_id) - db_bind_sha256(stmt, BIND_NEXT, e->payment_id); + db_bind_sha256(stmt, e->payment_id); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); if (e->spending_txid) - db_bind_txid(stmt, BIND_NEXT, e->spending_txid); + db_bind_txid(stmt, e->spending_txid); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); - db_bind_int(stmt, BIND_NEXT, e->ignored ? 1 : 0); - db_bind_int(stmt, BIND_NEXT, e->stealable ? 1 : 0); + db_bind_int(stmt, e->ignored ? 1 : 0); + db_bind_int(stmt, e->stealable ? 1 : 0); if (e->desc) - db_bind_text(stmt, BIND_NEXT, e->desc); + db_bind_text(stmt, e->desc); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); db_exec_prepared_v2(stmt); e->db_id = db_last_insert_id_v2(stmt); e->acct_db_id = acct->db_id; diff --git a/wallet/db.c b/wallet/db.c index ebac7a940..728fae29c 100644 --- a/wallet/db.c +++ b/wallet/db.c @@ -1004,7 +1004,7 @@ static bool db_migrate(struct lightningd *ld, struct db *db, /* Finally update the version number in the version table */ stmt = db_prepare_v2(db, SQL("UPDATE version SET version=?;")); - db_bind_int(stmt, BIND_NEXT, available); + db_bind_int(stmt, available); db_exec_prepared_v2(stmt); tal_free(stmt); @@ -1012,8 +1012,8 @@ static bool db_migrate(struct lightningd *ld, struct db *db, if (current != orig) { stmt = db_prepare_v2( db, SQL("INSERT INTO db_upgrades VALUES (?, ?);")); - db_bind_int(stmt, BIND_NEXT, orig); - db_bind_text(stmt, BIND_NEXT, version()); + db_bind_int(stmt, orig); + db_bind_text(stmt, version()); db_exec_prepared_v2(stmt); tal_free(stmt); } @@ -1063,8 +1063,8 @@ static void migrate_pr2342_feerate_per_channel(struct lightningd *ld, struct db struct db_stmt *stmt = db_prepare_v2( db, SQL("UPDATE channels SET feerate_base = ?, feerate_ppm = ?;")); - db_bind_int(stmt, BIND_NEXT, ld->config.fee_base); - db_bind_int(stmt, BIND_NEXT, ld->config.fee_per_satoshi); + db_bind_int(stmt, ld->config.fee_base); + db_bind_int(stmt, ld->config.fee_per_satoshi); db_exec_prepared_v2(stmt); tal_free(stmt); @@ -1160,9 +1160,9 @@ void fillin_missing_scriptpubkeys(struct lightningd *ld, struct db *db) " SET scriptpubkey = ?" " WHERE prev_out_tx = ? " " AND prev_out_index = ?")); - db_bind_blob(update_stmt, BIND_NEXT, scriptPubkey, tal_bytelen(scriptPubkey)); - db_bind_txid(update_stmt, BIND_NEXT, &txid); - db_bind_int(update_stmt, BIND_NEXT, outnum); + db_bind_blob(update_stmt, scriptPubkey, tal_bytelen(scriptPubkey)); + db_bind_txid(update_stmt, &txid); + db_bind_int(update_stmt, outnum); db_exec_prepared_v2(update_stmt); tal_free(update_stmt); } @@ -1201,8 +1201,8 @@ static void fillin_missing_channel_id(struct lightningd *ld, struct db *db) update_stmt = db_prepare_v2(db, SQL("UPDATE channels" " SET full_channel_id = ?" " WHERE id = ?;")); - db_bind_channel_id(update_stmt, BIND_NEXT, &cid); - db_bind_u64(update_stmt, BIND_NEXT, id); + db_bind_channel_id(update_stmt, &cid); + db_bind_u64(update_stmt, id); db_exec_prepared_v2(update_stmt); tal_free(update_stmt); @@ -1258,13 +1258,13 @@ static void fillin_missing_local_basepoints(struct lightningd *ld, ", delayed_payment_basepoint_local = ?" ", funding_pubkey_local = ? " "WHERE id = ?;")); - db_bind_pubkey(upstmt, BIND_NEXT, &base.revocation); - db_bind_pubkey(upstmt, BIND_NEXT, &base.payment); - db_bind_pubkey(upstmt, BIND_NEXT, &base.htlc); - db_bind_pubkey(upstmt, BIND_NEXT, &base.delayed_payment); - db_bind_pubkey(upstmt, BIND_NEXT, &funding_pubkey); + db_bind_pubkey(upstmt, &base.revocation); + db_bind_pubkey(upstmt, &base.payment); + db_bind_pubkey(upstmt, &base.htlc); + db_bind_pubkey(upstmt, &base.delayed_payment); + db_bind_pubkey(upstmt, &funding_pubkey); - db_bind_u64(upstmt, BIND_NEXT, dbid); + db_bind_u64(upstmt, dbid); db_exec_prepared_v2(take(upstmt)); } @@ -1380,9 +1380,9 @@ migrate_inflight_last_tx_to_psbt(struct lightningd *ld, struct db *db) " SET last_tx = ?" " WHERE channel_id = ?" " AND funding_tx_id = ?;")); - db_bind_psbt(update_stmt, BIND_NEXT, last_tx->psbt); - db_bind_int(update_stmt, BIND_NEXT, cdb_id); - db_bind_txid(update_stmt, BIND_NEXT, &funding_txid); + db_bind_psbt(update_stmt, last_tx->psbt); + db_bind_int(update_stmt, cdb_id); + db_bind_txid(update_stmt, &funding_txid); db_exec_prepared_v2(update_stmt); tal_free(update_stmt); } @@ -1474,8 +1474,8 @@ void migrate_last_tx_to_psbt(struct lightningd *ld, struct db *db) update_stmt = db_prepare_v2(db, SQL("UPDATE channels" " SET last_tx = ?" " WHERE id = ?;")); - db_bind_psbt(update_stmt, BIND_NEXT, last_tx->psbt); - db_bind_int(update_stmt, BIND_NEXT, cdb_id); + db_bind_psbt(update_stmt, last_tx->psbt); + db_bind_int(update_stmt, cdb_id); db_exec_prepared_v2(update_stmt); tal_free(update_stmt); } @@ -1511,8 +1511,8 @@ static void migrate_channels_scids_as_integers(struct lightningd *ld, stmt = db_prepare_v2(db, SQL("UPDATE channels" " SET scid = ?" " WHERE short_channel_id = ?")); - db_bind_short_channel_id(stmt, BIND_NEXT, &scid); - db_bind_text(stmt, BIND_NEXT, scids[i]); + db_bind_short_channel_id(stmt, &scid); + db_bind_text(stmt, scids[i]); db_exec_prepared_v2(stmt); /* This was reported to happen with an (old, closed) channel: that we'd have @@ -1566,8 +1566,8 @@ static void migrate_payments_scids_as_integers(struct lightningd *ld, update_stmt = db_prepare_v2(db, SQL("UPDATE payments SET" " failscid = ?" " WHERE id = ?")); - db_bind_short_channel_id(update_stmt, BIND_NEXT, &scid); - db_bind_u64(update_stmt, BIND_NEXT, db_col_u64(stmt, "id")); + db_bind_short_channel_id(update_stmt, &scid); + db_bind_u64(update_stmt, db_col_u64(stmt, "id")); db_exec_prepared_v2(update_stmt); tal_free(update_stmt); } @@ -1624,8 +1624,8 @@ static void migrate_fill_in_channel_type(struct lightningd *ld, update_stmt = db_prepare_v2(db, SQL("UPDATE channels SET" " channel_type = ?" " WHERE id = ?")); - db_bind_channel_type(update_stmt, BIND_NEXT, type); - db_bind_u64(update_stmt, BIND_NEXT, id); + db_bind_channel_type(update_stmt, type); + db_bind_u64(update_stmt, id); db_exec_prepared_v2(update_stmt); tal_free(update_stmt); } @@ -1697,8 +1697,8 @@ static void migrate_invalid_last_tx_psbts(struct lightningd *ld, update_stmt = db_prepare_v2(db, SQL("UPDATE channels" " SET last_tx = ?" " WHERE id = ?;")); - db_bind_psbt(update_stmt, BIND_NEXT, psbt); - db_bind_u64(update_stmt, BIND_NEXT, id); + db_bind_psbt(update_stmt, psbt); + db_bind_u64(update_stmt, id); db_exec_prepared_v2(update_stmt); tal_free(update_stmt); } diff --git a/wallet/invoices.c b/wallet/invoices.c index 8a40fa1e3..4badea7d1 100644 --- a/wallet/invoices.c +++ b/wallet/invoices.c @@ -123,9 +123,9 @@ static void update_db_expirations(struct invoices *invoices, u64 now) " SET state = ?" " WHERE state = ?" " AND expiry_time <= ?;")); - db_bind_int(stmt, BIND_NEXT, EXPIRED); - db_bind_int(stmt, BIND_NEXT, UNPAID); - db_bind_u64(stmt, BIND_NEXT, now); + db_bind_int(stmt, EXPIRED); + db_bind_int(stmt, UNPAID); + db_bind_u64(stmt, now); db_exec_prepared_v2(take(stmt)); } @@ -170,8 +170,8 @@ static void trigger_expiration(struct invoices *invoices) " FROM invoices" " WHERE state = ?" " AND expiry_time <= ?")); - db_bind_int(stmt, BIND_NEXT, UNPAID); - db_bind_u64(stmt, BIND_NEXT, now); + db_bind_int(stmt, UNPAID); + db_bind_u64(stmt, now); db_query_prepared(stmt); while (db_step(stmt)) { @@ -207,7 +207,7 @@ static void install_expiration_timer(struct invoices *invoices) stmt = db_prepare_v2(invoices->wallet->db, SQL("SELECT MIN(expiry_time)" " FROM invoices" " WHERE state = ?;")); - db_bind_int(stmt, BIND_NEXT, UNPAID); + db_bind_int(stmt, UNPAID); db_query_prepared(stmt); @@ -286,25 +286,25 @@ bool invoices_create(struct invoices *invoices, " , NULL, NULL" " , NULL, ?, ?, ?, ?);")); - db_bind_sha256(stmt, BIND_NEXT, rhash); - db_bind_preimage(stmt, BIND_NEXT, r); - db_bind_int(stmt, BIND_NEXT, UNPAID); + db_bind_sha256(stmt, rhash); + db_bind_preimage(stmt, r); + db_bind_int(stmt, UNPAID); if (msat) - db_bind_amount_msat(stmt, BIND_NEXT, msat); + db_bind_amount_msat(stmt, msat); else - db_bind_null(stmt, BIND_NEXT); - db_bind_json_escape(stmt, BIND_NEXT, label); - db_bind_u64(stmt, BIND_NEXT, expiry_time); - db_bind_text(stmt, BIND_NEXT, b11enc); + db_bind_null(stmt); + db_bind_json_escape(stmt, label); + db_bind_u64(stmt, expiry_time); + db_bind_text(stmt, b11enc); if (!description) - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); else - db_bind_text(stmt, BIND_NEXT, description); - db_bind_talarr(stmt, BIND_NEXT, features); + db_bind_text(stmt, description); + db_bind_talarr(stmt, features); if (local_offer_id) - db_bind_sha256(stmt, BIND_NEXT, local_offer_id); + db_bind_sha256(stmt, local_offer_id); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); db_exec_prepared_v2(stmt); @@ -333,7 +333,7 @@ bool invoices_find_by_label(struct invoices *invoices, stmt = db_prepare_v2(invoices->wallet->db, SQL("SELECT id" " FROM invoices" " WHERE label = ?;")); - db_bind_json_escape(stmt, BIND_NEXT, label); + db_bind_json_escape(stmt, label); db_query_prepared(stmt); if (!db_step(stmt)) { @@ -355,7 +355,7 @@ bool invoices_find_by_rhash(struct invoices *invoices, stmt = db_prepare_v2(invoices->wallet->db, SQL("SELECT id" " FROM invoices" " WHERE payment_hash = ?;")); - db_bind_sha256(stmt, BIND_NEXT, rhash); + db_bind_sha256(stmt, rhash); db_query_prepared(stmt); if (!db_step(stmt)) { @@ -377,8 +377,8 @@ bool invoices_find_unpaid(struct invoices *invoices, " FROM invoices" " WHERE payment_hash = ?" " AND state = ?;")); - db_bind_sha256(stmt, BIND_NEXT, rhash); - db_bind_int(stmt, BIND_NEXT, UNPAID); + db_bind_sha256(stmt, rhash); + db_bind_int(stmt, UNPAID); db_query_prepared(stmt); if (!db_step(stmt)) { @@ -398,7 +398,7 @@ bool invoices_delete(struct invoices *invoices, u64 inv_dbid) /* Delete from database. */ stmt = db_prepare_v2(invoices->wallet->db, SQL("DELETE FROM invoices WHERE id=?;")); - db_bind_u64(stmt, BIND_NEXT, inv_dbid); + db_bind_u64(stmt, inv_dbid); db_exec_prepared_v2(stmt); changes = db_count_changes(stmt); @@ -420,7 +420,7 @@ bool invoices_delete_description(struct invoices *invoices, u64 inv_dbid) stmt = db_prepare_v2(invoices->wallet->db, SQL("UPDATE invoices" " SET description = NULL" " WHERE ID = ?;")); - db_bind_u64(stmt, BIND_NEXT, inv_dbid); + db_bind_u64(stmt, inv_dbid); db_exec_prepared_v2(stmt); changes = db_count_changes(stmt); @@ -437,8 +437,8 @@ void invoices_delete_expired(struct invoices *invoices, "DELETE FROM invoices" " WHERE state = ?" " AND expiry_time <= ?;")); - db_bind_int(stmt, BIND_NEXT, EXPIRED); - db_bind_u64(stmt, BIND_NEXT, max_expiry_time); + db_bind_int(stmt, EXPIRED); + db_bind_u64(stmt, max_expiry_time); db_exec_prepared_v2(take(stmt)); } @@ -484,7 +484,7 @@ static enum invoice_status invoice_get_status(struct invoices *invoices, stmt = db_prepare_v2( invoices->wallet->db, SQL("SELECT state FROM invoices WHERE id = ?;")); - db_bind_u64(stmt, BIND_NEXT, inv_dbid); + db_bind_u64(stmt, inv_dbid); db_query_prepared(stmt); res = db_step(stmt); @@ -502,7 +502,7 @@ static void maybe_mark_offer_used(struct db *db, u64 inv_dbid) stmt = db_prepare_v2( db, SQL("SELECT local_offer_id FROM invoices WHERE id = ?;")); - db_bind_u64(stmt, BIND_NEXT, inv_dbid); + db_bind_u64(stmt, inv_dbid); db_query_prepared(stmt); db_step(stmt); @@ -539,11 +539,11 @@ bool invoices_resolve(struct invoices *invoices, " , msatoshi_received=?" " , paid_timestamp=?" " WHERE id=?;")); - db_bind_int(stmt, BIND_NEXT, PAID); - db_bind_u64(stmt, BIND_NEXT, pay_index); - db_bind_amount_msat(stmt, BIND_NEXT, &received); - db_bind_u64(stmt, BIND_NEXT, paid_timestamp); - db_bind_u64(stmt, BIND_NEXT, inv_dbid); + db_bind_int(stmt, PAID); + db_bind_u64(stmt, pay_index); + db_bind_amount_msat(stmt, &received); + db_bind_u64(stmt, paid_timestamp); + db_bind_u64(stmt, inv_dbid); db_exec_prepared_v2(take(stmt)); maybe_mark_offer_used(invoices->wallet->db, inv_dbid); @@ -596,7 +596,7 @@ void invoices_waitany(const tal_t *ctx, " WHERE pay_index IS NOT NULL" " AND pay_index > ?" " ORDER BY pay_index ASC LIMIT 1;")); - db_bind_u64(stmt, BIND_NEXT, lastpay_index); + db_bind_u64(stmt, lastpay_index); db_query_prepared(stmt); if (db_step(stmt)) { @@ -656,7 +656,7 @@ struct invoice_details *invoices_get_details(const tal_t *ctx, ", local_offer_id" " FROM invoices" " WHERE id = ?;")); - db_bind_u64(stmt, BIND_NEXT, inv_dbid); + db_bind_u64(stmt, inv_dbid); db_query_prepared(stmt); res = db_step(stmt); assert(res); diff --git a/wallet/test/run-wallet.c b/wallet/test/run-wallet.c index 820f5beb4..8f8043936 100644 --- a/wallet/test/run-wallet.c +++ b/wallet/test/run-wallet.c @@ -1568,7 +1568,7 @@ static int count_inflights(struct wallet *w, u64 channel_dbid) stmt = db_prepare_v2(w->db, SQL("SELECT COUNT(1)" " FROM channel_funding_inflights" " WHERE channel_id = ?;")); - db_bind_u64(stmt, 0, channel_dbid); + db_bind_u64(stmt, channel_dbid); db_query_prepared(stmt); if (!db_step(stmt)) abort(); diff --git a/wallet/wallet.c b/wallet/wallet.c index 6db304e72..5e5ac8915 100644 --- a/wallet/wallet.c +++ b/wallet/wallet.c @@ -132,8 +132,8 @@ static bool wallet_add_utxo(struct wallet *w, struct utxo *utxo, stmt = db_prepare_v2(w->db, SQL("SELECT * from outputs WHERE " "prev_out_tx=? AND prev_out_index=?")); - db_bind_txid(stmt, BIND_NEXT, &utxo->outpoint.txid); - db_bind_int(stmt, BIND_NEXT, utxo->outpoint.n); + db_bind_txid(stmt, &utxo->outpoint.txid); + db_bind_int(stmt, utxo->outpoint.n); db_query_prepared(stmt); /* If we get a result, that means a clash. */ @@ -161,41 +161,41 @@ static bool wallet_add_utxo(struct wallet *w, struct utxo *utxo, ", scriptpubkey" ", is_in_coinbase" ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);")); - db_bind_txid(stmt, BIND_NEXT, &utxo->outpoint.txid); - db_bind_int(stmt, BIND_NEXT, utxo->outpoint.n); - db_bind_amount_sat(stmt, BIND_NEXT, &utxo->amount); - db_bind_int(stmt, BIND_NEXT, wallet_output_type_in_db(type)); - db_bind_int(stmt, BIND_NEXT, OUTPUT_STATE_AVAILABLE); - db_bind_int(stmt, BIND_NEXT, utxo->keyindex); + db_bind_txid(stmt, &utxo->outpoint.txid); + db_bind_int(stmt, utxo->outpoint.n); + db_bind_amount_sat(stmt, &utxo->amount); + db_bind_int(stmt, wallet_output_type_in_db(type)); + db_bind_int(stmt, OUTPUT_STATE_AVAILABLE); + db_bind_int(stmt, utxo->keyindex); if (utxo->close_info) { - db_bind_u64(stmt, BIND_NEXT, utxo->close_info->channel_id); - db_bind_node_id(stmt, BIND_NEXT, &utxo->close_info->peer_id); + db_bind_u64(stmt, utxo->close_info->channel_id); + db_bind_node_id(stmt, &utxo->close_info->peer_id); if (utxo->close_info->commitment_point) - db_bind_pubkey(stmt, BIND_NEXT, utxo->close_info->commitment_point); + db_bind_pubkey(stmt, utxo->close_info->commitment_point); else - db_bind_null(stmt, BIND_NEXT); - db_bind_int(stmt, BIND_NEXT, utxo->close_info->option_anchors); + db_bind_null(stmt); + db_bind_int(stmt, utxo->close_info->option_anchors); } else { - db_bind_null(stmt, BIND_NEXT); - db_bind_null(stmt, BIND_NEXT); - db_bind_null(stmt, BIND_NEXT); - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); + db_bind_null(stmt); + db_bind_null(stmt); + db_bind_null(stmt); } if (utxo->blockheight) { - db_bind_int(stmt, BIND_NEXT, *utxo->blockheight); + db_bind_int(stmt, *utxo->blockheight); } else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); if (utxo->spendheight) - db_bind_int(stmt, BIND_NEXT, *utxo->spendheight); + db_bind_int(stmt, *utxo->spendheight); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); - db_bind_blob(stmt, BIND_NEXT, utxo->scriptPubkey, + db_bind_blob(stmt, utxo->scriptPubkey, tal_bytelen(utxo->scriptPubkey)); - db_bind_int(stmt, BIND_NEXT, utxo->is_in_coinbase); + db_bind_int(stmt, utxo->is_in_coinbase); db_exec_prepared_v2(take(stmt)); return true; } @@ -269,17 +269,17 @@ bool wallet_update_output_status(struct wallet *w, stmt = db_prepare_v2( w->db, SQL("UPDATE outputs SET status=? WHERE status=? AND " "prev_out_tx=? AND prev_out_index=?")); - db_bind_int(stmt, BIND_NEXT, output_status_in_db(newstatus)); - db_bind_int(stmt, BIND_NEXT, output_status_in_db(oldstatus)); - db_bind_txid(stmt, BIND_NEXT, &outpoint->txid); - db_bind_int(stmt, BIND_NEXT, outpoint->n); + db_bind_int(stmt, output_status_in_db(newstatus)); + db_bind_int(stmt, output_status_in_db(oldstatus)); + db_bind_txid(stmt, &outpoint->txid); + db_bind_int(stmt, outpoint->n); } else { stmt = db_prepare_v2(w->db, SQL("UPDATE outputs SET status=? WHERE " "prev_out_tx=? AND prev_out_index=?")); - db_bind_int(stmt, BIND_NEXT, output_status_in_db(newstatus)); - db_bind_txid(stmt, BIND_NEXT, &outpoint->txid); - db_bind_int(stmt, BIND_NEXT, outpoint->n); + db_bind_int(stmt, output_status_in_db(newstatus)); + db_bind_txid(stmt, &outpoint->txid); + db_bind_int(stmt, outpoint->n); } db_exec_prepared_v2(stmt); changes = db_count_changes(stmt); @@ -331,7 +331,7 @@ struct utxo **wallet_get_utxos(const tal_t *ctx, struct wallet *w, const enum ou ", is_in_coinbase " "FROM outputs " "WHERE status= ? ")); - db_bind_int(stmt, BIND_NEXT, output_status_in_db(state)); + db_bind_int(stmt, output_status_in_db(state)); } db_query_prepared(stmt); @@ -410,8 +410,8 @@ struct utxo *wallet_utxo_get(const tal_t *ctx, struct wallet *w, " WHERE prev_out_tx = ?" " AND prev_out_index = ?")); - db_bind_txid(stmt, BIND_NEXT, &outpoint->txid); - db_bind_int(stmt, BIND_NEXT, outpoint->n); + db_bind_txid(stmt, &outpoint->txid); + db_bind_int(stmt, outpoint->n); db_query_prepared(stmt); @@ -438,10 +438,10 @@ static void db_set_utxo(struct db *db, const struct utxo *utxo) stmt = db_prepare_v2( db, SQL("UPDATE outputs SET status=?, reserved_til=? " "WHERE prev_out_tx=? AND prev_out_index=?")); - db_bind_int(stmt, BIND_NEXT, output_status_in_db(utxo->status)); - db_bind_int(stmt, BIND_NEXT, utxo->reserved_til); - db_bind_txid(stmt, BIND_NEXT, &utxo->outpoint.txid); - db_bind_int(stmt, BIND_NEXT, utxo->outpoint.n); + db_bind_int(stmt, output_status_in_db(utxo->status)); + db_bind_int(stmt, utxo->reserved_til); + db_bind_txid(stmt, &utxo->outpoint.txid); + db_bind_int(stmt, utxo->outpoint.n); db_exec_prepared_v2(take(stmt)); } @@ -567,9 +567,9 @@ struct utxo *wallet_find_utxo(const tal_t *ctx, struct wallet *w, " WHERE status = ?" " OR (status = ? AND reserved_til <= ?)" "ORDER BY RANDOM();")); - db_bind_int(stmt, BIND_NEXT, output_status_in_db(OUTPUT_STATE_AVAILABLE)); - db_bind_int(stmt, BIND_NEXT, output_status_in_db(OUTPUT_STATE_RESERVED)); - db_bind_u64(stmt, BIND_NEXT, current_blockheight); + db_bind_int(stmt, output_status_in_db(OUTPUT_STATE_AVAILABLE)); + db_bind_int(stmt, output_status_in_db(OUTPUT_STATE_RESERVED)); + db_bind_u64(stmt, current_blockheight); /* FIXME: Use feerate + estimate of input cost to establish * range for amount_hint */ @@ -618,9 +618,9 @@ bool wallet_has_funds(struct wallet *w, " FROM outputs" " WHERE status = ?" " OR (status = ? AND reserved_til <= ?)")); - db_bind_int(stmt, BIND_NEXT, output_status_in_db(OUTPUT_STATE_AVAILABLE)); - db_bind_int(stmt, BIND_NEXT, output_status_in_db(OUTPUT_STATE_RESERVED)); - db_bind_u64(stmt, BIND_NEXT, current_blockheight); + db_bind_int(stmt, output_status_in_db(OUTPUT_STATE_AVAILABLE)); + db_bind_int(stmt, output_status_in_db(OUTPUT_STATE_RESERVED)); + db_bind_u64(stmt, current_blockheight); db_query_prepared(stmt); while (db_step(stmt)) { @@ -666,8 +666,8 @@ bool wallet_add_onchaind_utxo(struct wallet *w, stmt = db_prepare_v2(w->db, SQL("SELECT * from outputs WHERE " "prev_out_tx=? AND prev_out_index=?")); - db_bind_txid(stmt, BIND_NEXT, &outpoint->txid); - db_bind_int(stmt, BIND_NEXT, outpoint->n); + db_bind_txid(stmt, &outpoint->txid); + db_bind_int(stmt, outpoint->n); db_query_prepared(stmt); /* If we get a result, that means a clash. */ @@ -695,28 +695,28 @@ bool wallet_add_onchaind_utxo(struct wallet *w, ", scriptpubkey" ", csv_lock" ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);")); - db_bind_txid(stmt, BIND_NEXT, &outpoint->txid); - db_bind_int(stmt, BIND_NEXT, outpoint->n); - db_bind_amount_sat(stmt, BIND_NEXT, &amount); - db_bind_int(stmt, BIND_NEXT, wallet_output_type_in_db(p2wpkh)); - db_bind_int(stmt, BIND_NEXT, OUTPUT_STATE_AVAILABLE); - db_bind_int(stmt, BIND_NEXT, 0); - db_bind_u64(stmt, BIND_NEXT, channel->dbid); - db_bind_node_id(stmt, BIND_NEXT, &channel->peer->id); + db_bind_txid(stmt, &outpoint->txid); + db_bind_int(stmt, outpoint->n); + db_bind_amount_sat(stmt, &amount); + db_bind_int(stmt, wallet_output_type_in_db(p2wpkh)); + db_bind_int(stmt, OUTPUT_STATE_AVAILABLE); + db_bind_int(stmt, 0); + db_bind_u64(stmt, channel->dbid); + db_bind_node_id(stmt, &channel->peer->id); if (commitment_point) - db_bind_pubkey(stmt, BIND_NEXT, commitment_point); + db_bind_pubkey(stmt, commitment_point); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); - db_bind_int(stmt, BIND_NEXT, + db_bind_int(stmt, channel_type_has_anchors(channel->type)); - db_bind_int(stmt, BIND_NEXT, blockheight); + db_bind_int(stmt, blockheight); /* spendheight */ - db_bind_null(stmt, BIND_NEXT); - db_bind_blob(stmt, BIND_NEXT, scriptpubkey, tal_bytelen(scriptpubkey)); + db_bind_null(stmt); + db_bind_blob(stmt, scriptpubkey, tal_bytelen(scriptpubkey)); - db_bind_int(stmt, BIND_NEXT, csv_lock); + db_bind_int(stmt, csv_lock); db_exec_prepared_v2(take(stmt)); return true; @@ -802,7 +802,7 @@ static void wallet_shachain_init(struct wallet *wallet, stmt = db_prepare_v2( wallet->db, SQL("INSERT INTO shachains (min_index, num_valid) VALUES (?, 0);")); - db_bind_u64(stmt, BIND_NEXT, chain->chain.min_index); + db_bind_u64(stmt, chain->chain.min_index); db_exec_prepared_v2(stmt); chain->id = db_last_insert_id_v2(stmt); @@ -846,18 +846,18 @@ bool wallet_shachain_add_hash(struct wallet *wallet, stmt = db_prepare_v2( wallet->db, SQL("UPDATE shachains SET num_valid=?, min_index=? WHERE id=?")); - db_bind_int(stmt, BIND_NEXT, chain->chain.num_valid); - db_bind_u64(stmt, BIND_NEXT, index); - db_bind_u64(stmt, BIND_NEXT, chain->id); + db_bind_int(stmt, chain->chain.num_valid); + db_bind_u64(stmt, index); + db_bind_u64(stmt, chain->id); db_exec_prepared_v2(take(stmt)); stmt = db_prepare_v2(wallet->db, SQL("UPDATE shachain_known SET idx=?, hash=? " "WHERE shachain_id=? AND pos=?")); - db_bind_u64(stmt, BIND_NEXT, index); - db_bind_secret(stmt, BIND_NEXT, hash); - db_bind_u64(stmt, BIND_NEXT, chain->id); - db_bind_int(stmt, BIND_NEXT, pos); + db_bind_u64(stmt, index); + db_bind_secret(stmt, hash); + db_bind_u64(stmt, chain->id); + db_bind_int(stmt, pos); db_exec_prepared_v2(stmt); updated = db_count_changes(stmt) == 1; tal_free(stmt); @@ -866,10 +866,10 @@ bool wallet_shachain_add_hash(struct wallet *wallet, stmt = db_prepare_v2( wallet->db, SQL("INSERT INTO shachain_known (shachain_id, " "pos, idx, hash) VALUES (?, ?, ?, ?);")); - db_bind_u64(stmt, BIND_NEXT, chain->id); - db_bind_int(stmt, BIND_NEXT, pos); - db_bind_u64(stmt, BIND_NEXT, index); - db_bind_secret(stmt, BIND_NEXT, hash); + db_bind_u64(stmt, chain->id); + db_bind_int(stmt, pos); + db_bind_u64(stmt, index); + db_bind_secret(stmt, hash); db_exec_prepared_v2(take(stmt)); } @@ -887,7 +887,7 @@ static bool wallet_shachain_load(struct wallet *wallet, u64 id, stmt = db_prepare_v2( wallet->db, SQL("SELECT min_index, num_valid FROM shachains WHERE id=?")); - db_bind_u64(stmt, BIND_NEXT, id); + db_bind_u64(stmt, id); db_query_prepared(stmt); if (!db_step(stmt)) { @@ -903,7 +903,7 @@ static bool wallet_shachain_load(struct wallet *wallet, u64 id, stmt = db_prepare_v2(wallet->db, SQL("SELECT idx, hash, pos FROM shachain_known " "WHERE shachain_id=?")); - db_bind_u64(stmt, BIND_NEXT, id); + db_bind_u64(stmt, id); db_query_prepared(stmt); while (db_step(stmt)) { @@ -925,7 +925,7 @@ static struct peer *wallet_peer_load(struct wallet *w, const u64 dbid) stmt = db_prepare_v2( w->db, SQL("SELECT id, node_id, address, feature_bits FROM peers WHERE id=?;")); - db_bind_u64(stmt, BIND_NEXT, dbid); + db_bind_u64(stmt, dbid); db_query_prepared(stmt); if (!db_step(stmt)) @@ -968,7 +968,7 @@ wallet_htlc_sigs_load(const tal_t *ctx, struct wallet *w, u64 channelid, stmt = db_prepare_v2( w->db, SQL("SELECT signature FROM htlc_sigs WHERE channelid = ?")); - db_bind_u64(stmt, BIND_NEXT, channelid); + db_bind_u64(stmt, channelid); db_query_prepared(stmt); while (db_step(stmt)) { @@ -1003,7 +1003,7 @@ bool wallet_remote_ann_sigs_load(const tal_t *ctx, struct wallet *w, u64 id, stmt = db_prepare_v2( w->db, SQL("SELECT remote_ann_node_sig, remote_ann_bitcoin_sig" " FROM channels WHERE id = ?")); - db_bind_u64(stmt, BIND_NEXT, id); + db_bind_u64(stmt, id); db_query_prepared(stmt); res = db_step(stmt); @@ -1048,7 +1048,7 @@ static struct fee_states *wallet_channel_fee_states_load(struct wallet *w, struct db_stmt *stmt; stmt = db_prepare_v2(w->db, SQL("SELECT hstate, feerate_per_kw FROM channel_feerates WHERE channel_id = ?")); - db_bind_u64(stmt, BIND_NEXT, id); + db_bind_u64(stmt, id); db_query_prepared(stmt); /* Start with blank slate. */ @@ -1084,7 +1084,7 @@ static struct height_states *wallet_channel_height_states_load(struct wallet *w, struct db_stmt *stmt; stmt = db_prepare_v2(w->db, SQL("SELECT hstate, blockheight FROM channel_blockheights WHERE channel_id = ?")); - db_bind_u64(stmt, BIND_NEXT, id); + db_bind_u64(stmt, id); db_query_prepared(stmt); /* Start with blank slate. */ @@ -1137,33 +1137,33 @@ void wallet_inflight_add(struct wallet *w, struct channel_inflight *inflight) ") VALUES (" "?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);")); - db_bind_u64(stmt, BIND_NEXT, inflight->channel->dbid); - db_bind_txid(stmt, BIND_NEXT, &inflight->funding->outpoint.txid); - db_bind_int(stmt, BIND_NEXT, inflight->funding->outpoint.n); - db_bind_int(stmt, BIND_NEXT, inflight->funding->feerate); - db_bind_amount_sat(stmt, BIND_NEXT, &inflight->funding->total_funds); - db_bind_amount_sat(stmt, BIND_NEXT, &inflight->funding->our_funds); - db_bind_psbt(stmt, BIND_NEXT, inflight->funding_psbt); - db_bind_int(stmt, BIND_NEXT, inflight->remote_tx_sigs ? 1 : 0); - db_bind_psbt(stmt, BIND_NEXT, inflight->last_tx->psbt); - db_bind_signature(stmt, BIND_NEXT, &inflight->last_sig.s); + db_bind_u64(stmt, inflight->channel->dbid); + db_bind_txid(stmt, &inflight->funding->outpoint.txid); + db_bind_int(stmt, inflight->funding->outpoint.n); + db_bind_int(stmt, inflight->funding->feerate); + db_bind_amount_sat(stmt, &inflight->funding->total_funds); + db_bind_amount_sat(stmt, &inflight->funding->our_funds); + db_bind_psbt(stmt, inflight->funding_psbt); + db_bind_int(stmt, inflight->remote_tx_sigs ? 1 : 0); + db_bind_psbt(stmt, inflight->last_tx->psbt); + db_bind_signature(stmt, &inflight->last_sig.s); if (inflight->lease_expiry != 0) { - db_bind_signature(stmt, BIND_NEXT, inflight->lease_commit_sig); - db_bind_int(stmt, BIND_NEXT, inflight->lease_chan_max_msat); - db_bind_int(stmt, BIND_NEXT, inflight->lease_chan_max_ppt); - db_bind_int(stmt, BIND_NEXT, inflight->lease_expiry); - db_bind_int(stmt, BIND_NEXT, inflight->lease_blockheight_start); - db_bind_amount_msat(stmt, BIND_NEXT, &inflight->lease_fee); - db_bind_amount_sat(stmt, BIND_NEXT, &inflight->lease_amt); + db_bind_signature(stmt, inflight->lease_commit_sig); + db_bind_int(stmt, inflight->lease_chan_max_msat); + db_bind_int(stmt, inflight->lease_chan_max_ppt); + db_bind_int(stmt, inflight->lease_expiry); + db_bind_int(stmt, inflight->lease_blockheight_start); + db_bind_amount_msat(stmt, &inflight->lease_fee); + db_bind_amount_sat(stmt, &inflight->lease_amt); } else { - db_bind_null(stmt, BIND_NEXT); - db_bind_null(stmt, BIND_NEXT); - db_bind_null(stmt, BIND_NEXT); - db_bind_int(stmt, BIND_NEXT, 0); - db_bind_null(stmt, BIND_NEXT); - db_bind_null(stmt, BIND_NEXT); - db_bind_int(stmt, BIND_NEXT, 0); + db_bind_null(stmt); + db_bind_null(stmt); + db_bind_null(stmt); + db_bind_int(stmt, 0); + db_bind_null(stmt); + db_bind_null(stmt); + db_bind_int(stmt, 0); } db_exec_prepared_v2(stmt); @@ -1187,11 +1187,11 @@ void wallet_inflight_save(struct wallet *w, " channel_id=?" // 2 " AND funding_tx_id=?" // 3 " AND funding_tx_outnum=?")); // 4 - db_bind_psbt(stmt, BIND_NEXT, inflight->funding_psbt); - db_bind_int(stmt, BIND_NEXT, inflight->remote_tx_sigs); - db_bind_u64(stmt, BIND_NEXT, inflight->channel->dbid); - db_bind_txid(stmt, BIND_NEXT, &inflight->funding->outpoint.txid); - db_bind_int(stmt, BIND_NEXT, inflight->funding->outpoint.n); + db_bind_psbt(stmt, inflight->funding_psbt); + db_bind_int(stmt, inflight->remote_tx_sigs); + db_bind_u64(stmt, inflight->channel->dbid); + db_bind_txid(stmt, &inflight->funding->outpoint.txid); + db_bind_int(stmt, inflight->funding->outpoint.n); db_exec_prepared_v2(take(stmt)); } @@ -1205,7 +1205,7 @@ void wallet_channel_clear_inflights(struct wallet *w, /* Remove all the inflights for the channel */ stmt = db_prepare_v2(w->db, SQL("DELETE FROM channel_funding_inflights" " WHERE channel_id = ?")); - db_bind_u64(stmt, BIND_NEXT, chan->dbid); + db_bind_u64(stmt, chan->dbid); db_exec_prepared_v2(take(stmt)); /* Empty out the list too */ @@ -1321,7 +1321,7 @@ static bool wallet_channel_load_inflights(struct wallet *w, " WHERE channel_id = ?" " ORDER BY funding_feerate")); - db_bind_u64(stmt, BIND_NEXT, chan->dbid); + db_bind_u64(stmt, chan->dbid); db_query_prepared(stmt); while (db_step(stmt)) { @@ -1347,7 +1347,7 @@ static bool wallet_channel_config_load(struct wallet *w, const u64 id, "max_accepted_htlcs, max_dust_htlc_exposure_msat" " FROM channel_configs WHERE id= ? ;"); struct db_stmt *stmt = db_prepare_v2(w->db, query); - db_bind_u64(stmt, BIND_NEXT, id); + db_bind_u64(stmt, id); db_query_prepared(stmt); if (!db_step(stmt)) @@ -1704,7 +1704,7 @@ struct closed_channel **wallet_load_closed_channels(const tal_t *ctx, " FROM channels" " LEFT JOIN peers p ON p.id = peer_id" " WHERE state = ?;")); - db_bind_int(stmt, BIND_NEXT, CLOSED); + db_bind_int(stmt, CLOSED); db_query_prepared(stmt); while (db_step(stmt)) { @@ -1808,7 +1808,7 @@ static bool wallet_channels_load_active(struct wallet *w) ", alias_remote" " FROM channels" " WHERE state != ?;")); //? 0 - db_bind_int(stmt, BIND_NEXT, CLOSED); + db_bind_int(stmt, CLOSED); db_query_prepared(stmt); while (db_step(stmt)) { @@ -1883,8 +1883,8 @@ void wallet_channel_stats_incr_x(struct wallet *w, fatal("Unknown channel state key (direction %s, type %s)", dir, typ); stmt = db_prepare_v2(w->db, query); - db_bind_amount_msat(stmt, BIND_NEXT, &msat); - db_bind_u64(stmt, BIND_NEXT, cdbid); + db_bind_amount_msat(stmt, &msat); + db_bind_u64(stmt, cdbid); db_exec_prepared_v2(take(stmt)); } @@ -1923,7 +1923,7 @@ void wallet_channel_stats_load(struct wallet *w, ", out_msatoshi_offered, out_msatoshi_fulfilled" " FROM channels" " WHERE id = ?")); - db_bind_u64(stmt, BIND_NEXT, id); + db_bind_u64(stmt, id); db_query_prepared(stmt); res = db_step(stmt); @@ -2002,14 +2002,14 @@ static void wallet_channel_config_save(struct wallet *w, " max_accepted_htlcs=?," " max_dust_htlc_exposure_msat=?" " WHERE id=?;")); - db_bind_amount_sat(stmt, BIND_NEXT, &cc->dust_limit); - db_bind_amount_msat(stmt, BIND_NEXT, &cc->max_htlc_value_in_flight); - db_bind_amount_sat(stmt, BIND_NEXT, &cc->channel_reserve); - db_bind_amount_msat(stmt, BIND_NEXT, &cc->htlc_minimum); - db_bind_int(stmt, BIND_NEXT, cc->to_self_delay); - db_bind_int(stmt, BIND_NEXT, cc->max_accepted_htlcs); - db_bind_amount_msat(stmt, BIND_NEXT, &cc->max_dust_htlc_exposure_msat); - db_bind_u64(stmt, BIND_NEXT, cc->id); + db_bind_amount_sat(stmt, &cc->dust_limit); + db_bind_amount_msat(stmt, &cc->max_htlc_value_in_flight); + db_bind_amount_sat(stmt, &cc->channel_reserve); + db_bind_amount_msat(stmt, &cc->htlc_minimum); + db_bind_int(stmt, cc->to_self_delay); + db_bind_int(stmt, cc->max_accepted_htlcs); + db_bind_amount_msat(stmt, &cc->max_dust_htlc_exposure_msat); + db_bind_u64(stmt, cc->id); db_exec_prepared_v2(take(stmt)); } @@ -2030,9 +2030,9 @@ void wallet_announcement_save(struct wallet *w, u64 id, " remote_ann_bitcoin_sig=?" " WHERE id=?")); - db_bind_signature(stmt, BIND_NEXT, remote_ann_node_sig); - db_bind_signature(stmt, BIND_NEXT, remote_ann_bitcoin_sig); - db_bind_u64(stmt, BIND_NEXT, id); + db_bind_signature(stmt, remote_ann_node_sig); + db_bind_signature(stmt, remote_ann_bitcoin_sig); + db_bind_u64(stmt, id); db_exec_prepared_v2(take(stmt)); } @@ -2091,85 +2091,85 @@ void wallet_channel_save(struct wallet *w, struct channel *chan) " alias_local=?," // 44 " alias_remote=?" // 45 " WHERE id=?")); // 46 - db_bind_u64(stmt, BIND_NEXT, chan->their_shachain.id); + db_bind_u64(stmt, chan->their_shachain.id); if (chan->scid) - db_bind_short_channel_id(stmt, BIND_NEXT, chan->scid); + db_bind_short_channel_id(stmt, chan->scid); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); - db_bind_channel_id(stmt, BIND_NEXT, &chan->cid); - db_bind_int(stmt, BIND_NEXT, chan->state); - db_bind_int(stmt, BIND_NEXT, chan->opener); - db_bind_int(stmt, BIND_NEXT, chan->channel_flags); - db_bind_int(stmt, BIND_NEXT, chan->minimum_depth); + db_bind_channel_id(stmt, &chan->cid); + db_bind_int(stmt, chan->state); + db_bind_int(stmt, chan->opener); + db_bind_int(stmt, chan->channel_flags); + db_bind_int(stmt, chan->minimum_depth); - db_bind_u64(stmt, BIND_NEXT, chan->next_index[LOCAL]); - db_bind_u64(stmt, BIND_NEXT, chan->next_index[REMOTE]); - db_bind_u64(stmt, BIND_NEXT, chan->next_htlc_id); + db_bind_u64(stmt, chan->next_index[LOCAL]); + db_bind_u64(stmt, chan->next_index[REMOTE]); + db_bind_u64(stmt, chan->next_htlc_id); - db_bind_sha256d(stmt, BIND_NEXT, &chan->funding.txid.shad); + db_bind_sha256d(stmt, &chan->funding.txid.shad); - db_bind_int(stmt, BIND_NEXT, chan->funding.n); - db_bind_amount_sat(stmt, BIND_NEXT, &chan->funding_sats); - db_bind_amount_sat(stmt, BIND_NEXT, &chan->our_funds); - db_bind_int(stmt, BIND_NEXT, chan->remote_channel_ready); - db_bind_amount_msat(stmt, BIND_NEXT, &chan->push); - db_bind_amount_msat(stmt, BIND_NEXT, &chan->our_msat); + db_bind_int(stmt, chan->funding.n); + db_bind_amount_sat(stmt, &chan->funding_sats); + db_bind_amount_sat(stmt, &chan->our_funds); + db_bind_int(stmt, chan->remote_channel_ready); + db_bind_amount_msat(stmt, &chan->push); + db_bind_amount_msat(stmt, &chan->our_msat); - db_bind_talarr(stmt, BIND_NEXT, chan->shutdown_scriptpubkey[REMOTE]); - db_bind_u64(stmt, BIND_NEXT, chan->final_key_idx); - db_bind_u64(stmt, BIND_NEXT, chan->our_config.id); + db_bind_talarr(stmt, chan->shutdown_scriptpubkey[REMOTE]); + db_bind_u64(stmt, chan->final_key_idx); + db_bind_u64(stmt, chan->our_config.id); if (chan->last_tx) - db_bind_psbt(stmt, BIND_NEXT, chan->last_tx->psbt); + db_bind_psbt(stmt, chan->last_tx->psbt); else - db_bind_null(stmt, BIND_NEXT); - db_bind_signature(stmt, BIND_NEXT, &chan->last_sig.s); - db_bind_int(stmt, BIND_NEXT, chan->last_was_revoke); - db_bind_int(stmt, BIND_NEXT, chan->min_possible_feerate); - db_bind_int(stmt, BIND_NEXT, chan->max_possible_feerate); - db_bind_amount_msat(stmt, BIND_NEXT, &chan->msat_to_us_min); - db_bind_amount_msat(stmt, BIND_NEXT, &chan->msat_to_us_max); - db_bind_int(stmt, BIND_NEXT, chan->feerate_base); - db_bind_int(stmt, BIND_NEXT, chan->feerate_ppm); - db_bind_talarr(stmt, BIND_NEXT, chan->remote_upfront_shutdown_script); - db_bind_u64(stmt, BIND_NEXT, chan->static_remotekey_start[LOCAL]); - db_bind_u64(stmt, BIND_NEXT, chan->static_remotekey_start[REMOTE]); - db_bind_channel_type(stmt, BIND_NEXT, chan->type); - db_bind_talarr(stmt, BIND_NEXT, chan->shutdown_scriptpubkey[LOCAL]); - db_bind_int(stmt, BIND_NEXT, chan->closer); - db_bind_int(stmt, BIND_NEXT, state_change_in_db(chan->state_change_cause)); + db_bind_null(stmt); + db_bind_signature(stmt, &chan->last_sig.s); + db_bind_int(stmt, chan->last_was_revoke); + db_bind_int(stmt, chan->min_possible_feerate); + db_bind_int(stmt, chan->max_possible_feerate); + db_bind_amount_msat(stmt, &chan->msat_to_us_min); + db_bind_amount_msat(stmt, &chan->msat_to_us_max); + db_bind_int(stmt, chan->feerate_base); + db_bind_int(stmt, chan->feerate_ppm); + db_bind_talarr(stmt, chan->remote_upfront_shutdown_script); + db_bind_u64(stmt, chan->static_remotekey_start[LOCAL]); + db_bind_u64(stmt, chan->static_remotekey_start[REMOTE]); + db_bind_channel_type(stmt, chan->type); + db_bind_talarr(stmt, chan->shutdown_scriptpubkey[LOCAL]); + db_bind_int(stmt, chan->closer); + db_bind_int(stmt, state_change_in_db(chan->state_change_cause)); if (chan->shutdown_wrong_funding) { - db_bind_txid(stmt, BIND_NEXT, &chan->shutdown_wrong_funding->txid); - db_bind_int(stmt, BIND_NEXT, chan->shutdown_wrong_funding->n); + db_bind_txid(stmt, &chan->shutdown_wrong_funding->txid); + db_bind_int(stmt, chan->shutdown_wrong_funding->n); } else { - db_bind_null(stmt, BIND_NEXT); - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); + db_bind_null(stmt); } - db_bind_int(stmt, BIND_NEXT, chan->lease_expiry); + db_bind_int(stmt, chan->lease_expiry); if (chan->lease_commit_sig) { - db_bind_signature(stmt, BIND_NEXT, chan->lease_commit_sig); - db_bind_int(stmt, BIND_NEXT, chan->lease_chan_max_msat); - db_bind_int(stmt, BIND_NEXT, chan->lease_chan_max_ppt); + db_bind_signature(stmt, chan->lease_commit_sig); + db_bind_int(stmt, chan->lease_chan_max_msat); + db_bind_int(stmt, chan->lease_chan_max_ppt); } else { - db_bind_null(stmt, BIND_NEXT); - db_bind_null(stmt, BIND_NEXT); - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); + db_bind_null(stmt); + db_bind_null(stmt); } - db_bind_amount_msat(stmt, BIND_NEXT, &chan->htlc_minimum_msat); - db_bind_amount_msat(stmt, BIND_NEXT, &chan->htlc_maximum_msat); + db_bind_amount_msat(stmt, &chan->htlc_minimum_msat); + db_bind_amount_msat(stmt, &chan->htlc_maximum_msat); if (chan->alias[LOCAL] != NULL) - db_bind_short_channel_id(stmt, BIND_NEXT, chan->alias[LOCAL]); + db_bind_short_channel_id(stmt, chan->alias[LOCAL]); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); if (chan->alias[REMOTE] != NULL) - db_bind_short_channel_id(stmt, BIND_NEXT, chan->alias[REMOTE]); + db_bind_short_channel_id(stmt, chan->alias[REMOTE]); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); - db_bind_u64(stmt, BIND_NEXT, chan->dbid); + db_bind_u64(stmt, chan->dbid); db_exec_prepared_v2(take(stmt)); wallet_channel_config_save(w, &chan->channel_info.their_config); @@ -2184,25 +2184,25 @@ void wallet_channel_save(struct wallet *w, struct channel *chan) " channel_config_remote=?," " future_per_commitment_point=?" " WHERE id=?")); - db_bind_pubkey(stmt, BIND_NEXT, &chan->channel_info.remote_fundingkey); - db_bind_pubkey(stmt, BIND_NEXT, &chan->channel_info.theirbase.revocation); - db_bind_pubkey(stmt, BIND_NEXT, &chan->channel_info.theirbase.payment); - db_bind_pubkey(stmt, BIND_NEXT, &chan->channel_info.theirbase.htlc); - db_bind_pubkey(stmt, BIND_NEXT, &chan->channel_info.theirbase.delayed_payment); - db_bind_pubkey(stmt, BIND_NEXT, &chan->channel_info.remote_per_commit); - db_bind_pubkey(stmt, BIND_NEXT, &chan->channel_info.old_remote_per_commit); - db_bind_u64(stmt, BIND_NEXT, chan->channel_info.their_config.id); + db_bind_pubkey(stmt, &chan->channel_info.remote_fundingkey); + db_bind_pubkey(stmt, &chan->channel_info.theirbase.revocation); + db_bind_pubkey(stmt, &chan->channel_info.theirbase.payment); + db_bind_pubkey(stmt, &chan->channel_info.theirbase.htlc); + db_bind_pubkey(stmt, &chan->channel_info.theirbase.delayed_payment); + db_bind_pubkey(stmt, &chan->channel_info.remote_per_commit); + db_bind_pubkey(stmt, &chan->channel_info.old_remote_per_commit); + db_bind_u64(stmt, chan->channel_info.their_config.id); if (chan->future_per_commitment_point) - db_bind_pubkey(stmt, BIND_NEXT, chan->future_per_commitment_point); + db_bind_pubkey(stmt, chan->future_per_commitment_point); else - db_bind_null(stmt, BIND_NEXT); - db_bind_u64(stmt, BIND_NEXT, chan->dbid); + db_bind_null(stmt); + db_bind_u64(stmt, chan->dbid); db_exec_prepared_v2(take(stmt)); /* FIXME: Updates channel_feerates by discarding and rewriting. */ stmt = db_prepare_v2(w->db, SQL("DELETE FROM channel_feerates " "WHERE channel_id=?")); - db_bind_u64(stmt, BIND_NEXT, chan->dbid); + db_bind_u64(stmt, chan->dbid); db_exec_prepared_v2(take(stmt)); for (enum htlc_state i = 0; @@ -2212,16 +2212,16 @@ void wallet_channel_save(struct wallet *w, struct channel *chan) continue; stmt = db_prepare_v2(w->db, SQL("INSERT INTO channel_feerates " " VALUES(?, ?, ?)")); - db_bind_u64(stmt, BIND_NEXT, chan->dbid); - db_bind_int(stmt, BIND_NEXT, htlc_state_in_db(i)); - db_bind_int(stmt, BIND_NEXT, *chan->fee_states->feerate[i]); + db_bind_u64(stmt, chan->dbid); + db_bind_int(stmt, htlc_state_in_db(i)); + db_bind_int(stmt, *chan->fee_states->feerate[i]); db_exec_prepared_v2(take(stmt)); } /* FIXME: Updates channel_blockheights by discarding and rewriting. */ stmt = db_prepare_v2(w->db, SQL("DELETE FROM channel_blockheights " "WHERE channel_id=?")); - db_bind_u64(stmt, BIND_NEXT, chan->dbid); + db_bind_u64(stmt, chan->dbid); db_exec_prepared_v2(take(stmt)); for (enum htlc_state i = 0; @@ -2231,9 +2231,9 @@ void wallet_channel_save(struct wallet *w, struct channel *chan) continue; stmt = db_prepare_v2(w->db, SQL("INSERT INTO channel_blockheights " " VALUES(?, ?, ?)")); - db_bind_u64(stmt, BIND_NEXT, chan->dbid); - db_bind_int(stmt, BIND_NEXT, htlc_state_in_db(i)); - db_bind_int(stmt, BIND_NEXT, *chan->blockheight_states->height[i]); + db_bind_u64(stmt, chan->dbid); + db_bind_int(stmt, htlc_state_in_db(i)); + db_bind_int(stmt, *chan->blockheight_states->height[i]); db_exec_prepared_v2(take(stmt)); } @@ -2254,8 +2254,8 @@ void wallet_channel_save(struct wallet *w, struct channel *chan) list_for_each(&chan->inflights, inflight, list) wallet_inflight_save(w, inflight); - db_bind_talarr(stmt, BIND_NEXT, last_sent_commit); - db_bind_u64(stmt, BIND_NEXT, chan->dbid); + db_bind_talarr(stmt, last_sent_commit); + db_bind_u64(stmt, chan->dbid); db_exec_prepared_v2(take(stmt)); } @@ -2278,12 +2278,12 @@ void wallet_state_change_add(struct wallet *w, ", message" ") VALUES (?, ?, ?, ?, ?, ?);")); - db_bind_u64(stmt, BIND_NEXT, channel_id); - db_bind_timeabs(stmt, BIND_NEXT, *timestamp); - db_bind_int(stmt, BIND_NEXT, old_state); - db_bind_int(stmt, BIND_NEXT, new_state); - db_bind_int(stmt, BIND_NEXT, state_change_in_db(cause)); - db_bind_text(stmt, BIND_NEXT, message); + db_bind_u64(stmt, channel_id); + db_bind_timeabs(stmt, *timestamp); + db_bind_int(stmt, old_state); + db_bind_int(stmt, new_state); + db_bind_int(stmt, state_change_in_db(cause)); + db_bind_text(stmt, message); db_exec_prepared_v2(take(stmt)); } @@ -2306,7 +2306,7 @@ struct state_change_entry *wallet_state_change_get(struct wallet *w, "FROM channel_state_changes " "WHERE channel_id = ? " "ORDER BY timestamp ASC;")); - db_bind_int(stmt, BIND_NEXT, channel_id); + db_bind_int(stmt, channel_id); db_query_prepared(stmt); while (db_step(stmt)) { @@ -2328,7 +2328,7 @@ static void wallet_peer_save(struct wallet *w, struct peer *peer) struct db_stmt *stmt = db_prepare_v2(w->db, SQL("SELECT id FROM peers WHERE node_id = ?")); - db_bind_node_id(stmt, BIND_NEXT, &peer->id); + db_bind_node_id(stmt, &peer->id); db_query_prepared(stmt); if (db_step(stmt)) { @@ -2339,9 +2339,9 @@ static void wallet_peer_save(struct wallet *w, struct peer *peer) /* Since we're at it update the wireaddr, feature bits */ stmt = db_prepare_v2( w->db, SQL("UPDATE peers SET address = ?, feature_bits = ? WHERE id = ?")); - db_bind_text(stmt, BIND_NEXT, addr); - db_bind_talarr(stmt, BIND_NEXT, peer->their_features); - db_bind_u64(stmt, BIND_NEXT, peer->dbid); + db_bind_text(stmt, addr); + db_bind_talarr(stmt, peer->their_features); + db_bind_u64(stmt, peer->dbid); db_exec_prepared_v2(take(stmt)); } else { @@ -2350,9 +2350,9 @@ static void wallet_peer_save(struct wallet *w, struct peer *peer) stmt = db_prepare_v2(w->db, SQL("INSERT INTO peers (node_id, address, feature_bits) VALUES (?, ?, ?);") ); - db_bind_node_id(stmt, BIND_NEXT, &peer->id); - db_bind_text(stmt, BIND_NEXT, addr); - db_bind_talarr(stmt, BIND_NEXT, peer->their_features); + db_bind_node_id(stmt, &peer->id); + db_bind_text(stmt, addr); + db_bind_talarr(stmt, peer->their_features); db_exec_prepared_v2(stmt); peer_set_dbid(peer, db_last_insert_id_v2(take(stmt))); } @@ -2382,17 +2382,17 @@ void wallet_channel_insert(struct wallet *w, struct channel *chan) ", require_confirm_inputs_remote" ", require_confirm_inputs_local" ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?);")); - db_bind_u64(stmt, BIND_NEXT, chan->peer->dbid); - db_bind_int(stmt, BIND_NEXT, chan->first_blocknum); - db_bind_int(stmt, BIND_NEXT, chan->dbid); + db_bind_u64(stmt, chan->peer->dbid); + db_bind_int(stmt, chan->first_blocknum); + db_bind_int(stmt, chan->dbid); - db_bind_pubkey(stmt, BIND_NEXT, &chan->local_basepoints.revocation); - db_bind_pubkey(stmt, BIND_NEXT, &chan->local_basepoints.payment); - db_bind_pubkey(stmt, BIND_NEXT, &chan->local_basepoints.htlc); - db_bind_pubkey(stmt, BIND_NEXT, &chan->local_basepoints.delayed_payment); - db_bind_pubkey(stmt, BIND_NEXT, &chan->local_funding_pubkey); - db_bind_int(stmt, BIND_NEXT, chan->req_confirmed_ins[REMOTE]); - db_bind_int(stmt, BIND_NEXT, chan->req_confirmed_ins[LOCAL]); + db_bind_pubkey(stmt, &chan->local_basepoints.revocation); + db_bind_pubkey(stmt, &chan->local_basepoints.payment); + db_bind_pubkey(stmt, &chan->local_basepoints.htlc); + db_bind_pubkey(stmt, &chan->local_basepoints.delayed_payment); + db_bind_pubkey(stmt, &chan->local_funding_pubkey); + db_bind_int(stmt, chan->req_confirmed_ins[REMOTE]); + db_bind_int(stmt, chan->req_confirmed_ins[LOCAL]); db_exec_prepared_v2(take(stmt)); @@ -2417,26 +2417,26 @@ void wallet_channel_close(struct wallet *w, u64 wallet_id) /* Delete entries from `channel_htlcs` */ stmt = db_prepare_v2(w->db, SQL("DELETE FROM channel_htlcs " "WHERE channel_id=?")); - db_bind_u64(stmt, BIND_NEXT, wallet_id); + db_bind_u64(stmt, wallet_id); db_exec_prepared_v2(take(stmt)); /* Delete entries from `htlc_sigs` */ stmt = db_prepare_v2(w->db, SQL("DELETE FROM htlc_sigs " "WHERE channelid=?")); - db_bind_u64(stmt, BIND_NEXT, wallet_id); + db_bind_u64(stmt, wallet_id); db_exec_prepared_v2(take(stmt)); /* Delete entries from `htlc_sigs` */ stmt = db_prepare_v2(w->db, SQL("DELETE FROM channeltxs " "WHERE channel_id=?")); - db_bind_u64(stmt, BIND_NEXT, wallet_id); + db_bind_u64(stmt, wallet_id); db_exec_prepared_v2(take(stmt)); /* Delete any entries from 'inflights' */ stmt = db_prepare_v2(w->db, SQL("DELETE FROM channel_funding_inflights " " WHERE channel_id=?")); - db_bind_u64(stmt, BIND_NEXT, wallet_id); + db_bind_u64(stmt, wallet_id); db_exec_prepared_v2(take(stmt)); /* Delete shachains */ @@ -2446,15 +2446,15 @@ void wallet_channel_close(struct wallet *w, u64 wallet_id) " FROM channels " " WHERE channels.id=?" ")")); - db_bind_u64(stmt, BIND_NEXT, wallet_id); + db_bind_u64(stmt, wallet_id); db_exec_prepared_v2(take(stmt)); /* Set the channel to closed */ stmt = db_prepare_v2(w->db, SQL("UPDATE channels " "SET state=? " "WHERE channels.id=?")); - db_bind_u64(stmt, BIND_NEXT, CLOSED); - db_bind_u64(stmt, BIND_NEXT, wallet_id); + db_bind_u64(stmt, CLOSED); + db_bind_u64(stmt, wallet_id); db_exec_prepared_v2(take(stmt)); } @@ -2464,7 +2464,7 @@ void wallet_delete_peer_if_unused(struct wallet *w, u64 peer_dbid) /* Must not have any channels still using this peer */ stmt = db_prepare_v2(w->db, SQL("SELECT * FROM channels WHERE peer_id = ?;")); - db_bind_u64(stmt, BIND_NEXT, peer_dbid); + db_bind_u64(stmt, peer_dbid); db_query_prepared(stmt); if (db_step(stmt)) { @@ -2475,7 +2475,7 @@ void wallet_delete_peer_if_unused(struct wallet *w, u64 peer_dbid) tal_free(stmt); stmt = db_prepare_v2(w->db, SQL("DELETE FROM peers WHERE id=?")); - db_bind_u64(stmt, BIND_NEXT, peer_dbid); + db_bind_u64(stmt, peer_dbid); db_exec_prepared_v2(take(stmt)); } @@ -2488,8 +2488,8 @@ void wallet_confirm_tx(struct wallet *w, stmt = db_prepare_v2(w->db, SQL("UPDATE outputs " "SET confirmation_height = ? " "WHERE prev_out_tx = ?")); - db_bind_int(stmt, BIND_NEXT, confirmation_height); - db_bind_sha256d(stmt, BIND_NEXT, &txid->shad); + db_bind_int(stmt, confirmation_height); + db_bind_sha256d(stmt, &txid->shad); db_exec_prepared_v2(take(stmt)); } @@ -2610,32 +2610,32 @@ void wallet_htlc_save_in(struct wallet *wallet, " fail_immediate) VALUES " "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);")); - db_bind_u64(stmt, BIND_NEXT, chan->dbid); - db_bind_u64(stmt, BIND_NEXT, in->key.id); - db_bind_int(stmt, BIND_NEXT, DIRECTION_INCOMING); - db_bind_amount_msat(stmt, BIND_NEXT, &in->msat); - db_bind_int(stmt, BIND_NEXT, in->cltv_expiry); - db_bind_sha256(stmt, BIND_NEXT, &in->payment_hash); + db_bind_u64(stmt, chan->dbid); + db_bind_u64(stmt, in->key.id); + db_bind_int(stmt, DIRECTION_INCOMING); + db_bind_amount_msat(stmt, &in->msat); + db_bind_int(stmt, in->cltv_expiry); + db_bind_sha256(stmt, &in->payment_hash); if (in->preimage) - db_bind_preimage(stmt, BIND_NEXT, in->preimage); + db_bind_preimage(stmt, in->preimage); else - db_bind_null(stmt, BIND_NEXT); - db_bind_int(stmt, BIND_NEXT, in->hstate); + db_bind_null(stmt); + db_bind_int(stmt, in->hstate); if (!in->shared_secret) - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); else - db_bind_secret(stmt, BIND_NEXT, in->shared_secret); + db_bind_secret(stmt, in->shared_secret); - db_bind_blob(stmt, BIND_NEXT, in->onion_routing_packet, + db_bind_blob(stmt, in->onion_routing_packet, sizeof(in->onion_routing_packet)); - db_bind_timeabs(stmt, BIND_NEXT, in->received_time); - db_bind_u64(stmt, BIND_NEXT, min_unsigned(chan->next_index[LOCAL]-1, + db_bind_timeabs(stmt, in->received_time); + db_bind_u64(stmt, min_unsigned(chan->next_index[LOCAL]-1, chan->next_index[REMOTE]-1)); - db_bind_int(stmt, BIND_NEXT, in->fail_immediate); + db_bind_int(stmt, in->fail_immediate); db_exec_prepared_v2(stmt); in->dbid = db_last_insert_id_v2(take(stmt)); @@ -2671,37 +2671,37 @@ void wallet_htlc_save_out(struct wallet *wallet, " min_commit_num" ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?);")); - db_bind_u64(stmt, BIND_NEXT, chan->dbid); - db_bind_u64(stmt, BIND_NEXT, out->key.id); - db_bind_int(stmt, BIND_NEXT, DIRECTION_OUTGOING); + db_bind_u64(stmt, chan->dbid); + db_bind_u64(stmt, out->key.id); + db_bind_int(stmt, DIRECTION_OUTGOING); if (out->in) - db_bind_u64(stmt, BIND_NEXT, out->in->dbid); + db_bind_u64(stmt, out->in->dbid); else - db_bind_null(stmt, BIND_NEXT); - db_bind_amount_msat(stmt, BIND_NEXT, &out->msat); - db_bind_int(stmt, BIND_NEXT, out->cltv_expiry); - db_bind_sha256(stmt, BIND_NEXT, &out->payment_hash); + db_bind_null(stmt); + db_bind_amount_msat(stmt, &out->msat); + db_bind_int(stmt, out->cltv_expiry); + db_bind_sha256(stmt, &out->payment_hash); if (out->preimage) - db_bind_preimage(stmt, BIND_NEXT, out->preimage); + db_bind_preimage(stmt, out->preimage); else - db_bind_null(stmt, BIND_NEXT); - db_bind_int(stmt, BIND_NEXT, out->hstate); + db_bind_null(stmt); + db_bind_int(stmt, out->hstate); - db_bind_blob(stmt, BIND_NEXT, out->onion_routing_packet, + db_bind_blob(stmt, out->onion_routing_packet, sizeof(out->onion_routing_packet)); /* groupid and partid are only relevant when we are the origin */ if (!out->am_origin) { - db_bind_null(stmt, BIND_NEXT); - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); + db_bind_null(stmt); } else { - db_bind_u64(stmt, BIND_NEXT, out->partid); - db_bind_u64(stmt, BIND_NEXT, out->groupid); + db_bind_u64(stmt, out->partid); + db_bind_u64(stmt, out->groupid); } - db_bind_amount_msat(stmt, BIND_NEXT, &out->fees); - db_bind_u64(stmt, BIND_NEXT, min_u64(chan->next_index[LOCAL]-1, + db_bind_amount_msat(stmt, &out->fees); + db_bind_u64(stmt, min_u64(chan->next_index[LOCAL]-1, chan->next_index[REMOTE]-1)); db_exec_prepared_v2(stmt); @@ -2735,33 +2735,33 @@ void wallet_htlc_update(struct wallet *wallet, const u64 htlc_dbid, "we_filled=?, max_commit_num=?" " WHERE id=?")); - db_bind_int(stmt, BIND_NEXT, htlc_state_in_db(new_state)); + db_bind_int(stmt, htlc_state_in_db(new_state)); if (payment_key) - db_bind_preimage(stmt, BIND_NEXT, payment_key); + db_bind_preimage(stmt, payment_key); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); - db_bind_int(stmt, BIND_NEXT, badonion); + db_bind_int(stmt, badonion); if (failonion) - db_bind_onionreply(stmt, BIND_NEXT, failonion); + db_bind_onionreply(stmt, failonion); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); - db_bind_talarr(stmt, BIND_NEXT, failmsg); + db_bind_talarr(stmt, failmsg); if (we_filled) - db_bind_int(stmt, BIND_NEXT, *we_filled); + db_bind_int(stmt, *we_filled); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); /* Set max_commit_num iff we're in final state. */ if (terminal) - db_bind_u64(stmt, BIND_NEXT, max_commit_num); + db_bind_u64(stmt, max_commit_num); else - db_bind_null(stmt, BIND_NEXT); - db_bind_u64(stmt, BIND_NEXT, htlc_dbid); + db_bind_null(stmt); + db_bind_u64(stmt, htlc_dbid); db_exec_prepared_v2(take(stmt)); @@ -2771,7 +2771,7 @@ void wallet_htlc_update(struct wallet *wallet, const u64 htlc_dbid, wallet->db, SQL("UPDATE channel_htlcs SET payment_key=NULL, routing_onion=NULL, failuremsg=NULL, shared_secret=NULL, localfailmsg=NULL " " WHERE id=?")); - db_bind_u64(stmt, BIND_NEXT, htlc_dbid); + db_bind_u64(stmt, htlc_dbid); db_exec_prepared_v2(take(stmt)); } } @@ -2964,15 +2964,15 @@ bool wallet_htlcs_load_in_for_channel(struct wallet *wallet, " WHERE direction= ?" " AND channel_id= ?" " AND hstate NOT IN (?, ?)")); - db_bind_int(stmt, BIND_NEXT, DIRECTION_INCOMING); - db_bind_u64(stmt, BIND_NEXT, chan->dbid); + db_bind_int(stmt, DIRECTION_INCOMING); + db_bind_u64(stmt, chan->dbid); /* We need to generate `hstate NOT IN (9, 19)` in order to match * the `WHERE` clause of the database index; incoming HTLCs will * never actually get the state `RCVD_REMOVE_ACK_REVOCATION`. * See https://sqlite.org/partialindex.html#queries_using_partial_indexes */ - db_bind_int(stmt, BIND_NEXT, RCVD_REMOVE_ACK_REVOCATION); /* Not gonna happen. */ - db_bind_int(stmt, BIND_NEXT, SENT_REMOVE_ACK_REVOCATION); + db_bind_int(stmt, RCVD_REMOVE_ACK_REVOCATION); /* Not gonna happen. */ + db_bind_int(stmt, SENT_REMOVE_ACK_REVOCATION); db_query_prepared(stmt); while (db_step(stmt)) { @@ -3017,15 +3017,15 @@ bool wallet_htlcs_load_out_for_channel(struct wallet *wallet, " WHERE direction = ?" " AND channel_id = ?" " AND hstate NOT IN (?, ?)")); - db_bind_int(stmt, BIND_NEXT, DIRECTION_OUTGOING); - db_bind_u64(stmt, BIND_NEXT, chan->dbid); + db_bind_int(stmt, DIRECTION_OUTGOING); + db_bind_u64(stmt, chan->dbid); /* We need to generate `hstate NOT IN (9, 19)` in order to match * the `WHERE` clause of the database index; outgoing HTLCs will * never actually get the state `SENT_REMOVE_ACK_REVOCATION`. * See https://sqlite.org/partialindex.html#queries_using_partial_indexes */ - db_bind_int(stmt, BIND_NEXT, RCVD_REMOVE_ACK_REVOCATION); - db_bind_int(stmt, BIND_NEXT, SENT_REMOVE_ACK_REVOCATION); /* Not gonna happen. */ + db_bind_int(stmt, RCVD_REMOVE_ACK_REVOCATION); + db_bind_int(stmt, SENT_REMOVE_ACK_REVOCATION); /* Not gonna happen. */ db_query_prepared(stmt); while (db_step(stmt)) { @@ -3056,9 +3056,9 @@ struct htlc_stub *wallet_htlc_stubs(const tal_t *ctx, struct wallet *wallet, "channel_htlc_id, payment_hash " "FROM channel_htlcs WHERE channel_id = ? AND min_commit_num <= ? AND ((max_commit_num IS NULL) OR max_commit_num >= ?);")); - db_bind_u64(stmt, BIND_NEXT, chan->dbid); - db_bind_u64(stmt, BIND_NEXT, commit_num); - db_bind_u64(stmt, BIND_NEXT, commit_num); + db_bind_u64(stmt, chan->dbid); + db_bind_u64(stmt, commit_num); + db_bind_u64(stmt, commit_num); db_query_prepared(stmt); stubs = tal_arr(ctx, struct htlc_stub, 0); @@ -3093,10 +3093,10 @@ void wallet_local_htlc_out_delete(struct wallet *wallet, " AND origin_htlc = ?" " AND payment_hash = ?" " AND partid = ?;")); - db_bind_int(stmt, BIND_NEXT, DIRECTION_OUTGOING); - db_bind_int(stmt, BIND_NEXT, 0); - db_bind_sha256(stmt, BIND_NEXT, payment_hash); - db_bind_u64(stmt, BIND_NEXT, partid); + db_bind_int(stmt, DIRECTION_OUTGOING); + db_bind_int(stmt, 0); + db_bind_sha256(stmt, payment_hash); + db_bind_u64(stmt, partid); db_exec_prepared_v2(take(stmt)); } @@ -3144,9 +3144,9 @@ void wallet_payment_store(struct wallet *wallet, db_prepare_v2(wallet->db, SQL("SELECT status FROM payments" " WHERE payment_hash=?" " AND partid = ? AND groupid = ?;")); - db_bind_sha256(stmt, BIND_NEXT, &payment->payment_hash); - db_bind_u64(stmt, BIND_NEXT, payment->partid); - db_bind_u64(stmt, BIND_NEXT, payment->groupid); + db_bind_sha256(stmt, &payment->payment_hash); + db_bind_u64(stmt, payment->partid); + db_bind_u64(stmt, payment->groupid); db_query_prepared(stmt); res = db_step(stmt); assert(res); @@ -3180,57 +3180,57 @@ void wallet_payment_store(struct wallet *wallet, " paydescription" ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);")); - db_bind_int(stmt, BIND_NEXT, payment->status); - db_bind_sha256(stmt, BIND_NEXT, &payment->payment_hash); + db_bind_int(stmt, payment->status); + db_bind_sha256(stmt, &payment->payment_hash); if (payment->destination != NULL) - db_bind_node_id(stmt, BIND_NEXT, payment->destination); + db_bind_node_id(stmt, payment->destination); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); - db_bind_amount_msat(stmt, BIND_NEXT, &payment->msatoshi); - db_bind_int(stmt, BIND_NEXT, payment->timestamp); + db_bind_amount_msat(stmt, &payment->msatoshi); + db_bind_int(stmt, payment->timestamp); if (payment->path_secrets != NULL) - db_bind_secret_arr(stmt, BIND_NEXT, payment->path_secrets); + db_bind_secret_arr(stmt, payment->path_secrets); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); assert((payment->route_channels == NULL) == (payment->route_nodes == NULL)); if (payment->route_nodes) { - db_bind_node_id_arr(stmt, BIND_NEXT, payment->route_nodes); - db_bind_short_channel_id_arr(stmt, BIND_NEXT, payment->route_channels); + db_bind_node_id_arr(stmt, payment->route_nodes); + db_bind_short_channel_id_arr(stmt, payment->route_channels); } else { - db_bind_null(stmt, BIND_NEXT); - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); + db_bind_null(stmt); } - db_bind_amount_msat(stmt, BIND_NEXT, &payment->msatoshi_sent); + db_bind_amount_msat(stmt, &payment->msatoshi_sent); if (payment->label != NULL) - db_bind_text(stmt, BIND_NEXT, payment->label); + db_bind_text(stmt, payment->label); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); if (payment->invstring != NULL) - db_bind_text(stmt, BIND_NEXT, payment->invstring); + db_bind_text(stmt, payment->invstring); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); - db_bind_amount_msat(stmt, BIND_NEXT, &payment->total_msat); - db_bind_u64(stmt, BIND_NEXT, payment->partid); + db_bind_amount_msat(stmt, &payment->total_msat); + db_bind_u64(stmt, payment->partid); if (payment->local_invreq_id != NULL) - db_bind_sha256(stmt, BIND_NEXT, payment->local_invreq_id); + db_bind_sha256(stmt, payment->local_invreq_id); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); - db_bind_u64(stmt, BIND_NEXT, payment->groupid); + db_bind_u64(stmt, payment->groupid); if (payment->description != NULL) - db_bind_text(stmt, BIND_NEXT, payment->description); + db_bind_text(stmt, payment->description); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); db_exec_prepared_v2(stmt); payment->id = db_last_insert_id_v2(stmt); @@ -3253,7 +3253,7 @@ u64 wallet_payment_get_groupid(struct wallet *wallet, stmt = db_prepare_v2( wallet->db, SQL("SELECT MAX(groupid) FROM payments WHERE payment_hash = ?")); - db_bind_sha256(stmt, BIND_NEXT, payment_hash); + db_bind_sha256(stmt, payment_hash); db_query_prepared(stmt); if (db_step(stmt) && !db_col_is_null(stmt, "MAX(groupid)")) { groupid = db_col_u64(stmt, "MAX(groupid)"); @@ -3278,18 +3278,18 @@ void wallet_payment_delete(struct wallet *wallet, " AND groupid = ?" " AND partid = ?" " AND status = ?")); - db_bind_sha256(stmt, BIND_NEXT, payment_hash); - db_bind_u64(stmt, BIND_NEXT, *groupid); - db_bind_u64(stmt, BIND_NEXT, *partid); - db_bind_u64(stmt, BIND_NEXT, *status); + db_bind_sha256(stmt, payment_hash); + db_bind_u64(stmt, *groupid); + db_bind_u64(stmt, *partid); + db_bind_u64(stmt, *status); } else { assert(!partid); stmt = db_prepare_v2(wallet->db, SQL("DELETE FROM payments" " WHERE payment_hash = ?" " AND status = ?")); - db_bind_sha256(stmt, BIND_NEXT, payment_hash); - db_bind_u64(stmt, BIND_NEXT, *status); + db_bind_sha256(stmt, payment_hash); + db_bind_u64(stmt, *status); } db_exec_prepared_v2(take(stmt)); } @@ -3416,9 +3416,9 @@ wallet_payment_by_hash(const tal_t *ctx, struct wallet *wallet, " WHERE payment_hash = ?" " AND partid = ? AND groupid=?")); - db_bind_sha256(stmt, BIND_NEXT, payment_hash); - db_bind_u64(stmt, BIND_NEXT, partid); - db_bind_u64(stmt, BIND_NEXT, groupid); + db_bind_sha256(stmt, payment_hash); + db_bind_u64(stmt, partid); + db_bind_u64(stmt, groupid); db_query_prepared(stmt); if (db_step(stmt)) { payment = wallet_stmt2payment(ctx, stmt); @@ -3452,15 +3452,15 @@ void wallet_payment_set_status(struct wallet *wallet, SQL("UPDATE payments SET status=?, completed_at=? " "WHERE payment_hash=? AND partid=? AND groupid=?")); - db_bind_int(stmt, BIND_NEXT, payment_status_in_db(newstatus)); + db_bind_int(stmt, payment_status_in_db(newstatus)); if (completed_at != 0) { - db_bind_u64(stmt, BIND_NEXT, completed_at); + db_bind_u64(stmt, completed_at); } else { - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); } - db_bind_sha256(stmt, BIND_NEXT, payment_hash); - db_bind_u64(stmt, BIND_NEXT, partid); - db_bind_u64(stmt, BIND_NEXT, groupid); + db_bind_sha256(stmt, payment_hash); + db_bind_u64(stmt, partid); + db_bind_u64(stmt, groupid); db_exec_prepared_v2(take(stmt)); if (preimage) { @@ -3468,10 +3468,10 @@ void wallet_payment_set_status(struct wallet *wallet, SQL("UPDATE payments SET payment_preimage=? " "WHERE payment_hash=? AND partid=? AND groupid=?")); - db_bind_preimage(stmt, BIND_NEXT, preimage); - db_bind_sha256(stmt, BIND_NEXT, payment_hash); - db_bind_u64(stmt, BIND_NEXT, partid); - db_bind_u64(stmt, BIND_NEXT, groupid); + db_bind_preimage(stmt, preimage); + db_bind_sha256(stmt, payment_hash); + db_bind_u64(stmt, partid); + db_bind_u64(stmt, groupid); db_exec_prepared_v2(take(stmt)); } if (newstatus != PAYMENT_PENDING) { @@ -3482,9 +3482,9 @@ void wallet_payment_set_status(struct wallet *wallet, " , route_channels = NULL" " WHERE payment_hash = ?" " AND partid = ? AND groupid=?;")); - db_bind_sha256(stmt, BIND_NEXT, payment_hash); - db_bind_u64(stmt, BIND_NEXT, partid); - db_bind_u64(stmt, BIND_NEXT, groupid); + db_bind_sha256(stmt, payment_hash); + db_bind_u64(stmt, partid); + db_bind_u64(stmt, groupid); db_exec_prepared_v2(take(stmt)); } } @@ -3515,9 +3515,9 @@ void wallet_payment_get_failinfo(const tal_t *ctx, ", failupdate, faildetail, faildirection" " FROM payments" " WHERE payment_hash=? AND partid=? AND groupid=?;")); - db_bind_sha256(stmt, BIND_NEXT, payment_hash); - db_bind_u64(stmt, BIND_NEXT, partid); - db_bind_u64(stmt, BIND_NEXT, groupid); + db_bind_sha256(stmt, payment_hash); + db_bind_u64(stmt, partid); + db_bind_u64(stmt, groupid); db_query_prepared(stmt); resb = db_step(stmt); assert(resb); @@ -3579,35 +3579,35 @@ void wallet_payment_set_failinfo(struct wallet *wallet, " WHERE payment_hash=?" " AND partid=?;")); if (failonionreply) - db_bind_talarr(stmt, BIND_NEXT, failonionreply->contents); + db_bind_talarr(stmt, failonionreply->contents); else - db_bind_null(stmt, BIND_NEXT); - db_bind_int(stmt, BIND_NEXT, faildestperm ? 1 : 0); - db_bind_int(stmt, BIND_NEXT, failindex); - db_bind_int(stmt, BIND_NEXT, (int) failcode); + db_bind_null(stmt); + db_bind_int(stmt, faildestperm ? 1 : 0); + db_bind_int(stmt, failindex); + db_bind_int(stmt, (int) failcode); if (failnode) - db_bind_node_id(stmt, BIND_NEXT, failnode); + db_bind_node_id(stmt, failnode); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); if (failchannel) { - db_bind_short_channel_id(stmt, BIND_NEXT, failchannel); - db_bind_int(stmt, BIND_NEXT, faildirection); + db_bind_short_channel_id(stmt, failchannel); + db_bind_int(stmt, faildirection); } else { - db_bind_null(stmt, BIND_NEXT); - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); + db_bind_null(stmt); } - db_bind_talarr(stmt, BIND_NEXT, failupdate); + db_bind_talarr(stmt, failupdate); if (faildetail != NULL) - db_bind_text(stmt, BIND_NEXT, faildetail); + db_bind_text(stmt, faildetail); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); - db_bind_sha256(stmt, BIND_NEXT, payment_hash); - db_bind_u64(stmt, BIND_NEXT, partid); + db_bind_sha256(stmt, payment_hash); + db_bind_u64(stmt, partid); db_exec_prepared_v2(take(stmt)); } @@ -3650,7 +3650,7 @@ wallet_payment_list(const tal_t *ctx, " WHERE" " payment_hash = ?" " ORDER BY id;")); - db_bind_sha256(stmt, BIND_NEXT, payment_hash); + db_bind_sha256(stmt, payment_hash); } else { stmt = db_prepare_v2(wallet->db, SQL("SELECT" " id" @@ -3729,7 +3729,7 @@ wallet_payments_by_invoice_request(const tal_t *ctx, ", completed_at" " FROM payments" " WHERE local_invreq_id = ?;")); - db_bind_sha256(stmt, BIND_NEXT, local_invreq_id); + db_bind_sha256(stmt, local_invreq_id); db_query_prepared(stmt); for (i = 0; db_step(stmt); i++) { @@ -3755,7 +3755,7 @@ void wallet_htlc_sigs_save(struct wallet *w, u64 channel_id, /* Clear any existing HTLC sigs for this channel */ struct db_stmt *stmt = db_prepare_v2( w->db, SQL("DELETE FROM htlc_sigs WHERE channelid = ?")); - db_bind_u64(stmt, BIND_NEXT, channel_id); + db_bind_u64(stmt, channel_id); db_exec_prepared_v2(take(stmt)); /* Now insert the new ones */ @@ -3763,8 +3763,8 @@ void wallet_htlc_sigs_save(struct wallet *w, u64 channel_id, stmt = db_prepare_v2(w->db, SQL("INSERT INTO htlc_sigs (channelid, " "signature) VALUES (?, ?)")); - db_bind_u64(stmt, BIND_NEXT, channel_id); - db_bind_signature(stmt, BIND_NEXT, &htlc_sigs[i].s); + db_bind_u64(stmt, channel_id); + db_bind_signature(stmt, &htlc_sigs[i].s); db_exec_prepared_v2(take(stmt)); } } @@ -3799,7 +3799,7 @@ bool wallet_sanity_check(struct wallet *w) * that we are running */ stmt = db_prepare_v2(w->db, SQL("INSERT INTO vars (name, blobval) " "VALUES ('genesis_hash', ?);")); - db_bind_sha256d(stmt, BIND_NEXT, &chainparams->genesis_blockhash.shad); + db_bind_sha256d(stmt, &chainparams->genesis_blockhash.shad); db_exec_prepared_v2(take(stmt)); } @@ -3827,7 +3827,7 @@ bool wallet_sanity_check(struct wallet *w) /* Still a pristine wallet, claim it for the node_id we are now */ stmt = db_prepare_v2(w->db, SQL("INSERT INTO vars (name, blobval) " "VALUES ('node_id', ?);")); - db_bind_node_id(stmt, BIND_NEXT, &w->ld->id); + db_bind_node_id(stmt, &w->ld->id); db_exec_prepared_v2(take(stmt)); } return true; @@ -3843,7 +3843,7 @@ static void wallet_utxoset_prune(struct wallet *w, const u32 blockheight) stmt = db_prepare_v2( w->db, SQL("SELECT txid, outnum FROM utxoset WHERE spendheight < ?")); - db_bind_int(stmt, BIND_NEXT, blockheight - UTXO_PRUNE_DEPTH); + db_bind_int(stmt, blockheight - UTXO_PRUNE_DEPTH); db_query_prepared(stmt); while (db_step(stmt)) { @@ -3856,7 +3856,7 @@ static void wallet_utxoset_prune(struct wallet *w, const u32 blockheight) stmt = db_prepare_v2(w->db, SQL("DELETE FROM utxoset WHERE spendheight < ?")); - db_bind_int(stmt, BIND_NEXT, blockheight - UTXO_PRUNE_DEPTH); + db_bind_int(stmt, blockheight - UTXO_PRUNE_DEPTH); db_exec_prepared_v2(take(stmt)); } @@ -3866,12 +3866,12 @@ void wallet_block_add(struct wallet *w, struct block *b) db_prepare_v2(w->db, SQL("INSERT INTO blocks " "(height, hash, prev_hash) " "VALUES (?, ?, ?);")); - db_bind_int(stmt, BIND_NEXT, b->height); - db_bind_sha256d(stmt, BIND_NEXT, &b->blkid.shad); + db_bind_int(stmt, b->height); + db_bind_sha256d(stmt, &b->blkid.shad); if (b->prev) { - db_bind_sha256d(stmt, BIND_NEXT, &b->prev->blkid.shad); + db_bind_sha256d(stmt, &b->prev->blkid.shad); } else { - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); } db_exec_prepared_v2(take(stmt)); @@ -3883,13 +3883,13 @@ void wallet_block_remove(struct wallet *w, struct block *b) { struct db_stmt *stmt = db_prepare_v2(w->db, SQL("DELETE FROM blocks WHERE hash = ?")); - db_bind_sha256d(stmt, BIND_NEXT, &b->blkid.shad); + db_bind_sha256d(stmt, &b->blkid.shad); db_exec_prepared_v2(take(stmt)); /* Make sure that all descendants of the block are also deleted */ stmt = db_prepare_v2(w->db, SQL("SELECT * FROM blocks WHERE height >= ?;")); - db_bind_int(stmt, BIND_NEXT, b->height); + db_bind_int(stmt, b->height); db_query_prepared(stmt); assert(!db_step(stmt)); tal_free(stmt); @@ -3899,7 +3899,7 @@ void wallet_blocks_rollback(struct wallet *w, u32 height) { struct db_stmt *stmt = db_prepare_v2(w->db, SQL("DELETE FROM blocks " "WHERE height > ?")); - db_bind_int(stmt, BIND_NEXT, height); + db_bind_int(stmt, height); db_exec_prepared_v2(take(stmt)); } @@ -3915,10 +3915,10 @@ bool wallet_outpoint_spend(struct wallet *w, const tal_t *ctx, const u32 blockhe "WHERE prev_out_tx = ?" " AND prev_out_index = ?")); - db_bind_int(stmt, BIND_NEXT, blockheight); - db_bind_int(stmt, BIND_NEXT, output_status_in_db(OUTPUT_STATE_SPENT)); - db_bind_txid(stmt, BIND_NEXT, &outpoint->txid); - db_bind_int(stmt, BIND_NEXT, outpoint->n); + db_bind_int(stmt, blockheight); + db_bind_int(stmt, output_status_in_db(OUTPUT_STATE_SPENT)); + db_bind_txid(stmt, &outpoint->txid); + db_bind_int(stmt, outpoint->n); db_exec_prepared_v2(take(stmt)); @@ -3932,9 +3932,9 @@ bool wallet_outpoint_spend(struct wallet *w, const tal_t *ctx, const u32 blockhe "WHERE txid = ?" " AND outnum = ?")); - db_bind_int(stmt, BIND_NEXT, blockheight); - db_bind_txid(stmt, BIND_NEXT, &outpoint->txid); - db_bind_int(stmt, BIND_NEXT, outpoint->n); + db_bind_int(stmt, blockheight); + db_bind_txid(stmt, &outpoint->txid); + db_bind_int(stmt, outpoint->n); db_exec_prepared_v2(stmt); tal_free(stmt); } @@ -3958,13 +3958,13 @@ void wallet_utxoset_add(struct wallet *w, " scriptpubkey," " satoshis" ") VALUES(?, ?, ?, ?, ?, ?, ?);")); - db_bind_txid(stmt, BIND_NEXT, &outpoint->txid); - db_bind_int(stmt, BIND_NEXT, outpoint->n); - db_bind_int(stmt, BIND_NEXT, blockheight); - db_bind_null(stmt, BIND_NEXT); - db_bind_int(stmt, BIND_NEXT, txindex); - db_bind_talarr(stmt, BIND_NEXT, scriptpubkey); - db_bind_amount_sat(stmt, BIND_NEXT, &sat); + db_bind_txid(stmt, &outpoint->txid); + db_bind_int(stmt, outpoint->n); + db_bind_int(stmt, blockheight); + db_bind_null(stmt); + db_bind_int(stmt, txindex); + db_bind_talarr(stmt, scriptpubkey); + db_bind_amount_sat(stmt, &sat); db_exec_prepared_v2(take(stmt)); outpointfilter_add(w->utxoset_outpoints, outpoint); @@ -3979,9 +3979,9 @@ void wallet_filteredblock_add(struct wallet *w, const struct filteredblock *fb) stmt = db_prepare_v2(w->db, SQL("INSERT INTO blocks " "(height, hash, prev_hash) " "VALUES (?, ?, ?);")); - db_bind_int(stmt, BIND_NEXT, fb->height); - db_bind_sha256d(stmt, BIND_NEXT, &fb->id.shad); - db_bind_sha256d(stmt, BIND_NEXT, &fb->prev_hash.shad); + db_bind_int(stmt, fb->height); + db_bind_sha256d(stmt, &fb->id.shad); + db_bind_sha256d(stmt, &fb->prev_hash.shad); db_exec_prepared_v2(take(stmt)); for (size_t i = 0; i < tal_count(fb->outpoints); i++) { @@ -3996,13 +3996,13 @@ void wallet_filteredblock_add(struct wallet *w, const struct filteredblock *fb) " scriptpubkey," " satoshis" ") VALUES(?, ?, ?, ?, ?, ?, ?);")); - db_bind_txid(stmt, BIND_NEXT, &o->outpoint.txid); - db_bind_int(stmt, BIND_NEXT, o->outpoint.n); - db_bind_int(stmt, BIND_NEXT, fb->height); - db_bind_null(stmt, BIND_NEXT); - db_bind_int(stmt, BIND_NEXT, o->txindex); - db_bind_talarr(stmt, BIND_NEXT, o->scriptPubKey); - db_bind_amount_sat(stmt, BIND_NEXT, &o->amount); + db_bind_txid(stmt, &o->outpoint.txid); + db_bind_int(stmt, o->outpoint.n); + db_bind_int(stmt, fb->height); + db_bind_null(stmt); + db_bind_int(stmt, o->txindex); + db_bind_talarr(stmt, o->scriptPubKey); + db_bind_amount_sat(stmt, &o->amount); db_exec_prepared_v2(take(stmt)); outpointfilter_add(w->utxoset_outpoints, &o->outpoint); @@ -4014,7 +4014,7 @@ bool wallet_have_block(struct wallet *w, u32 blockheight) bool result; struct db_stmt *stmt = db_prepare_v2( w->db, SQL("SELECT height FROM blocks WHERE height = ?")); - db_bind_int(stmt, BIND_NEXT, blockheight); + db_bind_int(stmt, blockheight); db_query_prepared(stmt); result = db_step(stmt); if (result) @@ -4038,9 +4038,9 @@ struct outpoint *wallet_outpoint_for_scid(struct wallet *w, tal_t *ctx, " AND txindex = ?" " AND outnum = ?" " AND spendheight IS NULL")); - db_bind_int(stmt, BIND_NEXT, short_channel_id_blocknum(scid)); - db_bind_int(stmt, BIND_NEXT, short_channel_id_txnum(scid)); - db_bind_int(stmt, BIND_NEXT, short_channel_id_outnum(scid)); + db_bind_int(stmt, short_channel_id_blocknum(scid)); + db_bind_int(stmt, short_channel_id_txnum(scid)); + db_bind_int(stmt, short_channel_id_outnum(scid)); db_query_prepared(stmt); if (!db_step(stmt)) { @@ -4097,7 +4097,7 @@ wallet_utxoset_get_spent(const tal_t *ctx, struct wallet *w, " outnum " "FROM utxoset " "WHERE spendheight = ?")); - db_bind_int(stmt, BIND_NEXT, blockheight); + db_bind_int(stmt, blockheight); db_query_prepared(stmt); return db_scids(ctx, stmt); @@ -4114,7 +4114,7 @@ wallet_utxoset_get_created(const tal_t *ctx, struct wallet *w, " outnum " "FROM utxoset " "WHERE blockheight = ?")); - db_bind_int(stmt, BIND_NEXT, blockheight); + db_bind_int(stmt, blockheight); db_query_prepared(stmt); return db_scids(ctx, stmt); @@ -4128,7 +4128,7 @@ void wallet_transaction_add(struct wallet *w, const struct wally_tx *tx, w->db, SQL("SELECT blockheight FROM transactions WHERE id=?")); wally_txid(tx, &txid); - db_bind_txid(stmt, BIND_NEXT, &txid); + db_bind_txid(stmt, &txid); db_query_prepared(stmt); if (!db_step(stmt)) { @@ -4140,15 +4140,15 @@ void wallet_transaction_add(struct wallet *w, const struct wally_tx *tx, ", blockheight" ", txindex" ", rawtx) VALUES (?, ?, ?, ?);")); - db_bind_txid(stmt, BIND_NEXT, &txid); + db_bind_txid(stmt, &txid); if (blockheight) { - db_bind_int(stmt, BIND_NEXT, blockheight); - db_bind_int(stmt, BIND_NEXT, txindex); + db_bind_int(stmt, blockheight); + db_bind_int(stmt, txindex); } else { - db_bind_null(stmt, BIND_NEXT); - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); + db_bind_null(stmt); } - db_bind_tx(stmt, BIND_NEXT, tx); + db_bind_tx(stmt, tx); db_exec_prepared_v2(take(stmt)); } else { db_col_ignore(stmt, "blockheight"); @@ -4160,9 +4160,9 @@ void wallet_transaction_add(struct wallet *w, const struct wally_tx *tx, SQL("UPDATE transactions " "SET blockheight = ?, txindex = ? " "WHERE id = ?")); - db_bind_int(stmt, BIND_NEXT, blockheight); - db_bind_int(stmt, BIND_NEXT, txindex); - db_bind_txid(stmt, BIND_NEXT, &txid); + db_bind_int(stmt, blockheight); + db_bind_int(stmt, txindex); + db_bind_txid(stmt, &txid); db_exec_prepared_v2(take(stmt)); } } @@ -4178,14 +4178,14 @@ static void wallet_annotation_add(struct wallet *w, const struct bitcoin_txid *t "(txid, idx, location, type, channel) " "VALUES (?, ?, ?, ?, ?) ON CONFLICT(txid,idx) DO NOTHING;")); - db_bind_txid(stmt, BIND_NEXT, txid); - db_bind_int(stmt, BIND_NEXT, num); - db_bind_int(stmt, BIND_NEXT, annotation_type); - db_bind_int(stmt, BIND_NEXT, type); + db_bind_txid(stmt, txid); + db_bind_int(stmt, num); + db_bind_int(stmt, annotation_type); + db_bind_int(stmt, type); if (channel != 0) - db_bind_u64(stmt, BIND_NEXT, channel); + db_bind_u64(stmt, channel); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); db_exec_prepared_v2(take(stmt)); } @@ -4209,7 +4209,7 @@ struct bitcoin_tx *wallet_transaction_get(const tal_t *ctx, struct wallet *w, struct bitcoin_tx *tx; struct db_stmt *stmt = db_prepare_v2( w->db, SQL("SELECT rawtx FROM transactions WHERE id=?")); - db_bind_txid(stmt, BIND_NEXT, txid); + db_bind_txid(stmt, txid); db_query_prepared(stmt); if (!db_step(stmt)) { @@ -4231,7 +4231,7 @@ u32 wallet_transaction_height(struct wallet *w, const struct bitcoin_txid *txid) u32 blockheight; struct db_stmt *stmt = db_prepare_v2( w->db, SQL("SELECT blockheight FROM transactions WHERE id=?")); - db_bind_txid(stmt, BIND_NEXT, txid); + db_bind_txid(stmt, txid); db_query_prepared(stmt); if (!db_step(stmt)) { @@ -4255,7 +4255,7 @@ struct txlocator *wallet_transaction_locate(const tal_t *ctx, struct wallet *w, stmt = db_prepare_v2( w->db, SQL("SELECT blockheight, txindex FROM transactions WHERE id=?")); - db_bind_txid(stmt, BIND_NEXT, txid); + db_bind_txid(stmt, txid); db_query_prepared(stmt); if (!db_step(stmt)) { @@ -4284,7 +4284,7 @@ struct bitcoin_txid *wallet_transactions_by_height(const tal_t *ctx, int count = 0; stmt = db_prepare_v2( w->db, SQL("SELECT id FROM transactions WHERE blockheight=?")); - db_bind_int(stmt, BIND_NEXT, blockheight); + db_bind_int(stmt, blockheight); db_query_prepared(stmt); while (db_step(stmt)) { @@ -4309,11 +4309,11 @@ void wallet_channeltxs_add(struct wallet *w, struct channel *chan, ", input_num" ", blockheight" ") VALUES (?, ?, ?, ?, ?);")); - db_bind_int(stmt, BIND_NEXT, chan->dbid); - db_bind_int(stmt, BIND_NEXT, type); - db_bind_sha256(stmt, BIND_NEXT, &txid->shad.sha); - db_bind_int(stmt, BIND_NEXT, input_num); - db_bind_int(stmt, BIND_NEXT, blockheight); + db_bind_int(stmt, chan->dbid); + db_bind_int(stmt, type); + db_bind_sha256(stmt, &txid->shad.sha); + db_bind_int(stmt, input_num); + db_bind_int(stmt, blockheight); db_exec_prepared_v2(take(stmt)); } @@ -4327,7 +4327,7 @@ u32 *wallet_onchaind_channels(struct wallet *w, stmt = db_prepare_v2( w->db, SQL("SELECT DISTINCT(channel_id) FROM channeltxs WHERE type = ?;")); - db_bind_int(stmt, BIND_NEXT, WIRE_ONCHAIND_INIT); + db_bind_int(stmt, WIRE_ONCHAIND_INIT); db_query_prepared(stmt); while (db_step(stmt)) { @@ -4358,7 +4358,7 @@ struct channeltx *wallet_channeltxs_get(struct wallet *w, const tal_t *ctx, "JOIN transactions t ON t.id = c.transaction_id " "WHERE c.channel_id = ? " "ORDER BY c.id ASC;")); - db_bind_int(stmt, BIND_NEXT, channel_id); + db_bind_int(stmt, channel_id); db_query_prepared(stmt); while (db_step(stmt)) { @@ -4401,36 +4401,36 @@ static bool wallet_forwarded_payment_update(struct wallet *w, ", failcode=?" ", forward_style=?" " WHERE in_htlc_id=? AND in_channel_scid=?")); - db_bind_amount_msat(stmt, BIND_NEXT, &in->msat); + db_bind_amount_msat(stmt, &in->msat); if (out) { - db_bind_amount_msat(stmt, BIND_NEXT, &out->msat); + db_bind_amount_msat(stmt, &out->msat); } else { - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); } - db_bind_int(stmt, BIND_NEXT, wallet_forward_status_in_db(state)); + db_bind_int(stmt, wallet_forward_status_in_db(state)); if (resolved_time != NULL) { - db_bind_timeabs(stmt, BIND_NEXT, *resolved_time); + db_bind_timeabs(stmt, *resolved_time); } else { - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); } if (failcode != 0) { assert(state == FORWARD_FAILED || state == FORWARD_LOCAL_FAILED); - db_bind_int(stmt, BIND_NEXT, (int)failcode); + db_bind_int(stmt, (int)failcode); } else { - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); } /* This can happen for malformed onions, reload from db. */ if (forward_style == FORWARD_STYLE_UNKNOWN) - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); else - db_bind_int(stmt, BIND_NEXT, forward_style_in_db(forward_style)); - db_bind_u64(stmt, BIND_NEXT, in->key.id); - db_bind_short_channel_id(stmt, BIND_NEXT, channel_scid_or_local_alias(in->key.channel)); + db_bind_int(stmt, forward_style_in_db(forward_style)); + db_bind_u64(stmt, in->key.id); + db_bind_short_channel_id(stmt, channel_scid_or_local_alias(in->key.channel)); db_exec_prepared_v2(stmt); changed = db_count_changes(stmt) != 0; tal_free(stmt); @@ -4472,7 +4472,7 @@ void wallet_forwarded_payment_add(struct wallet *w, const struct htlc_in *in, ", failcode" ", forward_style" ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);")); - db_bind_u64(stmt, BIND_NEXT, in->key.id); + db_bind_u64(stmt, in->key.id); /* FORWARD_LOCAL_FAILED may occur before we get htlc_out */ if (!out || !scid_out) { @@ -4481,46 +4481,46 @@ void wallet_forwarded_payment_add(struct wallet *w, const struct htlc_in *in, } if (out) - db_bind_u64(stmt, BIND_NEXT, out->key.id); + db_bind_u64(stmt, out->key.id); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); /* We use the LOCAL alias, since that's under our control, and * we keep it stable, whereas the REMOTE alias is likely what * the sender used to specify the channel, but that's under * control of the remote end. */ assert(in->key.channel->scid != NULL || in->key.channel->alias[LOCAL]); - db_bind_short_channel_id(stmt, BIND_NEXT, channel_scid_or_local_alias(in->key.channel)); + db_bind_short_channel_id(stmt, channel_scid_or_local_alias(in->key.channel)); if (scid_out) - db_bind_short_channel_id(stmt, BIND_NEXT, scid_out); + db_bind_short_channel_id(stmt, scid_out); else - db_bind_null(stmt, BIND_NEXT); - db_bind_amount_msat(stmt, BIND_NEXT, &in->msat); + db_bind_null(stmt); + db_bind_amount_msat(stmt, &in->msat); if (out) - db_bind_amount_msat(stmt, BIND_NEXT, &out->msat); + db_bind_amount_msat(stmt, &out->msat); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); - db_bind_int(stmt, BIND_NEXT, wallet_forward_status_in_db(state)); - db_bind_timeabs(stmt, BIND_NEXT, in->received_time); + db_bind_int(stmt, wallet_forward_status_in_db(state)); + db_bind_timeabs(stmt, in->received_time); if (resolved_time != NULL) - db_bind_timeabs(stmt, BIND_NEXT, *resolved_time); + db_bind_timeabs(stmt, *resolved_time); else - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); if (failcode != 0) { assert(state == FORWARD_FAILED || state == FORWARD_LOCAL_FAILED); - db_bind_int(stmt, BIND_NEXT, (int)failcode); + db_bind_int(stmt, (int)failcode); } else { - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); } /* This can happen for malformed onions, reload from db! */ if (forward_style == FORWARD_STYLE_UNKNOWN) - db_bind_null(stmt, BIND_NEXT); + db_bind_null(stmt); else - db_bind_int(stmt, BIND_NEXT, forward_style_in_db(forward_style)); + db_bind_int(stmt, forward_style_in_db(forward_style)); db_exec_prepared_v2(take(stmt)); @@ -4539,7 +4539,7 @@ struct amount_msat wallet_total_forward_fees(struct wallet *w) " CAST(COALESCE(SUM(in_msatoshi - out_msatoshi), 0) AS BIGINT)" " FROM forwards " "WHERE state = ?;")); - db_bind_int(stmt, BIND_NEXT, wallet_forward_status_in_db(FORWARD_SETTLED)); + db_bind_int(stmt, wallet_forward_status_in_db(FORWARD_SETTLED)); db_query_prepared(stmt); res = db_step(stmt); @@ -4611,32 +4611,32 @@ const struct forwarding *wallet_forwarded_payments_get(struct wallet *w, if (status == FORWARD_ANY) { // any status - db_bind_int(stmt, BIND_NEXT, 1); - db_bind_int(stmt, BIND_NEXT, any); + db_bind_int(stmt, 1); + db_bind_int(stmt, any); } else { // specific forward status - db_bind_int(stmt, BIND_NEXT, 0); - db_bind_int(stmt, BIND_NEXT, status); + db_bind_int(stmt, 0); + db_bind_int(stmt, status); } if (chan_in) { // specific in_channel - db_bind_int(stmt, BIND_NEXT, 0); - db_bind_short_channel_id(stmt, BIND_NEXT, chan_in); + db_bind_int(stmt, 0); + db_bind_short_channel_id(stmt, chan_in); } else { // any in_channel - db_bind_int(stmt, BIND_NEXT, 1); - db_bind_int(stmt, BIND_NEXT, any); + db_bind_int(stmt, 1); + db_bind_int(stmt, any); } if (chan_out) { // specific out_channel - db_bind_int(stmt, BIND_NEXT, 0); - db_bind_short_channel_id(stmt, BIND_NEXT, chan_out); + db_bind_int(stmt, 0); + db_bind_short_channel_id(stmt, chan_out); } else { // any out_channel - db_bind_int(stmt, BIND_NEXT, 1); - db_bind_int(stmt, BIND_NEXT, any); + db_bind_int(stmt, 1); + db_bind_int(stmt, any); } db_query_prepared(stmt); @@ -4736,9 +4736,9 @@ bool wallet_forward_delete(struct wallet *w, " WHERE in_channel_scid = ?" " AND in_htlc_id = ?" " AND state = ?;")); - db_bind_short_channel_id(stmt, BIND_NEXT, chan_in); - db_bind_u64(stmt, BIND_NEXT, *htlc_id); - db_bind_int(stmt, BIND_NEXT, wallet_forward_status_in_db(FORWARD_SETTLED)); + db_bind_short_channel_id(stmt, chan_in); + db_bind_u64(stmt, *htlc_id); + db_bind_int(stmt, wallet_forward_status_in_db(FORWARD_SETTLED)); } else { stmt = db_prepare_v2(w->db, SQL("SELECT" " CAST(COALESCE(SUM(in_msatoshi - out_msatoshi), 0) AS BIGINT)" @@ -4746,8 +4746,8 @@ bool wallet_forward_delete(struct wallet *w, " WHERE in_channel_scid = ?" " AND in_htlc_id IS NULL" " AND state = ?;")); - db_bind_short_channel_id(stmt, BIND_NEXT, chan_in); - db_bind_int(stmt, BIND_NEXT, wallet_forward_status_in_db(FORWARD_SETTLED)); + db_bind_short_channel_id(stmt, chan_in); + db_bind_int(stmt, wallet_forward_status_in_db(FORWARD_SETTLED)); } db_query_prepared(stmt); @@ -4769,17 +4769,17 @@ bool wallet_forward_delete(struct wallet *w, " WHERE in_channel_scid = ?" " AND in_htlc_id = ?" " AND state = ?")); - db_bind_short_channel_id(stmt, BIND_NEXT, chan_in); - db_bind_u64(stmt, BIND_NEXT, *htlc_id); - db_bind_int(stmt, BIND_NEXT, wallet_forward_status_in_db(state)); + db_bind_short_channel_id(stmt, chan_in); + db_bind_u64(stmt, *htlc_id); + db_bind_int(stmt, wallet_forward_status_in_db(state)); } else { stmt = db_prepare_v2(w->db, SQL("DELETE FROM forwards" " WHERE in_channel_scid = ?" " AND in_htlc_id IS NULL" " AND state = ?")); - db_bind_short_channel_id(stmt, BIND_NEXT, chan_in); - db_bind_int(stmt, BIND_NEXT, wallet_forward_status_in_db(state)); + db_bind_short_channel_id(stmt, chan_in); + db_bind_int(stmt, wallet_forward_status_in_db(state)); } db_exec_prepared_v2(stmt); changed = db_count_changes(stmt) != 0; @@ -4844,11 +4844,11 @@ void wallet_penalty_base_add(struct wallet *w, u64 chan_id, ", amount" ") VALUES (?, ?, ?, ?, ?);")); - db_bind_u64(stmt, BIND_NEXT, chan_id); - db_bind_u64(stmt, BIND_NEXT, pb->commitment_num); - db_bind_txid(stmt, BIND_NEXT, &pb->txid); - db_bind_int(stmt, BIND_NEXT, pb->outnum); - db_bind_amount_sat(stmt, BIND_NEXT, &pb->amount); + db_bind_u64(stmt, chan_id); + db_bind_u64(stmt, pb->commitment_num); + db_bind_txid(stmt, &pb->txid); + db_bind_int(stmt, pb->outnum); + db_bind_amount_sat(stmt, &pb->amount); db_exec_prepared_v2(take(stmt)); } @@ -4865,7 +4865,7 @@ struct penalty_base *wallet_penalty_base_load_for_channel(const tal_t *ctx, "FROM penalty_bases " "WHERE channel_id = ?")); - db_bind_u64(stmt, BIND_NEXT, chan_id); + db_bind_u64(stmt, chan_id); db_query_prepared(stmt); while (db_step(stmt)) { @@ -4887,8 +4887,8 @@ void wallet_penalty_base_delete(struct wallet *w, u64 chan_id, u64 commitnum) w->db, SQL("DELETE FROM penalty_bases " "WHERE channel_id = ? AND commitnum = ?")); - db_bind_u64(stmt, BIND_NEXT, chan_id); - db_bind_u64(stmt, BIND_NEXT, commitnum); + db_bind_u64(stmt, chan_id); + db_bind_u64(stmt, commitnum); db_exec_prepared_v2(take(stmt)); } @@ -4906,7 +4906,7 @@ bool wallet_offer_create(struct wallet *w, stmt = db_prepare_v2(w->db, SQL("SELECT 1" " FROM offers" " WHERE offer_id = ?;")); - db_bind_sha256(stmt, BIND_NEXT, offer_id); + db_bind_sha256(stmt, offer_id); db_query_prepared(stmt); if (db_step(stmt)) { @@ -4924,13 +4924,13 @@ bool wallet_offer_create(struct wallet *w, ", status" ") VALUES (?, ?, ?, ?);")); - db_bind_sha256(stmt, BIND_NEXT, offer_id); - db_bind_text(stmt, BIND_NEXT, bolt12); + db_bind_sha256(stmt, offer_id); + db_bind_text(stmt, bolt12); if (label) - db_bind_json_escape(stmt, BIND_NEXT, label); + db_bind_json_escape(stmt, label); else - db_bind_null(stmt, BIND_NEXT); - db_bind_int(stmt, BIND_NEXT, offer_status_in_db(status)); + db_bind_null(stmt); + db_bind_int(stmt, offer_status_in_db(status)); db_exec_prepared_v2(take(stmt)); return true; } @@ -4947,7 +4947,7 @@ char *wallet_offer_find(const tal_t *ctx, stmt = db_prepare_v2(w->db, SQL("SELECT bolt12, label, status" " FROM offers" " WHERE offer_id = ?;")); - db_bind_sha256(stmt, BIND_NEXT, offer_id); + db_bind_sha256(stmt, offer_id); db_query_prepared(stmt); if (!db_step(stmt)) { @@ -5006,8 +5006,8 @@ static void offer_status_update(struct db *db, stmt = db_prepare_v2(db, SQL("UPDATE offers" " SET status=?" " WHERE offer_id = ?;")); - db_bind_int(stmt, BIND_NEXT, offer_status_in_db(newstatus)); - db_bind_sha256(stmt, BIND_NEXT, offer_id); + db_bind_int(stmt, offer_status_in_db(newstatus)); + db_bind_sha256(stmt, offer_id); db_exec_prepared_v2(take(stmt)); if (!offer_status_active(oldstatus) @@ -5017,9 +5017,9 @@ static void offer_status_update(struct db *db, stmt = db_prepare_v2(db, SQL("UPDATE invoices" " SET state=?" " WHERE state=? AND local_offer_id = ?;")); - db_bind_int(stmt, BIND_NEXT, invoice_status_in_db(EXPIRED)); - db_bind_int(stmt, BIND_NEXT, invoice_status_in_db(UNPAID)); - db_bind_sha256(stmt, BIND_NEXT, offer_id); + db_bind_int(stmt, invoice_status_in_db(EXPIRED)); + db_bind_int(stmt, invoice_status_in_db(UNPAID)); + db_bind_sha256(stmt, offer_id); db_exec_prepared_v2(take(stmt)); } @@ -5045,7 +5045,7 @@ void wallet_offer_mark_used(struct db *db, const struct sha256 *offer_id) stmt = db_prepare_v2(db, SQL("SELECT status" " FROM offers" " WHERE offer_id = ?;")); - db_bind_sha256(stmt, BIND_NEXT, offer_id); + db_bind_sha256(stmt, offer_id); db_query_prepared(stmt); if (!db_step(stmt)) fatal("%s: unknown offer_id %s", @@ -5086,7 +5086,7 @@ bool wallet_invoice_request_create(struct wallet *w, stmt = db_prepare_v2(w->db, SQL("SELECT 1" " FROM invoicerequests" " WHERE invreq_id = ?;")); - db_bind_sha256(stmt, BIND_NEXT, invreq_id); + db_bind_sha256(stmt, invreq_id); db_query_prepared(stmt); if (db_step(stmt)) { @@ -5104,13 +5104,13 @@ bool wallet_invoice_request_create(struct wallet *w, ", status" ") VALUES (?, ?, ?, ?);")); - db_bind_sha256(stmt, BIND_NEXT, invreq_id); - db_bind_text(stmt, BIND_NEXT, bolt12); + db_bind_sha256(stmt, invreq_id); + db_bind_text(stmt, bolt12); if (label) - db_bind_json_escape(stmt, BIND_NEXT, label); + db_bind_json_escape(stmt, label); else - db_bind_null(stmt, BIND_NEXT); - db_bind_int(stmt, BIND_NEXT, offer_status_in_db(status)); + db_bind_null(stmt); + db_bind_int(stmt, offer_status_in_db(status)); db_exec_prepared_v2(take(stmt)); return true; } @@ -5127,7 +5127,7 @@ char *wallet_invoice_request_find(const tal_t *ctx, stmt = db_prepare_v2(w->db, SQL("SELECT bolt12, label, status" " FROM invoicerequests" " WHERE invreq_id = ?;")); - db_bind_sha256(stmt, BIND_NEXT, invreq_id); + db_bind_sha256(stmt, invreq_id); db_query_prepared(stmt); if (!db_step(stmt)) { @@ -5185,8 +5185,8 @@ static void invoice_request_status_update(struct db *db, stmt = db_prepare_v2(db, SQL("UPDATE invoicerequests" " SET status=?" " WHERE invreq_id = ?;")); - db_bind_int(stmt, BIND_NEXT, offer_status_in_db(newstatus)); - db_bind_sha256(stmt, BIND_NEXT, invreq_id); + db_bind_int(stmt, offer_status_in_db(newstatus)); + db_bind_sha256(stmt, invreq_id); db_exec_prepared_v2(take(stmt)); } @@ -5212,7 +5212,7 @@ void wallet_invoice_request_mark_used(struct db *db, const struct sha256 *invreq stmt = db_prepare_v2(db, SQL("SELECT status" " FROM invoicerequests" " WHERE invreq_id = ?;")); - db_bind_sha256(stmt, BIND_NEXT, invreq_id); + db_bind_sha256(stmt, invreq_id); db_query_prepared(stmt); if (!db_step(stmt)) fatal("%s: unknown invreq_id %s", @@ -5241,14 +5241,13 @@ void wallet_invoice_request_mark_used(struct db *db, const struct sha256 *invreq /* We join key parts with nuls for now. */ static void db_bind_datastore_key(struct db_stmt *stmt, - int pos, const char **key) { u8 *joined; size_t len; if (tal_count(key) == 1) { - db_bind_blob(stmt, pos, (u8 *)key[0], strlen(key[0])); + db_bind_blob(stmt, (u8 *)key[0], strlen(key[0])); return; } @@ -5260,7 +5259,7 @@ static void db_bind_datastore_key(struct db_stmt *stmt, memcpy(joined + len + 1, key[i], strlen(key[i])); len += 1 + strlen(key[i]); } - db_bind_blob(stmt, pos, joined, len); + db_bind_blob(stmt, joined, len); } static const char **db_col_datastore_key(const tal_t *ctx, @@ -5294,8 +5293,8 @@ void wallet_datastore_update(struct wallet *w, const char **key, const u8 *data) stmt = db_prepare_v2(w->db, SQL("UPDATE datastore SET data=?, generation=generation+1 WHERE key=?;")); - db_bind_talarr(stmt, BIND_NEXT, data); - db_bind_datastore_key(stmt, BIND_NEXT, key); + db_bind_talarr(stmt, data); + db_bind_datastore_key(stmt, key); db_exec_prepared_v2(take(stmt)); } @@ -5306,8 +5305,8 @@ void wallet_datastore_create(struct wallet *w, const char **key, const u8 *data) stmt = db_prepare_v2(w->db, SQL("INSERT INTO datastore VALUES (?, ?, 0);")); - db_bind_datastore_key(stmt, BIND_NEXT, key); - db_bind_talarr(stmt, BIND_NEXT, data); + db_bind_datastore_key(stmt, key); + db_bind_talarr(stmt, data); db_exec_prepared_v2(take(stmt)); } @@ -5317,7 +5316,7 @@ void wallet_datastore_remove(struct wallet *w, const char **key) stmt = db_prepare_v2(w->db, SQL("DELETE FROM datastore" " WHERE key = ?")); - db_bind_datastore_key(stmt, BIND_NEXT, key); + db_bind_datastore_key(stmt, key); db_exec_prepared_v2(take(stmt)); } @@ -5336,7 +5335,7 @@ struct db_stmt *wallet_datastore_first(const tal_t *ctx, " FROM datastore" " WHERE key >= ?" " ORDER BY key;")); - db_bind_datastore_key(stmt, BIND_NEXT, startkey); + db_bind_datastore_key(stmt, startkey); } else { stmt = db_prepare_v2(w->db, SQL("SELECT key, data, generation" @@ -5407,7 +5406,7 @@ struct wallet_htlc_iter *wallet_htlcs_first(const tal_t *ctx, " FROM channel_htlcs h" " WHERE channel_id = ?" " ORDER BY id ASC")); - db_bind_u64(i->stmt, BIND_NEXT, chan->dbid); + db_bind_u64(i->stmt, chan->dbid); } else { i->scid.u64 = 0; i->stmt = db_prepare_v2(w->db,