Allow routing by older scids when we splice

bitcoin/short_channel_id.c

@@ -1,6 +1,7 @@
 #include "config.h"
 #include <bitcoin/short_channel_id.h>
 #include <ccan/tal/str/str.h>
+#include <sodium/randombytes.h>
 #include <stdio.h>
 #include <wire/wire.h>
 
@@ -99,3 +100,10 @@ struct short_channel_id fromwire_short_channel_id(const u8 **cursor, size_t *max
 	scid.u64 = fromwire_u64(cursor, max);
 	return scid;
 }
+
+struct short_channel_id random_scid(void)
+{
+	struct short_channel_id scid;
+	randombytes_buf(&scid, sizeof(scid));
+	return scid;
+}

bitcoin/short_channel_id.h

@@ -98,4 +98,6 @@ void towire_short_channel_id(u8 **pptr,
 			     struct short_channel_id short_channel_id);
 struct short_channel_id fromwire_short_channel_id(const u8 **cursor, size_t *max);
 
+/* Set to random bytes */
+struct short_channel_id random_scid(void);
 #endif /* LIGHTNING_BITCOIN_SHORT_CHANNEL_ID_H */

lightningd/channel.c

@@ -17,7 +17,6 @@
 #include <lightningd/opening_common.h>
 #include <lightningd/peer_control.h>
 #include <lightningd/subd.h>
-#include <sodium/randombytes.h>
 #include <wallet/txfilter.h>
 #include <wire/peer_wire.h>
 
@@ -254,6 +253,65 @@ struct channel_type *desired_channel_type(const tal_t *ctx,
 	return channel_type_static_remotekey(ctx);
 }
 
+static void chanmap_remove(struct lightningd *ld,
+			   const struct channel *channel,
+			   struct short_channel_id scid)
+{
+	struct scid_to_channel *scc = channel_scid_map_get(ld->channels_by_scid, scid);
+	assert(scc->channel == channel);
+	tal_free(scc);
+}
+
+static void destroy_scid_to_channel(struct scid_to_channel *scc,
+				    struct lightningd *ld)
+{
+	if (!channel_scid_map_del(ld->channels_by_scid, scc))
+		abort();
+}
+
+static void chanmap_add(struct lightningd *ld,
+			struct channel *channel,
+			struct short_channel_id scid)
+{
+	struct scid_to_channel *scc = tal(channel, struct scid_to_channel);
+	scc->channel = channel;
+	scc->scid = scid;
+	channel_scid_map_add(ld->channels_by_scid, scc);
+	tal_add_destructor2(scc, destroy_scid_to_channel, ld);
+}
+
+void channel_set_scid(struct channel *channel, const struct short_channel_id *new_scid)
+{
+	struct lightningd *ld = channel->peer->ld;
+
+	/* Get rid of old one (if any) */
+	if (channel->scid != NULL) {
+		chanmap_remove(ld, channel, *channel->scid);
+		channel->scid = tal_free(channel->scid);
+	}
+
+	/* Add new one (if any) */
+	if (new_scid) {
+		channel->scid = tal_dup(channel, struct short_channel_id, new_scid);
+		chanmap_add(ld, channel, *new_scid);
+	}
+}
+
+void channel_add_old_scid(struct channel *channel,
+			  struct short_channel_id old_scid)
+{
+	/* If this is not public, we skip */
+	if (!(channel->channel_flags & CHANNEL_FLAGS_ANNOUNCE_CHANNEL))
+		return;
+
+	if (!channel->old_scids)
+		channel->old_scids = tal_dup(channel, struct short_channel_id, &old_scid);
+	else
+		tal_arr_expand(&channel->old_scids, old_scid);
+
+	chanmap_add(channel->peer->ld, channel, old_scid);
+}
+
 struct channel *new_unsaved_channel(struct peer *peer,
 				    u32 feerate_base,
 				    u32 feerate_ppm)
@@ -287,6 +345,7 @@ struct channel *new_unsaved_channel(struct peer *peer,
 	channel->last_htlc_sigs = NULL;
 	channel->remote_channel_ready = false;
 	channel->scid = NULL;
+	channel->old_scids = NULL;
 	channel->next_index[LOCAL] = 1;
 	channel->next_index[REMOTE] = 1;
 	channel->next_htlc_id = 0;
@@ -299,9 +358,11 @@ struct channel *new_unsaved_channel(struct peer *peer,
 	channel->shutdown_wrong_funding = NULL;
 	channel->closing_feerate_range = NULL;
 	channel->alias[REMOTE] = NULL;
-	/* We don't even bother checking for clashes. */
 	channel->alias[LOCAL] = tal(channel, struct short_channel_id);
-	randombytes_buf(channel->alias[LOCAL], sizeof(struct short_channel_id));
+	*channel->alias[LOCAL] = random_scid();
+	/* We don't check for uniqueness.  We would crash on a clash, but your machine is
+	 * probably broken beyond repair if it gets two equal 64 bit numbers */
+	chanmap_add(channel->peer->ld, channel, *channel->alias[LOCAL]);
 
 	channel->shutdown_scriptpubkey[REMOTE] = NULL;
 	channel->last_was_revoke = false;
@@ -422,8 +483,9 @@ struct channel *new_channel(struct peer *peer, u64 dbid,
 			    struct amount_sat our_funds,
 			    bool remote_channel_ready,
 			    /* NULL or stolen */
-			    struct short_channel_id *scid,
-			    struct short_channel_id *alias_local TAKES,
+			    struct short_channel_id *scid TAKES,
+			    struct short_channel_id *old_scids TAKES,
+			    struct short_channel_id alias_local,
 			    struct short_channel_id *alias_remote STEALS,
 			    struct channel_id *cid,
 			    struct amount_msat our_msat,
@@ -549,13 +611,18 @@ struct channel *new_channel(struct peer *peer, u64 dbid,
 	channel->push = push;
 	channel->our_funds = our_funds;
 	channel->remote_channel_ready = remote_channel_ready;
-	channel->scid = tal_steal(channel, scid);
-	channel->alias[LOCAL] = tal_dup_or_null(channel, struct short_channel_id, alias_local);
-	/* We always make sure this is set (historical channels from db might not) */
-	if (!channel->alias[LOCAL]) {
-		channel->alias[LOCAL] = tal(channel, struct short_channel_id);
-		randombytes_buf(channel->alias[LOCAL], sizeof(struct short_channel_id));
-	}
+	channel->scid = tal_dup_or_null(channel, struct short_channel_id, scid);
+	channel->old_scids = tal_dup_talarr(channel, struct short_channel_id, old_scids);
+	channel->alias[LOCAL] = tal_dup(channel, struct short_channel_id, &alias_local);
+	/* All these possible short_channel_id variants go in the lookup table! */
+	/* Stub channels all have the same scid though, *and* get loaded from db! */
+	if (channel->scid && !is_stub_scid(*channel->scid))
+		chanmap_add(peer->ld, channel, *channel->scid);
+	if (!is_stub_scid(*channel->alias[LOCAL]))
+		chanmap_add(peer->ld, channel, *channel->alias[LOCAL]);
+	for (size_t i = 0; i < tal_count(channel->old_scids); i++)
+		chanmap_add(peer->ld, channel, channel->old_scids[i]);
+
 	channel->alias[REMOTE] = tal_steal(channel, alias_remote);  /* Haven't gotten one yet. */
 	channel->cid = *cid;
 	channel->our_msat = our_msat;
@@ -662,7 +729,7 @@ struct channel *new_channel(struct peer *peer, u64 dbid,
 	}
 	/* scid is NULL when opening a new channel so we don't
 	 * need to set error in that case as well */
-	if (scid && is_stub_scid(*scid))
+	if (channel->scid && is_stub_scid(*channel->scid))
 		channel->error = towire_errorfmt(peer->ld,
 						 &channel->cid,
 						 "We can't be together anymore.");
@@ -749,37 +816,28 @@ struct channel *any_channel_by_scid(struct lightningd *ld,
 				    struct short_channel_id scid,
 				    bool privacy_leak_ok)
 {
-	struct peer *p;
-	struct channel *chan;
-	struct peer_node_id_map_iter it;
-
-	/* FIXME: Support lookup by scid directly! */
-	for (p = peer_node_id_map_first(ld->peers, &it);
-	     p;
-	     p = peer_node_id_map_next(ld->peers, &it)) {
-		list_for_each(&p->channels, chan, list) {
-			/* BOLT #2:
-			 * - MUST always recognize the `alias` as a
-			 *   `short_channel_id` for incoming HTLCs to this
-			 *   channel.
-			 */
-			if (chan->alias[LOCAL] &&
-			    short_channel_id_eq(scid, *chan->alias[LOCAL]))
-				return chan;
-			/* BOLT #2:
-			 * - if `channel_type` has `option_scid_alias` set:
-			 *   - MUST NOT allow incoming HTLCs to this channel
-			 *     using the real `short_channel_id`
-			 */
-			if (!privacy_leak_ok
-			    && channel_type_has(chan->type, OPT_SCID_ALIAS))
-				continue;
-			if (chan->scid
-			    && short_channel_id_eq(scid, *chan->scid))
-				return chan;
-		}
-	}
-	return NULL;
+	const struct scid_to_channel *scc = channel_scid_map_get(ld->channels_by_scid, scid);
+	if (!scc)
+		return NULL;
+
+	/* BOLT #2:
+	 * - MUST always recognize the `alias` as a `short_channel_id` for
+	 *   incoming HTLCs to this channel.
+	 */
+	if (scc->channel->alias[LOCAL]
+	    && short_channel_id_eq(scid, *scc->channel->alias[LOCAL]))
+		return scc->channel;
+
+	/* BOLT #2:
+	 * - if `channel_type` has `option_scid_alias` set:
+	 *   - MUST NOT allow incoming HTLCs to this channel using the real
+	 *     `short_channel_id`
+	 */
+	/* This means any scids other than the alias (handled above) cannot be exposed */
+	if (!privacy_leak_ok && channel_type_has(scc->channel->type, OPT_SCID_ALIAS))
+		return NULL;
+
+	return scc->channel;
 }
 
 struct channel *channel_by_dbid(struct lightningd *ld, const u64 dbid)

lightningd/channel.h

@@ -1,6 +1,7 @@
 #ifndef LIGHTNING_LIGHTNINGD_CHANNEL_H
 #define LIGHTNING_LIGHTNINGD_CHANNEL_H
 #include "config.h"
+#include <ccan/htable/htable_type.h>
 #include <common/channel_config.h>
 #include <common/channel_id.h>
 #include <common/channel_type.h>
@@ -217,6 +218,8 @@ struct channel {
 	bool remote_channel_ready;
 	/* Channel if locked locally. */
 	struct short_channel_id *scid;
+	/* Old scids if we were spliced */
+	struct short_channel_id *old_scids;
 
 	/* Alias used for option_zeroconf, or option_scid_alias, if
 	 * present. LOCAL are all the alias we told the peer about and
@@ -390,8 +393,9 @@ struct channel *new_channel(struct peer *peer, u64 dbid,
 			    struct amount_sat our_funds,
 			    bool remote_channel_ready,
 			    /* NULL or stolen */
-			    struct short_channel_id *scid STEALS,
-			    struct short_channel_id *alias_local STEALS,
+			    struct short_channel_id *scid TAKES,
+			    struct short_channel_id *old_scids TAKES,
+			    struct short_channel_id alias_local,
 			    struct short_channel_id *alias_remote STEALS,
 			    struct channel_id *cid,
 			    struct amount_msat our_msatoshi,
@@ -491,6 +495,10 @@ u32 channel_last_funding_feerate(const struct channel *channel);
 /* Only set completely_eliminate for never-existed channels */
 void delete_channel(struct channel *channel STEALS, bool completely_eliminate);
 
+/* Add a historic (public) short_channel_id to this channel */
+void channel_add_old_scid(struct channel *channel,
+			  struct short_channel_id old_scid);
+
 const char *channel_state_name(const struct channel *channel);
 const char *channel_state_str(enum channel_state state);
 
@@ -837,6 +845,35 @@ struct channel *peer_any_channel_bystate(struct peer *peer,
 
 struct channel *channel_by_dbid(struct lightningd *ld, const u64 dbid);
 
+struct scid_to_channel {
+	struct short_channel_id scid;
+	struct channel *channel;
+};
+
+static inline const struct short_channel_id scid_to_channel_key(const struct scid_to_channel *scidchan)
+{
+	return scidchan->scid;
+}
+
+static inline bool scid_to_channel_eq_scid(const struct scid_to_channel *scidchan,
+					   struct short_channel_id scid)
+{
+	return short_channel_id_eq(scidchan->scid, scid);
+}
+
+/* Define channel_scid_map */
+HTABLE_DEFINE_NODUPS_TYPE(struct scid_to_channel,
+			  scid_to_channel_key,
+			  short_channel_id_hash,
+			  scid_to_channel_eq_scid,
+			  channel_scid_map);
+
+/* The only allowed way to set channel->scid */
+void channel_set_scid(struct channel *channel, const struct short_channel_id *new_scid);
+
+/* The only allowed way to set channel->alias[LOCAL] */
+void channel_set_local_alias(struct channel *channel, struct short_channel_id alias_scid);
+
 /* Includes both real scids and aliases.  If !privacy_leak_ok, then private
  * channels' real scids are not included. */
 struct channel *any_channel_by_scid(struct lightningd *ld,

lightningd/channel_control.c

@@ -803,7 +803,7 @@ bool depthcb_update_scid(struct channel *channel,
 	if (!channel->scid) {
 		wallet_annotate_txout(ld->wallet, outpoint,
 				      TX_CHANNEL_FUNDING, channel->dbid);
-		channel->scid = tal_dup(channel, struct short_channel_id, &scid);
+		channel_set_scid(channel, &scid);
 
 		/* If we have a zeroconf channel, i.e., no scid yet
 		 * but have exchange `channel_ready` messages, then we
@@ -815,12 +815,16 @@ bool depthcb_update_scid(struct channel *channel,
 			lockin_has_completed(channel, false);
 
 	} else {
+		struct short_channel_id old_scid = *channel->scid;
+
 		/* We freaked out if required when original was
 		 * removed, so just update now */
 		log_info(channel->log, "Short channel id changed from %s->%s",
 			 fmt_short_channel_id(tmpctx, *channel->scid),
 			 fmt_short_channel_id(tmpctx, scid));
-		*channel->scid = scid;
+		channel_set_scid(channel, &scid);
+		/* In case we broadcast it before (e.g. splice!) */
+		channel_add_old_scid(channel, old_scid);
 		channel_gossip_scid_changed(channel);
 	}
 

lightningd/dual_open_control.c

@@ -1038,15 +1038,15 @@ static enum watch_result opening_depth_cb(struct lightningd *ld,
 	if (!inflight->channel->scid) {
 		wallet_annotate_txout(ld->wallet, &inflight->funding->outpoint,
 				      TX_CHANNEL_FUNDING, inflight->channel->dbid);
-		inflight->channel->scid = tal_dup(inflight->channel, struct short_channel_id, &scid);
+		channel_set_scid(inflight->channel, &scid);
 		wallet_channel_save(ld->wallet, inflight->channel);
 	} else if (!short_channel_id_eq(*inflight->channel->scid, scid)) {
 		/* We freaked out if required when original was
 		 * removed, so just update now */
 		log_info(inflight->channel->log, "Short channel id changed from %s->%s",
 			 fmt_short_channel_id(tmpctx, *inflight->channel->scid),
 			 fmt_short_channel_id(tmpctx, scid));
-		*inflight->channel->scid = scid;
+		channel_set_scid(inflight->channel, &scid);
 		wallet_channel_save(ld->wallet, inflight->channel);
 	}
 

lightningd/lightningd.c

@@ -209,6 +209,10 @@ static struct lightningd *new_lightningd(const tal_t *ctx)
 	ld->peers_by_dbid = tal(ld, struct peer_dbid_map);
 	peer_dbid_map_init(ld->peers_by_dbid);
 
+	/*~ This speeds lookups for short_channel_ids to their channels. */
+	ld->channels_by_scid = tal(ld, struct channel_scid_map);
+	channel_scid_map_init(ld->channels_by_scid);
+
 	/*~ For multi-part payments, we need to keep some incoming payments
 	 * in limbo until we get all the parts, or we time them out. */
 	ld->htlc_sets = tal(ld, struct htlc_set_map);

lightningd/lightningd.h

@@ -215,6 +215,8 @@ struct lightningd {
 	struct peer_node_id_map *peers;
 	/* And those in database by dbid */
 	struct peer_dbid_map *peers_by_dbid;
+	/* Here are all our channels and their aliases */
+	struct channel_scid_map *channels_by_scid;
 
 	/* Outstanding connect commands. */
 	struct list_head connects;

lightningd/memdump.c

@@ -11,6 +11,7 @@
 #include <gossipd/gossipd_wiregen.h>
 #include <hsmd/hsmd_wiregen.h>
 #include <lightningd/chaintopology.h>
+#include <lightningd/channel.h>
 #include <lightningd/closed_channel.h>
 #include <lightningd/hsm_control.h>
 #include <lightningd/jsonrpc.h>
@@ -202,6 +203,7 @@ static bool lightningd_check_leaks(struct command *cmd)
 	memleak_scan_htable(memtable, &ld->htlc_sets->raw);
 	memleak_scan_htable(memtable, &ld->peers->raw);
 	memleak_scan_htable(memtable, &ld->peers_by_dbid->raw);
+	memleak_scan_htable(memtable, &ld->channels_by_scid->raw);
 	memleak_scan_htable(memtable, &ld->closed_channels->raw);
 	wallet_memleak_scan(memtable, ld->wallet);