feat(tower): rework confirmed frags and vote txn verify + minor fixes

Author: lidatong

src/app/firedancer/topology.c

@@ -595,15 +595,18 @@ fd_topo_initialize( config_t * config ) {
                        fd_topob_tile_in (   topo, "replay",  0UL,          "metric_in", "snapin_manif", 0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   }
 
-  /**/                 fd_topob_tile_in(    topo, "replay",  0UL,          "metric_in", "poh_replay",   0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
-  FOR(exec_tile_cnt)   fd_topob_tile_in(    topo, "exec",    i,            "metric_in", "replay_exec",  0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
+  /**/                 fd_topob_tile_in (   topo, "replay",  0UL,          "metric_in", "poh_replay",   0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
+  FOR(exec_tile_cnt)   fd_topob_tile_in (   topo, "exec",    i,            "metric_in", "replay_exec",  0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
+
+  /**/                 fd_topob_tile_in (   topo, "tower",   0UL,          "metric_in", "dedup_resolv", 0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   /**/                 fd_topob_tile_in (   topo, "tower",   0UL,          "metric_in", "genesi_out",   0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   /**/                 fd_topob_tile_in (   topo, "tower",   0UL,          "metric_in", "gossip_out",   0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   /**/                 fd_topob_tile_in (   topo, "tower",   0UL,          "metric_in", "replay_out",   0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   if( snapshots_enabled ) {
                        fd_topob_tile_in (   topo, "tower",   0UL,          "metric_in", "snapin_manif", 0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   }
   /**/                 fd_topob_tile_out(   topo, "tower",   0UL,                       "tower_out",    0UL                                                );
+
   /**/                 fd_topob_tile_in (   topo, "send",    0UL,          "metric_in", "replay_stake", 0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   /**/                 fd_topob_tile_in (   topo, "send",    0UL,          "metric_in", "gossip_out",   0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
   /**/                 fd_topob_tile_in (   topo, "send",    0UL,          "metric_in", "tower_out",    0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );

src/choreo/notar/fd_notar.c

@@ -94,31 +94,23 @@ fd_notar_delete( void * notar ) {
   return notar;
 }
 
-int
+fd_notar_blk_t *
 fd_notar_count_vote( fd_notar_t *        notar,
                      ulong               total_stake,
                      fd_pubkey_t const * addr,
                      ulong               vote_slot,
                      fd_hash_t const *   vote_block_id ) {
 
-  if( FD_UNLIKELY( !notar ) ) {
-    FD_LOG_WARNING(( "NULL notar" ));
-    return 0;
-  }
+  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 0;
+  if( FD_UNLIKELY( vote_slot < notar->lo_wmark || vote_slot > notar->hi_wmark ) ) return NULL;
 
   /* Ignore if this vote account isn't in the voter set. */
 
   fd_notar_vtr_t const * vtr = fd_notar_vtr_query( notar->vtr_map, *addr, NULL );
-  if( FD_UNLIKELY( !vtr ) ) return 0;
-
-  /* Ignore if this notar blk was already duplicate confirmed. */
-
-  fd_notar_blk_t * notar_blk = fd_notar_blk_query( notar->blk_map, *vote_block_id, NULL );
-  if( FD_LIKELY( notar_blk && notar_blk->dup_conf ) ) return 0;
+  if( FD_UNLIKELY( !vtr ) ) return NULL;
 
   /* Check we haven't already counted the voter's stake for this slot.
      If a voter voted for multiple block ids for the same slot, we only
@@ -138,12 +130,13 @@ fd_notar_count_vote( fd_notar_t *        notar,
     fd_notar_slot_vtrs_null( notar_slot->prev_vtrs );
     fd_notar_slot_vtrs_null( notar_slot->vtrs );
   }
-  if( FD_LIKELY( fd_notar_slot_vtrs_test( notar_slot->vtrs, vtr->bit ) ) ) return 0;
+  if( FD_LIKELY( fd_notar_slot_vtrs_test( notar_slot->vtrs, vtr->bit ) ) ) return NULL;
   fd_notar_slot_vtrs_insert( notar_slot->vtrs, vtr->bit );
   notar_slot->stake += vtr->stake;
 
   /* Get the actual block with the block_id. */
 
+  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;
@@ -152,8 +145,9 @@ fd_notar_count_vote( fd_notar_t *        notar,
     notar_slot->block_ids[notar_slot->block_ids_cnt++] = *vote_block_id;
   }
   notar_blk->stake   += vtr->stake;
-  notar_blk->dup_conf = (double)notar_blk->stake / (double)total_stake > 0.52; /* duplicate confirmed if > 52% stake */
-  return notar_blk->dup_conf;
+  notar_blk->dup_conf = ((double)notar_blk->stake / (double)total_stake) > 0.52;
+  notar_blk->opt_conf = ((double)notar_blk->stake / (double)total_stake) > (2.0/3.0);
+  return notar_blk;
 }
 
 void

src/choreo/notar/fd_notar.h

@@ -10,16 +10,16 @@
      important in two contexts:
 
      1. When becoming leader, we need to check that our "previous"
-         leader block _as of_ the parent slot we're building on, has
-         propagated. If it's not propagated, we need to instead
-         retransmit our last block that failed to propagate.  "Previous"
-         is quoted, because there is a grace period of one leader
-         rotation for leader blocks to propagate.
+        leader block _as of_ the parent slot we're building on, has
+        propagated.  If it's not propagated, we need to instead
+        retransmit our last block that failed to propagate.  "Previous"
+        is quoted, because there is a grace period of one leader
+        rotation for leader blocks to propagate.
 
      2. When voting, we need to check our previous leader block _as of_
-         the slot we're voting for has propagated (unless we're voting
-         for one of our leader blocks).  We cannot vote for slots in
-         which our last leader block failed to propagate.
+        the slot we're voting for has propagated (unless we're voting
+        for one of our leader blocks).  We cannot vote for slots in
+        which our last leader block failed to propagate.
 
    - duplicate confirmed: a block is duplicate confirmed if it has
      received votes from at least 52% of stake in the cluster.  The
@@ -85,6 +85,10 @@
 #define FD_NOTAR_PARANOID 1
 #endif
 
+#define FD_NOTAR_FLAG_CONFIRMED_PROPAGATED (0)
+#define FD_NOTAR_FLAG_CONFIRMED_DUPLICATE  (1)
+#define FD_NOTAR_FLAG_CONFIRMED_OPTIMISTIC (2)
+
 #define SET_NAME fd_notar_slot_vtrs
 #define SET_MAX  FD_VOTER_MAX
 #include "../../util/tmpl/fd_set.c"
@@ -95,7 +99,7 @@ struct fd_notar_slot {
   ulong prev_leader_slot; /* previous slot in which we were leader */
   ulong stake;            /* amount of stake that has voted for this slot */
   int   is_leader;        /* whether this slot was our own leader slot */
-  int   is_propagated;    /* whether this slot has reached 33% of stake */
+  int   is_propagated;    /* whether this slot has reached 1/3 of stake */
 
   fd_hash_t block_ids[FD_VOTER_MAX]; /* one block id per voter per slot */
   ulong     block_ids_cnt;           /* count of block ids */
@@ -105,13 +109,13 @@ 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 */
 };
 typedef struct fd_notar_blk fd_notar_blk_t;
 
@@ -161,7 +165,7 @@ struct __attribute__((aligned(128UL))) fd_notar {
   ulong epoch;    /* highest replayed epoch */
   ulong lo_wmark; /* notar ignores votes < lo_wmark */
   ulong hi_wmark; /* notar ignores votes > hi_wmark */
-  ulong slot_max; /* maximum slot number */
+  ulong slot_max; /* maximum number of slots notar can track */
 
   fd_notar_slot_t * slot_map; /* tracks who has voted for a given slot */
   fd_notar_blk_t *  blk_map;  /* tracks amount of stake for a given block (keyed by block id) */
@@ -237,7 +241,7 @@ fd_notar_delete( void * notar );
    account in the current epoch, slot is slot being voted for, block_id
    is the voter's proposed block id for this vote slot. */
 
-int
+fd_notar_blk_t *
 fd_notar_count_vote( fd_notar_t *        notar,
                      ulong               total_stake,
                      fd_pubkey_t const * addr,

src/disco/gui/fd_gui.c

@@ -2425,27 +2425,23 @@ fd_gui_handle_rooted_slot( fd_gui_t * gui, ulong root_slot ) {
   fd_http_server_ws_broadcast( gui->http );
 }
 
-/* fd_gui_handle_tower_update handles updates from the tower tile, which
-   manages consensus related fork switching, rooting, slot confirmation. */
+/* fd_gui_handle_tower_slot_done handles slot_done frags from the tower
+   tile, which manages consensus related fork switching, rooting, slot
+   confirmation. */
 void
-fd_gui_handle_tower_update( fd_gui_t *                   gui,
-                            fd_tower_slot_done_t const * tower,
-                            long                         now ) {
+fd_gui_handle_tower_slot_done( fd_gui_t *                   gui,
+                               fd_tower_slot_done_t const * slot_done,
+                               long                         now ) {
   (void)now;
 
-  /* handle new root */
-  if( FD_LIKELY( tower->root_slot!=ULONG_MAX && gui->summary.slot_rooted!=tower->root_slot ) ) {
-    fd_gui_handle_rooted_slot( gui, tower->root_slot );
-  }
-
-  if( FD_UNLIKELY( gui->summary.vote_distance!=tower->reset_slot-tower->vote_slot ) ) {
-    gui->summary.vote_distance = tower->reset_slot-tower->vote_slot;
+  if( FD_UNLIKELY( gui->summary.vote_distance!=slot_done->reset_slot-slot_done->vote_slot ) ) {
+    gui->summary.vote_distance = slot_done->reset_slot-slot_done->vote_slot;
     fd_gui_printf_vote_distance( gui );
     fd_http_server_ws_broadcast( gui->http );
   }
 
   if( FD_LIKELY( gui->summary.vote_state!=FD_GUI_VOTE_STATE_NON_VOTING ) ) {
-    if( FD_UNLIKELY( tower->vote_slot==ULONG_MAX || (tower->vote_slot+150UL)<tower->reset_slot ) ) {
+    if( FD_UNLIKELY( slot_done->vote_slot==ULONG_MAX || (slot_done->vote_slot+150UL)<slot_done->reset_slot ) ) {
       if( FD_UNLIKELY( gui->summary.vote_state!=FD_GUI_VOTE_STATE_DELINQUENT ) ) {
         gui->summary.vote_state = FD_GUI_VOTE_STATE_DELINQUENT;
         fd_gui_printf_vote_state( gui );
@@ -2463,6 +2459,24 @@ fd_gui_handle_tower_update( fd_gui_t *                   gui,
   /* todo ... optimistic confirmation, waiting on fd_ghost / fd_notar */
 }
 
+/* fd_gui_handle_tower_update handles slot_confirmed frags from the
+   tower tile, which indicate when slots are optimistically confirmed or
+   rooted. */
+
+void
+fd_gui_handle_tower_slot_confirmed( fd_gui_t *                        gui,
+                                    fd_tower_slot_confirmed_t const * slot_confirmed,
+                                    long                              now ) {
+  (void)now;
+
+  /* handle new root */
+  if( FD_LIKELY( slot_confirmed->kind==FD_TOWER_SLOT_CONFIRMED_ROOTED && gui->summary.slot_rooted!=slot_confirmed->slot ) ) {
+    fd_gui_handle_rooted_slot( gui, slot_confirmed->slot );
+  }
+
+  /* todo ... optimistic confirmation, waiting on fd_ghost / fd_notar */
+}
+
 void
 fd_gui_handle_replay_update( fd_gui_t *                gui,
                              fd_gui_slot_completed_t * slot_completed,

src/disco/gui/fd_gui.h

@@ -826,7 +826,7 @@ fd_gui_handle_leader_schedule( fd_gui_t *                    gui,
                                long                          now );
 
 void
-fd_gui_handle_tower_update( fd_gui_t *                   gui,
+fd_gui_handle_tower_slot_done( fd_gui_t *                   gui,
                             fd_tower_slot_done_t const * msg,
                             long                         now );
 

src/disco/gui/fd_gui_tile.c

@@ -383,8 +383,11 @@ after_frag( fd_gui_ctx_t *      ctx,
     case IN_KIND_TOWER_OUT: {
       FD_TEST( ctx->is_full_client );
       if( FD_LIKELY( sig==FD_TOWER_SIG_SLOT_DONE )) {
-        fd_tower_slot_done_t const * tower = (fd_tower_slot_done_t const *)ctx->buf;
-        fd_gui_handle_tower_update( ctx->gui, tower, fd_clock_now( ctx->clock ) );
+        fd_tower_slot_done_t const * slot_done = (fd_tower_slot_done_t const *)ctx->buf;
+        fd_gui_handle_tower_slot_done( ctx->gui, slot_done, fd_clock_now( ctx->clock ) );
+      } else if ( FD_LIKELY( sig==FD_TOWER_SIG_SLOT_CONFIRMED ) ) {
+        fd_tower_slot_confirmed_t const * slot_confirmed = (fd_tower_slot_confirmed_t const *)ctx->buf;
+        fd_gui_handle_tower_slot_confirmed( ctx->gui, slot_confirmed, fd_clock_now( ctx->clock ) );
       }
       break;
     }

src/discof/repair/fd_repair_tile.c

@@ -774,7 +774,7 @@ after_frag( ctx_t * ctx,
         fd_policy_reset  ( ctx->policy, ctx->forest );
       }
     } else if( FD_LIKELY( sig == FD_TOWER_SIG_DUPLICATE_CONFIRMED ) ) {
-      fd_tower_duplicate_confirmed_t const * msg = (fd_tower_duplicate_confirmed_t const *)fd_type_pun_const( ctx->buffer );
+      fd_tower_slot_confirmed_t const * msg = (fd_tower_slot_confirmed_t const *)fd_type_pun_const( ctx->buffer );
       (void)msg;
     }
     return;