fix(tower): stem burst and pr comments

lidatong · lidatong · commit 04374b0ba7c2 · 2025-11-12T00:13:34.000Z
diff --git a/book/api/metrics-generated.md b/book/api/metrics-generated.md
@@ -1135,6 +1135,9 @@
 
 | Metric | Type | Description |
 |--------|------|-------------|
+| <span class="metrics-name">tower_&#8203;vote_&#8203;txn_&#8203;invalid</span> | counter | Number of times we dropped a vote txn because it was invalid (malformed, bad signature, etc.) |
+| <span class="metrics-name">tower_&#8203;vote_&#8203;txn_&#8203;ignored</span> | counter | Number of times we ignored all or part of a vote txn because we didn't recognize a slot (eg. our replay was behind) |
+| <span class="metrics-name">tower_&#8203;vote_&#8203;txn_&#8203;mismatch</span> | counter | Number of times a vote txn mismatched our own block id |
 | <span class="metrics-name">tower_&#8203;ancestor_&#8203;rollback</span> | counter | Rollback to an ancestor of our prev vote (can't vote) |
 | <span class="metrics-name">tower_&#8203;sibling_&#8203;confirmed</span> | counter | Duplicate sibling got confirmed (can't vote) |
 | <span class="metrics-name">tower_&#8203;same_&#8203;fork</span> | counter | Same fork as prev vote (can vote) |
diff --git a/src/app/firedancer/config/default.toml b/src/app/firedancer/config/default.toml
@@ -472,15 +472,6 @@ user = ""
     # abort with an error.
     expected_genesis_hash = ""
 
-    # Firedancer can process at most this many slots without rooting in
-    # the consensus rules before it must begin evicting.
-    #
-    # This is an estimate and should be set as generously as possible to
-    # allow for brief anomalies such as the validator disconnecting from
-    # part of the cluster due to data center issues.  Roughly, at 400 ms
-    # per slot, the default allows for 30 minutes without rooting.
-    max_unrooted_slots = 4096
-
 # This section configures the "funk" account database.  Currently, funk
 # stores all Solana accounts.  In future versions of Firedancer, most
 # accounts will be offloaded to the "groove" database.
@@ -1370,6 +1361,27 @@ user = ""
         # TODO: What is this ... needs to be deleted
         cluster_version =  "1.18.0"
 
+    # The tower tile runs the fork choice and tower rules to determine
+    # both what block to vote on and what block to build our own leader
+    # blocks on top of.
+    [tiles.tower]
+        # Firedancer can process at most this many slots without rooting
+        # in the consensus rules before it must begin evicting.
+        #
+        # This is an estimate and should be set as generously as
+        # possible to allow for temporary outages such as network
+        # partitions.  For example, the validator might get disconnected
+        # from part of the cluster due to data center issues.  Roughly,
+        # the default of 4096 allows for 30 minutes without rooting.
+        #
+        # Specifically, tower will ignore gossip votes that exceed max
+        # unrooted slots ahead of the current root.  Additionally, both
+        # fork choice and tower structures will OOM and cause Firedancer
+        # to exit if it needs to maintain more than max unrooted slots
+        # tower forks (TODO in the future Firedancer will instead
+        # gracefully degrade by evicting forks).
+        max_unrooted_slots = 4096
+
     [tiles.send]
         # The port the send tile uses for QUIC, to send votes and other
         # transactions. It also uses this as the UDP src port.
diff --git a/src/app/firedancer/topology.c b/src/app/firedancer/topology.c
@@ -395,7 +395,7 @@ fd_topo_initialize( config_t * config ) {
 
   /* TODO: Explain this .... USHORT_MAX is not dcache max */
   ulong pending_fec_shreds_depth = fd_ulong_min( fd_ulong_pow2_up( config->tiles.shred.max_pending_shred_sets * FD_REEDSOL_DATA_SHREDS_MAX ), USHORT_MAX + 1 /* dcache max */ );
-  ulong max_unrooted_slots       = config->firedancer.consensus.max_unrooted_slots;
+  ulong max_unrooted_slots       = config->tiles.tower.max_unrooted_slots;
 
   /*                                  topo, link_name,      wksp_name,      depth,                                    mtu,                           burst */
   /**/                 fd_topob_link( topo, "gossip_net",   "net_gossip",   32768UL,                                  FD_NET_MTU,                    1UL );
@@ -1164,7 +1164,7 @@ fd_topo_configure_tile( fd_topo_tile_t * tile,
 
   } else if( FD_UNLIKELY( !strcmp( tile->name, "tower" ) ) ) {
 
-    tile->tower.slot_max = config->firedancer.consensus.max_unrooted_slots;
+    tile->tower.slot_max = config->tiles.tower.max_unrooted_slots;
     strncpy( tile->tower.identity_key, config->paths.identity_key, sizeof(tile->tower.identity_key) );
     strncpy( tile->tower.vote_account, config->paths.vote_account, sizeof(tile->tower.vote_account) );
     strncpy( tile->tower.base_path, config->paths.base, sizeof(tile->tower.base_path) );
diff --git a/src/app/shared/fd_config.h b/src/app/shared/fd_config.h
@@ -132,10 +132,6 @@ struct fd_configf {
     char host[ 256 ];
   } gossip;
 
-  struct {
-    ulong max_unrooted_slots;
-  } consensus;
-
   struct {
     struct {
       uint max_local_full_effective_age;
@@ -481,6 +477,10 @@ struct fd_config {
       ulong write_buffer_size;
     } shredcap;
 
+    struct {
+      ulong max_unrooted_slots;
+    } tower;
+
   } tiles;
   struct {
     ulong capture_start_slot;
diff --git a/src/app/shared/fd_config_parse.c b/src/app/shared/fd_config_parse.c
@@ -80,8 +80,6 @@ fd_config_extract_podf( uchar *        pod,
                         fd_configf_t * config ) {
   CFG_POP      ( cstr,   gossip.host                                         );
 
-  CFG_POP      ( ulong,  consensus.max_unrooted_slots                        );
-
   CFG_POP      ( uint,   layout.exec_tile_count                              );
   CFG_POP      ( uint,   layout.sign_tile_count                              );
   CFG_POP      ( uint,   layout.gossvf_tile_count                            );
@@ -255,13 +253,10 @@ fd_config_extract_pod( uchar *       pod,
   CFG_POP      ( cstr,   tiles.replay.cluster_version                     );
   CFG_POP_ARRAY( cstr,   tiles.replay.enable_features                     );
 
-  CFG_POP      ( cstr,   tiles.store_int.slots_pending                    );
-  CFG_POP      ( cstr,   tiles.store_int.shred_cap_archive                );
-  CFG_POP      ( cstr,   tiles.store_int.shred_cap_replay                 );
-  CFG_POP      ( ulong,  tiles.store_int.shred_cap_end_slot               );
-
   CFG_POP      ( ushort, tiles.send.send_src_port                         );
 
+  CFG_POP      ( ulong,  tiles.tower.max_unrooted_slots                   );
+
   CFG_POP      ( bool,   tiles.archiver.enabled                           );
   CFG_POP      ( ulong,  tiles.archiver.end_slot                          );
   CFG_POP      ( cstr,   tiles.archiver.rocksdb_path                      );
diff --git a/src/choreo/notar/fd_notar.c b/src/choreo/notar/fd_notar.c
@@ -101,8 +101,6 @@ fd_notar_count_vote( fd_notar_t *        notar,
                      ulong               vote_slot,
                      fd_hash_t const *   vote_block_id ) {
 
-  if( FD_UNLIKELY( !notar ) ) { FD_LOG_WARNING(( "NULL notar" )); return NULL; }
-
   /* Ignore if this vote slot isn't in range. */
 
   if( FD_UNLIKELY( vote_slot < notar->lo_wmark || vote_slot > notar->hi_wmark ) ) return NULL;
@@ -138,10 +136,14 @@ fd_notar_count_vote( fd_notar_t *        notar,
 
   fd_notar_blk_t * notar_blk = fd_notar_blk_query( notar->blk_map, *vote_block_id, NULL );
   if( FD_UNLIKELY( !notar_blk ) ) {
-    notar_blk        = fd_notar_blk_insert( notar->blk_map, *vote_block_id );
-    notar_blk->slot  = vote_slot;
-    notar_blk->stake = 0;
     FD_TEST( notar_slot->block_ids_cnt < FD_VOTER_MAX ); /* at most one unique block id per voter in a slot */
+    notar_blk            = fd_notar_blk_insert( notar->blk_map, *vote_block_id );
+    notar_blk->slot      = vote_slot;
+    notar_blk->stake     = 0;
+    notar_blk->dup_conf  = 0;
+    notar_blk->opt_conf  = 0;
+    notar_blk->dup_notif = 0;
+    notar_blk->opt_notif = 0;
     notar_slot->block_ids[notar_slot->block_ids_cnt++] = *vote_block_id;
   }
   notar_blk->stake   += vtr->stake;
diff --git a/src/choreo/notar/fd_notar.h b/src/choreo/notar/fd_notar.h
@@ -110,12 +110,14 @@ struct fd_notar_slot {
 typedef struct fd_notar_slot fd_notar_slot_t;
 
 struct fd_notar_blk {
-  fd_hash_t block_id; /* map key */
-  uint      hash;     /* reserved for fd_map_dynamic */
-  ulong     slot;     /* slot associated with this block */
-  ulong     stake;    /* sum of stake that has voted for this block_id */
-  int       dup_conf; /* whether this block has reached 52% of stake */
-  int       opt_conf; /* whether this block has reached 2/3 of stake */
+  fd_hash_t block_id;  /* map key */
+  uint      hash;      /* reserved for fd_map_dynamic */
+  ulong     slot;      /* slot associated with this block */
+  ulong     stake;     /* sum of stake that has voted for this block_id */
+  int       dup_conf;  /* whether this block has reached 52% of stake */
+  int       opt_conf;  /* whether this block has reached 2/3 of stake */
+  int       dup_notif; /* set by caller, whether we've notified consumers this is duplicate confirmed */
+  int       opt_notif; /* set by caller, whether we've notified consumers this is optimistically confirmed */
 };
 typedef struct fd_notar_blk fd_notar_blk_t;
 
diff --git a/src/choreo/tower/fd_tower_forks.c b/src/choreo/tower/fd_tower_forks.c
@@ -42,12 +42,8 @@ fd_tower_forks_lowest_common_ancestor( fd_tower_forks_t * forks,
 }
 
 fd_hash_t const *
-fd_tower_forks_canonical_block_id( fd_tower_forks_t * forks,
-                                   ulong              slot ) {
-  fd_tower_forks_t * fork = fd_tower_forks_query( forks, slot, NULL );
-  if( FD_UNLIKELY( !fork ) ) return NULL;
+fd_tower_forks_canonical_block_id( fd_tower_forks_t * fork ) {
   if     ( FD_LIKELY( fork->confirmed ) ) return &fork->confirmed_block_id;
   else if( FD_LIKELY( fork->voted     ) ) return &fork->voted_block_id;
-  else if( FD_LIKELY( fork->replayed  ) ) return &fork->replayed_block_id;
-  else return NULL;
+  else                                    return &fork->replayed_block_id;
 }
diff --git a/src/choreo/tower/fd_tower_forks.h b/src/choreo/tower/fd_tower_forks.h
@@ -31,8 +31,8 @@ struct fd_tower_forks {
   fd_hash_t confirmed_block_id; /* the block_id that was duplicate confirmed */
   int       voted;              /* whether we voted for this slot yet */
   fd_hash_t voted_block_id;     /* the block_id we voted on for this slot */
-  int       replayed;           /* whether we replayed this slot yet */
   fd_hash_t replayed_block_id;  /* the block_id we _first_ replayed for this slot */
+  ulong     bank_idx;           /* pool idx of the bank as of this replayed block */
 };
 typedef struct fd_tower_forks fd_tower_forks_t;
 
@@ -78,8 +78,7 @@ fd_tower_forks_lowest_common_ancestor( fd_tower_forks_t * forks,
    so they're always comparing the confirmed block id */
 
 fd_hash_t const *
-fd_tower_forks_canonical_block_id( fd_tower_forks_t * forks,
-                                   ulong              slot );
+fd_tower_forks_canonical_block_id( fd_tower_forks_t * fork );
 
 FD_PROTOTYPES_END
 
diff --git a/src/choreo/tower/fd_tower_serde.c b/src/choreo/tower/fd_tower_serde.c
@@ -4,10 +4,7 @@
 #define SHORTVEC 0
 
 #define DE( T, name ) do {                                                               \
-    if( FD_UNLIKELY( off+sizeof(T)>buf_sz ) ) {                                          \
-      FD_LOG_WARNING(( "de %s: overflow (off %lu > buf_sz: %lu)", #name, off, buf_sz )); \
-      return -1;                                                                         \
-    }                                                                                    \
+    if( FD_UNLIKELY( off+sizeof(T)>buf_sz ) ) return -1;                                 \
     serde->name = *(T const *)fd_type_pun_const( buf+off );                              \
     off += sizeof(T);                                                                    \
 } while(0)
@@ -45,11 +42,8 @@ fd_compact_tower_sync_deserialize( fd_compact_tower_sync_serde_t * serde,
   ulong off = 0;
   DE( ulong, root );
   off += de_short_u16( &serde->lockouts_cnt, buf+off );
-  if( FD_UNLIKELY( serde->lockouts_cnt > FD_TOWER_VOTE_MAX ) ) {
-    FD_LOG_WARNING(( "lockouts_cnt > 31: %u", serde->lockouts_cnt ));
-    return -1;
-  }
-  for( ulong i = 0; i < fd_ulong_min( serde->lockouts_cnt, 31 ); i++ ) {
+  if( FD_UNLIKELY( serde->lockouts_cnt > FD_TOWER_VOTE_MAX ) ) return -1;
+  for( ulong i = 0; i < serde->lockouts_cnt; i++ ) {
     off += de_var_int( &serde->lockouts[i].offset, buf+off );
     DE( uchar, lockouts[i].confirmation_count );
   }
diff --git a/src/choreo/tower/test_tower_serde.c b/src/choreo/tower/test_tower_serde.c
diff --git a/src/choreo/voter/fd_voter.c b/src/choreo/voter/fd_voter.c
diff --git a/src/disco/metrics/generated/fd_metrics_tower.c b/src/disco/metrics/generated/fd_metrics_tower.c
@@ -2,6 +2,9 @@
 #include "fd_metrics_tower.h"
 
 const fd_metrics_meta_t FD_METRICS_TOWER[FD_METRICS_TOWER_TOTAL] = {
+    DECLARE_METRIC( TOWER_VOTE_TXN_INVALID, COUNTER ),
+    DECLARE_METRIC( TOWER_VOTE_TXN_IGNORED, COUNTER ),
+    DECLARE_METRIC( TOWER_VOTE_TXN_MISMATCH, COUNTER ),
     DECLARE_METRIC( TOWER_ANCESTOR_ROLLBACK, COUNTER ),
     DECLARE_METRIC( TOWER_SIBLING_CONFIRMED, COUNTER ),
     DECLARE_METRIC( TOWER_SAME_FORK, COUNTER ),
diff --git a/src/disco/metrics/generated/fd_metrics_tower.h b/src/disco/metrics/generated/fd_metrics_tower.h
@@ -6,55 +6,73 @@
 #include "../fd_metrics_base.h"
 #include "fd_metrics_enums.h"
 
-#define FD_METRICS_COUNTER_TOWER_ANCESTOR_ROLLBACK_OFF  (16UL)
+#define FD_METRICS_COUNTER_TOWER_VOTE_TXN_INVALID_OFF  (16UL)
+#define FD_METRICS_COUNTER_TOWER_VOTE_TXN_INVALID_NAME "tower_vote_txn_invalid"
+#define FD_METRICS_COUNTER_TOWER_VOTE_TXN_INVALID_TYPE (FD_METRICS_TYPE_COUNTER)
+#define FD_METRICS_COUNTER_TOWER_VOTE_TXN_INVALID_DESC "Number of times we dropped a vote txn because it was invalid (malformed, bad signature, etc.)"
+#define FD_METRICS_COUNTER_TOWER_VOTE_TXN_INVALID_CVT  (FD_METRICS_CONVERTER_NONE)
+
+#define FD_METRICS_COUNTER_TOWER_VOTE_TXN_IGNORED_OFF  (17UL)
+#define FD_METRICS_COUNTER_TOWER_VOTE_TXN_IGNORED_NAME "tower_vote_txn_ignored"
+#define FD_METRICS_COUNTER_TOWER_VOTE_TXN_IGNORED_TYPE (FD_METRICS_TYPE_COUNTER)
+#define FD_METRICS_COUNTER_TOWER_VOTE_TXN_IGNORED_DESC "Number of times we ignored all or part of a vote txn because we didn't recognize a slot (eg. our replay was behind)"
+#define FD_METRICS_COUNTER_TOWER_VOTE_TXN_IGNORED_CVT  (FD_METRICS_CONVERTER_NONE)
+
+#define FD_METRICS_COUNTER_TOWER_VOTE_TXN_MISMATCH_OFF  (18UL)
+#define FD_METRICS_COUNTER_TOWER_VOTE_TXN_MISMATCH_NAME "tower_vote_txn_mismatch"
+#define FD_METRICS_COUNTER_TOWER_VOTE_TXN_MISMATCH_TYPE (FD_METRICS_TYPE_COUNTER)
+#define FD_METRICS_COUNTER_TOWER_VOTE_TXN_MISMATCH_DESC "Number of times a vote txn mismatched our own block id"
+#define FD_METRICS_COUNTER_TOWER_VOTE_TXN_MISMATCH_CVT  (FD_METRICS_CONVERTER_NONE)
+
+#define FD_METRICS_COUNTER_TOWER_ANCESTOR_ROLLBACK_OFF  (19UL)
 #define FD_METRICS_COUNTER_TOWER_ANCESTOR_ROLLBACK_NAME "tower_ancestor_rollback"
 #define FD_METRICS_COUNTER_TOWER_ANCESTOR_ROLLBACK_TYPE (FD_METRICS_TYPE_COUNTER)
 #define FD_METRICS_COUNTER_TOWER_ANCESTOR_ROLLBACK_DESC "Rollback to an ancestor of our prev vote (can't vote)"
 #define FD_METRICS_COUNTER_TOWER_ANCESTOR_ROLLBACK_CVT  (FD_METRICS_CONVERTER_NONE)
 
-#define FD_METRICS_COUNTER_TOWER_SIBLING_CONFIRMED_OFF  (17UL)
+#define FD_METRICS_COUNTER_TOWER_SIBLING_CONFIRMED_OFF  (20UL)
 #define FD_METRICS_COUNTER_TOWER_SIBLING_CONFIRMED_NAME "tower_sibling_confirmed"
 #define FD_METRICS_COUNTER_TOWER_SIBLING_CONFIRMED_TYPE (FD_METRICS_TYPE_COUNTER)
 #define FD_METRICS_COUNTER_TOWER_SIBLING_CONFIRMED_DESC "Duplicate sibling got confirmed (can't vote)"
 #define FD_METRICS_COUNTER_TOWER_SIBLING_CONFIRMED_CVT  (FD_METRICS_CONVERTER_NONE)
 
-#define FD_METRICS_COUNTER_TOWER_SAME_FORK_OFF  (18UL)
+#define FD_METRICS_COUNTER_TOWER_SAME_FORK_OFF  (21UL)
 #define FD_METRICS_COUNTER_TOWER_SAME_FORK_NAME "tower_same_fork"
 #define FD_METRICS_COUNTER_TOWER_SAME_FORK_TYPE (FD_METRICS_TYPE_COUNTER)
 #define FD_METRICS_COUNTER_TOWER_SAME_FORK_DESC "Same fork as prev vote (can vote)"
 #define FD_METRICS_COUNTER_TOWER_SAME_FORK_CVT  (FD_METRICS_CONVERTER_NONE)
 
-#define FD_METRICS_COUNTER_TOWER_SWITCH_PASS_OFF  (19UL)
+#define FD_METRICS_COUNTER_TOWER_SWITCH_PASS_OFF  (22UL)
 #define FD_METRICS_COUNTER_TOWER_SWITCH_PASS_NAME "tower_switch_pass"
 #define FD_METRICS_COUNTER_TOWER_SWITCH_PASS_TYPE (FD_METRICS_TYPE_COUNTER)
 #define FD_METRICS_COUNTER_TOWER_SWITCH_PASS_DESC "Prev vote was on a different fork, but we are allowed to switch (can vote)"
 #define FD_METRICS_COUNTER_TOWER_SWITCH_PASS_CVT  (FD_METRICS_CONVERTER_NONE)
 
-#define FD_METRICS_COUNTER_TOWER_SWITCH_FAIL_OFF  (20UL)
+#define FD_METRICS_COUNTER_TOWER_SWITCH_FAIL_OFF  (23UL)
 #define FD_METRICS_COUNTER_TOWER_SWITCH_FAIL_NAME "tower_switch_fail"
 #define FD_METRICS_COUNTER_TOWER_SWITCH_FAIL_TYPE (FD_METRICS_TYPE_COUNTER)
 #define FD_METRICS_COUNTER_TOWER_SWITCH_FAIL_DESC "Prev vote was on a different fork, and we are not allowed to switch (can't vote)"
 #define FD_METRICS_COUNTER_TOWER_SWITCH_FAIL_CVT  (FD_METRICS_CONVERTER_NONE)
 
-#define FD_METRICS_COUNTER_TOWER_LOCKOUT_FAIL_OFF  (21UL)
+#define FD_METRICS_COUNTER_TOWER_LOCKOUT_FAIL_OFF  (24UL)
 #define FD_METRICS_COUNTER_TOWER_LOCKOUT_FAIL_NAME "tower_lockout_fail"
 #define FD_METRICS_COUNTER_TOWER_LOCKOUT_FAIL_TYPE (FD_METRICS_TYPE_COUNTER)
 #define FD_METRICS_COUNTER_TOWER_LOCKOUT_FAIL_DESC "Locked out (can't vote)"
 #define FD_METRICS_COUNTER_TOWER_LOCKOUT_FAIL_CVT  (FD_METRICS_CONVERTER_NONE)
 
-#define FD_METRICS_COUNTER_TOWER_THRESHOLD_FAIL_OFF  (22UL)
+#define FD_METRICS_COUNTER_TOWER_THRESHOLD_FAIL_OFF  (25UL)
 #define FD_METRICS_COUNTER_TOWER_THRESHOLD_FAIL_NAME "tower_threshold_fail"
 #define FD_METRICS_COUNTER_TOWER_THRESHOLD_FAIL_TYPE (FD_METRICS_TYPE_COUNTER)
 #define FD_METRICS_COUNTER_TOWER_THRESHOLD_FAIL_DESC "Did not pass threshold check (can't vote)"
 #define FD_METRICS_COUNTER_TOWER_THRESHOLD_FAIL_CVT  (FD_METRICS_CONVERTER_NONE)
 
-#define FD_METRICS_COUNTER_TOWER_PROPAGATED_FAIL_OFF  (23UL)
+#define FD_METRICS_COUNTER_TOWER_PROPAGATED_FAIL_OFF  (26UL)
 #define FD_METRICS_COUNTER_TOWER_PROPAGATED_FAIL_NAME "tower_propagated_fail"
 #define FD_METRICS_COUNTER_TOWER_PROPAGATED_FAIL_TYPE (FD_METRICS_TYPE_COUNTER)
 #define FD_METRICS_COUNTER_TOWER_PROPAGATED_FAIL_DESC "Prev leader block did not propagate (can't vote)"
 #define FD_METRICS_COUNTER_TOWER_PROPAGATED_FAIL_CVT  (FD_METRICS_CONVERTER_NONE)
 
-#define FD_METRICS_TOWER_TOTAL (8UL)
+#define FD_METRICS_TOWER_TOTAL (11UL)
 extern const fd_metrics_meta_t FD_METRICS_TOWER[FD_METRICS_TOWER_TOTAL];
 
 #endif /* HEADER_fd_src_disco_metrics_generated_fd_metrics_tower_h */
diff --git a/src/disco/metrics/metrics.xml b/src/disco/metrics/metrics.xml
@@ -1097,6 +1097,9 @@ metric introduced.
 </tile>
 
 <tile name="tower">
+    <counter name="VoteTxnInvalid" summary="Number of times we dropped a vote txn because it was invalid (malformed, bad signature, etc.)" />
+    <counter name="VoteTxnIgnored" summary="Number of times we ignored all or part of a vote txn because we didn't recognize a slot (eg. our replay was behind)" />
+    <counter name="VoteTxnMismatch" summary="Number of times a vote txn mismatched our own block id" />
     <counter name="AncestorRollback" summary="Rollback to an ancestor of our prev vote (can't vote)" />
     <counter name="SiblingConfirmed" summary="Duplicate sibling got confirmed (can't vote)" />
     <counter name="SameFork" summary="Same fork as prev vote (can vote)" />
diff --git a/src/discof/tower/fd_tower_tile.c b/src/discof/tower/fd_tower_tile.c
diff --git a/src/discof/tower/fd_tower_tile.h b/src/discof/tower/fd_tower_tile.h

Original file line number	Diff line number	Diff line change
`@@ -42,12 +42,8 @@ fd_tower_forks_lowest_common_ancestor( fd_tower_forks_t * forks,`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`fd_hash_t const *`
`45`		`-fd_tower_forks_canonical_block_id( fd_tower_forks_t * forks,`
`46`		`- ulong slot ) {`
`47`		`- fd_tower_forks_t * fork = fd_tower_forks_query( forks, slot, NULL );`
`48`		`- if( FD_UNLIKELY( !fork ) ) return NULL;`
	`45`	`+fd_tower_forks_canonical_block_id( fd_tower_forks_t * fork ) {`
`49`	`46`	`if ( FD_LIKELY( fork->confirmed ) ) return &fork->confirmed_block_id;`
`50`	`47`	`else if( FD_LIKELY( fork->voted ) ) return &fork->voted_block_id;`
`51`		`- else if( FD_LIKELY( fork->replayed ) ) return &fork->replayed_block_id;`
`52`		`- else return NULL;`
	`48`	`+ else return &fork->replayed_block_id;`
`53`	`49`	`}`