feat(tower): integrate with gossip v2 and rework serdes

Author: lidatong

src/app/firedancer/topology.c

@@ -523,7 +523,8 @@ fd_topo_initialize( config_t * config ) {
      single out link, over which all the writer tiles round-robin. */
   FOR(writer_tile_cnt) for( ulong j=0UL; j<exec_tile_cnt; j++ )
                        fd_topob_tile_in(    topo, "writer",  i,            "metric_in", "exec_writer",  j,            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", "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", "snap_out",     0UL,          FD_TOPOB_RELIABLE,   FD_TOPOB_POLLED );
@@ -951,8 +952,8 @@ fd_topo_configure_tile( fd_topo_tile_t * tile,
 
   } else if( FD_UNLIKELY( !strcmp( tile->name, "tower" ) ) ) {
 
-    strncpy( tile->tower.identity_key_path, config->paths.identity_key, sizeof(tile->tower.identity_key_path) );
-    strncpy( tile->tower.vote_acc_path, config->paths.vote_account, sizeof(tile->tower.vote_acc_path) );
+    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.ledger_path, config->paths.ledger, sizeof(tile->tower.ledger_path) );
 
   } else if( FD_UNLIKELY( !strcmp( tile->name, "send" ) ) ) {

src/choreo/ghost/fd_ghost.c

@@ -570,7 +570,7 @@ fd_ghost_is_ancestor( fd_ghost_t const * ghost, fd_hash_t const * ancestor, fd_h
 }
 
 int
-fd_ghost_invalid( fd_ghost_t const * ghost, fd_ghost_ele_t const * ele ) {
+fd_ghost_is_valid_fork( fd_ghost_t const * ghost, fd_ghost_ele_t const * ele ) {
   fd_ghost_ele_t const * anc = ele;
   while( FD_LIKELY( anc ) ) {
     if( FD_UNLIKELY( ( !anc->valid ) ) ) return 1;

src/choreo/ghost/fd_ghost.h

@@ -200,9 +200,6 @@ typedef struct fd_dup_seen fd_dup_seen_t;
 #define FD_GHOST_MAGIC (0xf17eda2ce7940570UL) /* firedancer ghost version 0 */
 
 struct __attribute__((aligned(128UL))) fd_ghost {
-
-  /* Metadata */
-
   ulong magic;          /* ==FD_GHOST_MAGIC */
   ulong ghost_gaddr;    /* wksp gaddr of this in the backing wksp, non-zero gaddr */
   ulong seed;           /* seed for various hashing function used under the hood, arbitrary */
@@ -387,7 +384,7 @@ fd_ghost_is_ancestor( fd_ghost_t const * ghost, fd_hash_t const * ancestor, fd_h
 /* fd_ghost_anc_eqvoc. */
 
 int
-fd_ghost_invalid( fd_ghost_t const * ghost, fd_ghost_ele_t const * ele );
+fd_ghost_is_valid_fork( fd_ghost_t const * ghost, fd_ghost_ele_t const * ele );
 
 /* Operations */
 

src/choreo/notar/fd_notar.h

@@ -29,7 +29,7 @@
      commitment status of blocks (queryable via RPC) to determine that
      their transaction has landed on a block that will not rollback. */
 
-/* TODO duplicate confirmed / optimistc confirmed currently not
+/* TODO duplicate confirmed / optimistic confirmed currently not
    implemented through this API */
 
 /* FD_NOTAR_PARANOID:  Define this to non-zero at compile time

src/choreo/tower/Local.mk

@@ -1,10 +1,13 @@
 ifdef FD_HAS_INT128
 ifdef FD_HAS_SECP256K1
-$(call add-hdrs,fd_tower.h)
+$(call add-hdrs,fd_tower.h fd_tower_serde.h)
 $(call add-objs,fd_tower,fd_choreo)
+$(call add-objs,fd_tower_serde,fd_choreo)
 ifdef FD_HAS_HOSTED
 $(call make-unit-test,test_tower,test_tower,fd_choreo fd_flamenco fd_tango fd_ballet fd_util,$(SECP256K1_LIBS))
+$(call make-unit-test,test_tower_serde,test_tower_serde,fd_choreo fd_flamenco fd_tango fd_ballet fd_util,$(SECP256K1_LIBS))
 $(call run-unit-test,test_tower)
+$(call run-unit-test,test_tower_serde)
 endif
 endif
 endif

src/choreo/tower/fd_tower.c

@@ -459,57 +459,6 @@ typedef struct fd_tower_vote fd_tower_vote_t;
 
 typedef fd_tower_vote_t fd_tower_t;
 
-/* fd_tower_sync_serde describes a serialization / deserialization
-   schema for a bincode-encoded TowerSync transaction.  The serde is
-   structured for zero-copy access ie. x-raying individual fields. */
-
-struct fd_tower_sync_serde /* CompactTowerSync */ {
-  ulong const * root;
-  struct /* short_vec */ {
-    ushort lockouts_cnt; /* variable-length so copied (ShortU16) */
-    struct /* Lockout */ {
-      ulong         offset; /* variable-length so copied (VarInt) */
-      uchar const * confirmation_count;
-    } lockouts[31];
-  };
-  fd_hash_t const * hash;
-  struct /* Option<UnixTimestamp> */ {
-    uchar const * timestamp_option;
-    long  const * timestamp;
-  };
-  fd_hash_t const * block_id;
-};
-typedef struct fd_tower_sync_serde fd_tower_sync_serde_t;
-
-/* fd_tower_file_serde describes a serialization / deserialization
-   schema for checkpointing / restoring tower from a file.  This
-   corresponds exactly with the binary layout of a tower file that Agave
-   uses during boot, set-identity, and voting.
-
-   The serde is structured for zero-copy access ie. x-raying individual
-   fields. */
-
-struct fd_tower_file_serde /* SavedTowerVersions::Current */ {
-  uint const *             kind;
-  fd_ed25519_sig_t const * signature;
-  ulong const *            data_sz; /* serialized sz of data field below */
-  struct /* Tower1_14_11 */ {
-    fd_pubkey_t const *   node_pubkey;
-    ulong const *         threshold_depth;
-    double const *        threshold_size;
-    fd_voter_v2_serde_t   vote_state;
-    struct {
-      uint const *          last_vote_kind;
-      fd_tower_sync_serde_t last_vote;
-    };
-    struct /* BlockTimestamp */ {
-      ulong const * slot;
-      long const *  timestamp;
-    } last_timestamp;
-  } /* data */;
-};
-typedef struct fd_tower_file_serde fd_tower_file_serde_t;
-
 /* fd_tower_sign_fn is the signing callback used for signing tower
    checkpoints after serialization. */
 
@@ -771,24 +720,24 @@ fd_tower_vote( fd_tower_t * tower, ulong slot );
 
 /* Misc */
 
-/* fd_tower_sync_serde populates serde using the provided tower and args
-   to create a zero-copy view of a TowerSync vote transaction payload
-   ready for serialization. */
+// /* fd_tower_sync_serde populates serde using the provided tower and args
+//    to create a zero-copy view of a TowerSync vote transaction payload
+//    ready for serialization. */
 
-fd_tower_sync_serde_t *
-fd_tower_to_tower_sync( fd_tower_t const * tower, ulong root, fd_hash_t * bank_hash, fd_hash_t * block_id, long ts, fd_tower_sync_serde_t * ser );
+// fd_tower_sync_serde_t *
+// fd_tower_to_tower_sync( fd_tower_t const * tower, ulong root, fd_hash_t * bank_hash, fd_hash_t * block_id, long ts, fd_tower_sync_serde_t * ser );
 
-/* fd_tower_sync_serde populates serde using the provided tower and args
-   to create a zero-copy view of an Agave-compatible serialized Tower
-   ready for serialization. */
+// /* fd_tower_sync_serde populates serde using the provided tower and args
+//    to create a zero-copy view of an Agave-compatible serialized Tower
+//    ready for serialization. */
 
-fd_tower_file_serde_t *
-fd_tower_serde( fd_tower_t const *      tower,
-                ulong                   root,
-                fd_tower_sync_serde_t * last_vote,
-                uchar const             pvtkey[static 32],
-                uchar const             pubkey[static 32],
-                fd_tower_file_serde_t * ser );
+// fd_tower_file_serde_t *
+// fd_tower_serde( fd_tower_t const *      tower,
+//                 ulong                   root,
+//                 fd_tower_sync_serde_t * last_vote,
+//                 uchar const             pvtkey[static 32],
+//                 uchar const             pubkey[static 32],
+//                 fd_tower_file_serde_t * ser );
 
 /* fd_tower_to_vote_txn writes tower into a fd_tower_sync_t vote
    instruction and serializes it into a Solana transaction.  Assumes
@@ -822,15 +771,15 @@ fd_tower_to_vote_txn( fd_tower_t const *    tower,
    the memory pointed by tower or the file pointed to by path while
    fd_tower_checkpt is in progress. */
 
-int
-fd_tower_checkpt( fd_tower_t const *      tower,
-                  ulong                   root,
-                  fd_tower_sync_serde_t * last_vote,
-                  uchar const             pubkey[static 32],
-                  fd_tower_sign_fn *      sign_fn,
-                  int                     fd,
-                  uchar *                 buf,
-                  ulong                   buf_max );
+// int
+// fd_tower_checkpt( fd_tower_t const *      tower,
+//                   ulong                   root,
+//                   fd_tower_sync_serde_t * last_vote,
+//                   uchar const             pubkey[static 32],
+//                   fd_tower_sign_fn *      sign_fn,
+//                   int                     fd,
+//                   uchar *                 buf,
+//                   ulong                   buf_max );
 
 /* fd_tower_restore restores tower from the bytes pointed to by restore.
    Returns 0 on success, -1 on error.  Assumes tower is a valid local
@@ -870,11 +819,11 @@ fd_tower_restore( fd_tower_t * tower,
    serde is a zero-copy view of the Agave-compatible bincode-encoding of
    a tower.  See also the struct definition of fd_tower_serde_t. */
 
-int
-fd_tower_serialize( fd_tower_file_serde_t * ser,
-                    uchar *            buf,
-                    ulong              buf_max,
-                    ulong *            buf_sz );
+// int
+// fd_tower_serialize( fd_tower_file_serde_t * ser,
+//                     uchar *            buf,
+//                     ulong              buf_max,
+//                     ulong *            buf_sz );
 
 /* fd_tower_deserialize deserializes buf into serde.  Returns 0 on
    success, -1 if an error is encountered during deserialization.  buf
@@ -884,10 +833,10 @@ fd_tower_serialize( fd_tower_file_serde_t * ser,
    serde is a zero-copy view of the Agave-compatible bincode-encoding of
    a tower.  See also the struct definition of fd_tower_serde_t. */
 
-int
-fd_tower_deserialize( uchar *            buf,
-                      ulong              buf_sz,
-                      fd_tower_file_serde_t * de );
+// int
+// fd_tower_deserialize( uchar *            buf,
+//                       ulong              buf_sz,
+//                       fd_tower_file_serde_t * de );
 
 /* fd_tower_verify checks tower is in a valid state. Valid iff:
    - cnt < FD_TOWER_VOTE_MAX

src/choreo/tower/fd_tower.h

@@ -0,0 +1,141 @@
+#include "fd_tower_serde.h"
+#include "fd_tower.h"
+
+#define SHORTVEC 0
+
+#define SER( T, name ) do {                                                                 \
+    if( FD_UNLIKELY( off+sizeof(T)>buf_max ) ) {                                            \
+      FD_LOG_WARNING(( "ser %s: overflow (off %lu > buf_max: %lu)", #name, off, buf_max )); \
+      return -1;                                                                            \
+    }                                                                                       \
+    FD_STORE( T, buf+off, serde->name );                                                    \
+    off += sizeof(T);                                                                       \
+} while(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;                                                                         \
+    }                                                                                    \
+    serde->name = *(T const *)fd_type_pun_const( buf+off );                              \
+    off += sizeof(T);                                                                    \
+} while(0)
+
+static ulong
+ser_short_u16( uchar * dst, ushort src ) {
+  if     ( FD_LIKELY( src < 0x80UL   ) ) { *dst   = (uchar)  src;                                                                                          return 1; }
+  else if( FD_LIKELY( src < 0x4000UL ) ) { *dst++ = (uchar)((src&0x7FUL)|0x80UL); *dst++ = (uchar)(  src>>7);                                              return 2; }
+  else                                   { *dst++ = (uchar)((src&0x7FUL)|0x80UL); *dst++ = (uchar)(((src>>7)&0x7FUL)|0x80UL); *dst++ = (uchar)(src>>14UL); return 3; }
+}
+
+static ulong
+ser_var_int( uchar * dst, ulong src ) {
+  ulong off = 0;
+  while( FD_LIKELY( 1 ) ) {
+    if( FD_LIKELY( src < 0x80UL ) ) {
+      *(dst) = (uchar)src;
+      off   += 1;
+      return off;
+    }
+    *(dst+off) = (uchar)((src&0x7FUL)|0x80UL);
+    off       += 1;
+    src      >>= 7;
+  }
+}
+
+static ulong
+de_short_u16( ushort * dst, uchar const * src ) {
+  if     ( FD_LIKELY( !(0x80U & src[0]) ) ) { *dst = (ushort)src[0];                                                                           return 1; }
+  else if( FD_LIKELY( !(0x80U & src[1]) ) ) { *dst = (ushort)((ulong)(src[0]&0x7FUL) + (((ulong)src[1])<<7));                                  return 2; }
+  else                                      { *dst = (ushort)((ulong)(src[0]&0x7FUL) + (((ulong)(src[1]&0x7FUL))<<7) + (((ulong)src[2])<<14)); return 3; }
+}
+
+static ulong
+de_var_int( ulong * dst, uchar const * src ) {
+  *dst = 0;
+  ulong off = 0;
+  ulong bit = 0;
+  while( FD_LIKELY( bit < 64 ) ) {
+    uchar byte = *(uchar const *)(src+off);
+    off       += 1;
+    *dst      |= (byte & 0x7FUL) << bit;
+    if( FD_LIKELY( (byte & 0x80U) == 0U ) ) {
+      if( FD_UNLIKELY( (*dst>>bit) != byte                ) ) FD_LOG_CRIT(( "de_varint" ));
+      if( FD_UNLIKELY( byte==0U && (bit!=0U || *dst!=0UL) ) ) FD_LOG_CRIT(( "de_varint" ));
+      return off;
+    }
+    bit += 7;
+  }
+  FD_LOG_CRIT(( "de_varint" ));
+}
+
+// fd_tower_sync_serde_t *
+// fd_tower_sync_to( fd_tower_sync_serde_t * serde, uchar * buf, ulong buf_max, ulong * buf_sz ) {
+//   ser->root         = &root;
+//   ser->lockouts_cnt = (ushort)fd_tower_votes_cnt( tower );
+//   ushort i          = 0;
+//   ulong  prev       = root;
+//   for( fd_tower_votes_iter_t iter = fd_tower_votes_iter_init( tower );
+//                                    !fd_tower_votes_iter_done( tower, iter );
+//                              iter = fd_tower_votes_iter_next( tower, iter ) ) {
+//     fd_tower_vote_t const * vote        = fd_tower_votes_iter_ele_const( tower, iter );
+//     ser->lockouts[i].offset             = vote->slot - prev;
+//     ser->lockouts[i].confirmation_count = (uchar const *)fd_type_pun_const( &vote->conf );
+//     i++;
+//   }
+//   ser->hash              = bank_hash;
+//   ser->timestamp_option  = &option_some;
+//   ser->timestamp         = &ts;
+//   ser->block_id          = block_id;
+//   return ser;
+// }
+
+int
+fd_tower_sync_serialize( fd_tower_sync_serde_t * serde,
+                         uchar *                 buf,
+                         ulong                   buf_max,
+                         ulong *                 buf_sz ) {
+  ulong off = 0;
+  SER( ulong, root );
+  off += ser_short_u16( buf+off, serde->lockouts_cnt );
+  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++ ) {
+    off += ser_var_int( buf+off, serde->lockouts[i].offset );
+    SER( uchar, lockouts[i].confirmation_count );
+  }
+  SER( fd_hash_t, hash             );
+  SER( uchar,     timestamp_option );
+  if( FD_LIKELY( serde->timestamp_option ) ) {
+    SER( long, timestamp );
+  }
+  SER( fd_hash_t, block_id );
+  *buf_sz = off;
+  return 0;
+}
+
+int
+fd_tower_sync_deserialize( fd_tower_sync_serde_t * serde,
+                           uchar const *           buf,
+                           ulong                   buf_sz ) {
+  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++ ) {
+    off += de_var_int( &serde->lockouts[i].offset, buf+off );
+    DE( uchar, lockouts[i].confirmation_count );
+  }
+  DE( fd_hash_t, hash             );
+  DE( uchar,     timestamp_option );
+  if( FD_LIKELY( serde->timestamp_option ) ) {
+    DE( long, timestamp );
+  }
+  DE( fd_hash_t, block_id );
+  return 0;
+}