Move stake_weight out of fd_types

Author: riptl

src/discof/poh/fd_poh_tile.c

@@ -313,7 +313,7 @@
 #include "../../disco/pack/fd_pack.h"
 #include "../../ballet/sha256/fd_sha256.h"
 #include "../../disco/metrics/fd_metrics.h"
-#include "../../util/pod/fd_pod_format.h"
+#include "../../util/pod/fd_pod.h"
 #include "../../disco/shred/fd_shredder.h"
 #include "../../disco/keyguard/fd_keyload.h"
 #include "../../disco/keyguard/fd_keyswitch.h"

src/flamenco/leaders/fd_leaders.h

@@ -28,7 +28,6 @@
    rotation. */
 
 #include "fd_leaders_base.h"
-#include "../types/fd_types.h"
 #include "../../ballet/wsample/fd_wsample.h"
 
 #define FD_ULONG_MAX(  a, b ) (__builtin_choose_expr( __builtin_constant_p( a ) & __builtin_constant_p( b ),        \

src/flamenco/leaders/fd_leaders_base.h

@@ -1,8 +1,7 @@
 #ifndef HEADER_fd_src_flamenco_leaders_fd_leaders_base_h
 #define HEADER_fd_src_flamenco_leaders_fd_leaders_base_h
 
-#include "../fd_flamenco_base.h"
-#include "../types/fd_types.h"
+#include "../types/fd_types_custom.h"
 
 #define MAX_SLOTS_PER_EPOCH   432000UL
 #define MAX_PUB_CNT           50000UL

src/flamenco/snapshot/fd_snapshot_http.c

@@ -1,6 +1,6 @@
 #include "fd_snapshot_http.h"
 #include "../../waltz/http/picohttpparser.h"
-#include "fd_snapshot.h"
+#include "../../util/net/fd_ip4.h"
 
 #include <assert.h>
 #include <errno.h>

src/flamenco/snapshot/fuzz_snapshot_http.c

@@ -17,6 +17,7 @@
 #include <unistd.h>
 
 #include "../../util/sanitize/fd_fuzz.h"
+#include "../../util/net/fd_ip4.h"
 #include "fd_snapshot_http.h"
 
 struct shared_state {

src/flamenco/types/fd_fuzz_types.h

@@ -387,30 +387,6 @@ void *fd_account_keys_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
   return mem;
 }
 
-void *fd_stake_weight_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
-  fd_stake_weight_t *self = (fd_stake_weight_t *) mem;
-  *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_weight_t);
-  fd_stake_weight_new(mem);
-  fd_pubkey_generate( &self->key, alloc_mem, rng );
-  self->stake = fd_rng_ulong( rng );
-  return mem;
-}
-
-void *fd_stake_weights_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
-  fd_stake_weights_t *self = (fd_stake_weights_t *) mem;
-  *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_weights_t);
-  fd_stake_weights_new(mem);
-  ulong stake_weights_len = fd_rng_ulong( rng ) % 8;
-  self->stake_weights_pool = fd_stake_weight_t_map_join_new( alloc_mem, stake_weights_len );
-  self->stake_weights_root = NULL;
-  for( ulong i=0; i < stake_weights_len; i++ ) {
-    fd_stake_weight_t_mapnode_t * node = fd_stake_weight_t_map_acquire( self->stake_weights_pool );
-    fd_stake_weight_generate( &node->elem, alloc_mem, rng );
-    fd_stake_weight_t_map_insert( self->stake_weights_pool, &self->stake_weights_root, node );
-  }
-  return mem;
-}
-
 void *fd_delegation_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
   fd_delegation_t *self = (fd_delegation_t *) mem;
   *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_delegation_t);

src/flamenco/types/fd_types.c

@@ -2248,139 +2248,6 @@ ulong fd_account_keys_size_global( fd_account_keys_global_t const * self ) {
   return size;
 }
 
-int fd_stake_weight_encode( fd_stake_weight_t const * self, fd_bincode_encode_ctx_t * ctx ) {
-  int err;
-  err = fd_pubkey_encode( &self->key, ctx );
-  if( FD_UNLIKELY( err ) ) return err;
-  err = fd_bincode_uint64_encode( self->stake, ctx );
-  if( FD_UNLIKELY( err ) ) return err;
-  return FD_BINCODE_SUCCESS;
-}
-static inline int fd_stake_weight_decode_footprint_inner( fd_bincode_decode_ctx_t * ctx, ulong * total_sz ) {
-  if( (ulong)ctx->data + 40UL > (ulong)ctx->dataend ) { return FD_BINCODE_ERR_OVERFLOW; };
-  ctx->data = (void *)( (ulong)ctx->data + 40UL );
-  return 0;
-}
-static void fd_stake_weight_decode_inner( void * struct_mem, void * * alloc_mem, fd_bincode_decode_ctx_t * ctx ) {
-  fd_stake_weight_t * self = (fd_stake_weight_t *)struct_mem;
-  fd_pubkey_decode_inner( &self->key, alloc_mem, ctx );
-  fd_bincode_uint64_decode_unsafe( &self->stake, ctx );
-}
-void * fd_stake_weight_decode( void * mem, fd_bincode_decode_ctx_t * ctx ) {
-  fd_stake_weight_t * self = (fd_stake_weight_t *)mem;
-  fd_stake_weight_new( self );
-  void * alloc_region = (uchar *)mem + sizeof(fd_stake_weight_t);
-  void * * alloc_mem = &alloc_region;
-  fd_stake_weight_decode_inner( mem, alloc_mem, ctx );
-  return self;
-}
-void fd_stake_weight_walk( void * w, fd_stake_weight_t const * self, fd_types_walk_fn_t fun, const char *name, uint level, uint varint ) {
-  (void) varint;
-  fun( w, self, name, FD_FLAMENCO_TYPE_MAP, "fd_stake_weight", level++, 0 );
-  fd_pubkey_walk( w, &self->key, fun, "key", level, 0 );
-  fun( w, &self->stake, "stake", FD_FLAMENCO_TYPE_ULONG, "ulong", level, 0  );
-  fun( w, self, name, FD_FLAMENCO_TYPE_MAP_END, "fd_stake_weight", level--, 0 );
-}
-ulong fd_stake_weight_size( fd_stake_weight_t const * self ) {
-  ulong size = 0;
-  size += fd_pubkey_size( &self->key );
-  size += sizeof(ulong);
-  return size;
-}
-
-int fd_stake_weights_encode( fd_stake_weights_t const * self, fd_bincode_encode_ctx_t * ctx ) {
-  int err;
-  if( self->stake_weights_root ) {
-    ulong stake_weights_len = fd_stake_weight_t_map_size( self->stake_weights_pool, self->stake_weights_root );
-    err = fd_bincode_uint64_encode( stake_weights_len, ctx );
-    if( FD_UNLIKELY( err ) ) return err;
-    for( fd_stake_weight_t_mapnode_t * n = fd_stake_weight_t_map_minimum( self->stake_weights_pool, self->stake_weights_root ); n; n = fd_stake_weight_t_map_successor( self->stake_weights_pool, n ) ) {
-      err = fd_stake_weight_encode( &n->elem, ctx );
-      if( FD_UNLIKELY( err ) ) return err;
-    }
-  } else {
-    ulong stake_weights_len = 0;
-    err = fd_bincode_uint64_encode( stake_weights_len, ctx );
-    if( FD_UNLIKELY( err ) ) return err;
-  }
-  return FD_BINCODE_SUCCESS;
-}
-static int fd_stake_weights_decode_footprint_inner( fd_bincode_decode_ctx_t * ctx, ulong * total_sz ) {
-  if( ctx->data>=ctx->dataend ) { return FD_BINCODE_ERR_OVERFLOW; };
-  int err = 0;
-  ulong stake_weights_len = 0UL;
-  err = fd_bincode_uint64_decode( &stake_weights_len, ctx );
-  ulong stake_weights_cnt = !!stake_weights_len ? stake_weights_len : 1;
-  *total_sz += fd_stake_weight_t_map_align() + fd_stake_weight_t_map_footprint( stake_weights_cnt );
-  if( FD_UNLIKELY( err ) ) return err;
-  for( ulong i=0; i < stake_weights_len; i++ ) {
-    err = fd_stake_weight_decode_footprint_inner( ctx, total_sz );
-    if( FD_UNLIKELY( err ) ) return err;
-  }
-  return 0;
-}
-int fd_stake_weights_decode_footprint( fd_bincode_decode_ctx_t * ctx, ulong * total_sz ) {
-  *total_sz += sizeof(fd_stake_weights_t);
-  void const * start_data = ctx->data;
-  int err = fd_stake_weights_decode_footprint_inner( ctx, total_sz );
-  if( ctx->data>ctx->dataend ) { return FD_BINCODE_ERR_OVERFLOW; };
-  ctx->data = start_data;
-  return err;
-}
-static void fd_stake_weights_decode_inner( void * struct_mem, void * * alloc_mem, fd_bincode_decode_ctx_t * ctx ) {
-  fd_stake_weights_t * self = (fd_stake_weights_t *)struct_mem;
-  ulong stake_weights_len;
-  fd_bincode_uint64_decode_unsafe( &stake_weights_len, ctx );
-  self->stake_weights_pool = fd_stake_weight_t_map_join_new( alloc_mem, stake_weights_len );
-  self->stake_weights_root = NULL;
-  for( ulong i=0; i < stake_weights_len; i++ ) {
-    fd_stake_weight_t_mapnode_t * node = fd_stake_weight_t_map_acquire( self->stake_weights_pool );
-    fd_stake_weight_new( &node->elem );
-    fd_stake_weight_decode_inner( &node->elem, alloc_mem, ctx );
-    fd_stake_weight_t_mapnode_t * out = NULL;;
-    fd_stake_weight_t_map_insert_or_replace( self->stake_weights_pool, &self->stake_weights_root, node, &out );
-    if( out != NULL ) {
-      // Unclear how to release the memory...
-      fd_stake_weight_t_map_release( self->stake_weights_pool, out );
-    }
-  }
-}
-void * fd_stake_weights_decode( void * mem, fd_bincode_decode_ctx_t * ctx ) {
-  fd_stake_weights_t * self = (fd_stake_weights_t *)mem;
-  fd_stake_weights_new( self );
-  void * alloc_region = (uchar *)mem + sizeof(fd_stake_weights_t);
-  void * * alloc_mem = &alloc_region;
-  fd_stake_weights_decode_inner( mem, alloc_mem, ctx );
-  return self;
-}
-void fd_stake_weights_new(fd_stake_weights_t * self) {
-  fd_memset( self, 0, sizeof(fd_stake_weights_t) );
-}
-void fd_stake_weights_walk( void * w, fd_stake_weights_t const * self, fd_types_walk_fn_t fun, const char *name, uint level, uint varint ) {
-  (void) varint;
-  fun( w, self, name, FD_FLAMENCO_TYPE_MAP, "fd_stake_weights", level++, 0 );
-  if( self->stake_weights_root ) {
-    for( fd_stake_weight_t_mapnode_t * n = fd_stake_weight_t_map_minimum(self->stake_weights_pool, self->stake_weights_root ); n; n = fd_stake_weight_t_map_successor( self->stake_weights_pool, n ) ) {
-      fd_stake_weight_walk(w, &n->elem, fun, "stake_weights", level, 0 );
-    }
-  }
-  fun( w, self, name, FD_FLAMENCO_TYPE_MAP_END, "fd_stake_weights", level--, 0 );
-}
-ulong fd_stake_weights_size( fd_stake_weights_t const * self ) {
-  ulong size = 0;
-  if( self->stake_weights_root ) {
-    size += sizeof(ulong);
-    ulong max = fd_stake_weight_t_map_max( self->stake_weights_pool );
-    size += fd_stake_weight_t_map_footprint( max );
-    for( fd_stake_weight_t_mapnode_t * n = fd_stake_weight_t_map_minimum( self->stake_weights_pool, self->stake_weights_root ); n; n = fd_stake_weight_t_map_successor( self->stake_weights_pool, n ) ) {
-      size += fd_stake_weight_size( &n->elem ) - sizeof(fd_stake_weight_t);
-    }
-  } else {
-    size += sizeof(ulong);
-  }
-  return size;
-}
-
 int fd_delegation_encode( fd_delegation_t const * self, fd_bincode_encode_ctx_t * ctx ) {
   int err;
   err = fd_pubkey_encode( &self->voter_pubkey, ctx );
@@ -27074,13 +26941,6 @@ long fd_vote_accounts_pair_global_t_map_compare( fd_vote_accounts_pair_global_t_
 long fd_account_keys_pair_t_map_compare( fd_account_keys_pair_t_mapnode_t * left, fd_account_keys_pair_t_mapnode_t * right ) {
   return memcmp( left->elem.key.uc, right->elem.key.uc, sizeof(right->elem.key) );
 }
-#define REDBLK_T fd_stake_weight_t_mapnode_t
-#define REDBLK_NAME fd_stake_weight_t_map
-#define REDBLK_IMPL_STYLE 2
-#include "../../util/tmpl/fd_redblack.c"
-long fd_stake_weight_t_map_compare( fd_stake_weight_t_mapnode_t * left, fd_stake_weight_t_mapnode_t * right ) {
-  return memcmp( left->elem.key.uc, right->elem.key.uc, sizeof(right->elem.key) );
-}
 #define REDBLK_T fd_delegation_pair_t_mapnode_t
 #define REDBLK_NAME fd_delegation_pair_t_map
 #define REDBLK_IMPL_STYLE 2

src/flamenco/types/fd_types.h

@@ -458,43 +458,6 @@ static FD_FN_UNUSED void fd_account_keys_account_keys_pool_update( fd_account_ke
 static FD_FN_UNUSED void fd_account_keys_account_keys_root_update( fd_account_keys_global_t * type, fd_account_keys_pair_t_mapnode_t * root ) {
   type->account_keys_root_offset = !!root ? (ulong)root - (ulong)type : 0UL;
 }
-/* fd_stake_weight_t assigns an Ed25519 public key (node identity) a stake weight number measured in lamports */
-/* Encoded Size: Fixed (40 bytes) */
-struct __attribute__((packed)) fd_stake_weight {
-  fd_pubkey_t key;
-  ulong stake;
-};
-typedef struct fd_stake_weight fd_stake_weight_t;
-#define FD_STAKE_WEIGHT_ALIGN (8UL)
-
-typedef struct fd_stake_weight_t_mapnode fd_stake_weight_t_mapnode_t;
-#define REDBLK_T fd_stake_weight_t_mapnode_t
-#define REDBLK_NAME fd_stake_weight_t_map
-#define REDBLK_IMPL_STYLE 1
-#include "../../util/tmpl/fd_redblack.c"
-struct fd_stake_weight_t_mapnode {
-    fd_stake_weight_t elem;
-    ulong redblack_parent;
-    ulong redblack_left;
-    ulong redblack_right;
-    int redblack_color;
-};
-static inline fd_stake_weight_t_mapnode_t *
-fd_stake_weight_t_map_join_new( void * * alloc_mem, ulong len ) {
-  if( FD_UNLIKELY( 0 == len ) ) len = 1; // prevent underflow
-  *alloc_mem = (void*)fd_ulong_align_up( (ulong)*alloc_mem, fd_stake_weight_t_map_align() );
-  void * map_mem = *alloc_mem;
-  *alloc_mem = (uchar *)*alloc_mem + fd_stake_weight_t_map_footprint( len );
-  return fd_stake_weight_t_map_join( fd_stake_weight_t_map_new( map_mem, len ) );
-}
-/* Encoded Size: Dynamic */
-struct fd_stake_weights {
-  fd_stake_weight_t_mapnode_t * stake_weights_pool;
-  fd_stake_weight_t_mapnode_t * stake_weights_root;
-};
-typedef struct fd_stake_weights fd_stake_weights_t;
-#define FD_STAKE_WEIGHTS_ALIGN alignof(fd_stake_weights_t)
-
 /* https://github.com/solana-labs/solana/blob/8f2c8b8388a495d2728909e30460aa40dcc5d733/sdk/program/src/stake/state.rs#L303 */
 /* Encoded Size: Fixed (64 bytes) */
 struct fd_delegation {
@@ -3956,26 +3919,6 @@ void * fd_account_keys_decode_global( void * mem, fd_bincode_decode_ctx_t * ctx
 int fd_account_keys_encode_global( fd_account_keys_global_t const * self, fd_bincode_encode_ctx_t * ctx );
 ulong fd_account_keys_size_global( fd_account_keys_global_t const * self );
 
-static inline void fd_stake_weight_new( fd_stake_weight_t * self ) { fd_memset( self, 0, sizeof(fd_stake_weight_t) ); }
-int fd_stake_weight_encode( fd_stake_weight_t const * self, fd_bincode_encode_ctx_t * ctx );
-void fd_stake_weight_walk( void * w, fd_stake_weight_t const * self, fd_types_walk_fn_t fun, const char *name, uint level, uint varint );
-ulong fd_stake_weight_size( fd_stake_weight_t const * self );
-static inline ulong fd_stake_weight_align( void ) { return FD_STAKE_WEIGHT_ALIGN; }
-static inline int fd_stake_weight_decode_footprint( fd_bincode_decode_ctx_t * ctx, ulong * total_sz ) {
-  *total_sz += sizeof(fd_stake_weight_t);
-  if( (ulong)ctx->data + 40UL > (ulong)ctx->dataend ) { return FD_BINCODE_ERR_OVERFLOW; };
-  return 0;
-}
-void * fd_stake_weight_decode( void * mem, fd_bincode_decode_ctx_t * ctx );
-
-void fd_stake_weights_new( fd_stake_weights_t * self );
-int fd_stake_weights_encode( fd_stake_weights_t const * self, fd_bincode_encode_ctx_t * ctx );
-void fd_stake_weights_walk( void * w, fd_stake_weights_t const * self, fd_types_walk_fn_t fun, const char *name, uint level, uint varint );
-ulong fd_stake_weights_size( fd_stake_weights_t const * self );
-static inline ulong fd_stake_weights_align( void ) { return FD_STAKE_WEIGHTS_ALIGN; }
-int fd_stake_weights_decode_footprint( fd_bincode_decode_ctx_t * ctx, ulong * total_sz );
-void * fd_stake_weights_decode( void * mem, fd_bincode_decode_ctx_t * ctx );
-
 static inline void fd_delegation_new( fd_delegation_t * self ) { fd_memset( self, 0, sizeof(fd_delegation_t) ); }
 int fd_delegation_encode( fd_delegation_t const * self, fd_bincode_encode_ctx_t * ctx );
 void fd_delegation_walk( void * w, fd_delegation_t const * self, fd_types_walk_fn_t fun, const char *name, uint level, uint varint );

src/flamenco/types/fd_types.json

@@ -285,23 +285,6 @@
         { "name": "account_keys", "type": "map", "element": "account_keys_pair", "key": "key", "minalloc":100000 }
       ]
     },
-    {
-      "name": "stake_weight",
-      "packed": true,
-      "type": "struct",
-      "fields": [
-        { "name": "key", "type": "pubkey" },
-        { "name": "stake", "type": "ulong" }
-      ],
-      "comment": "fd_stake_weight_t assigns an Ed25519 public key (node identity) a stake weight number measured in lamports"
-    },
-    {
-      "name": "stake_weights",
-      "type": "struct",
-      "fields": [
-        { "name": "stake_weights", "type": "map", "element": "stake_weight", "key": "key" }
-      ]
-    },
     {
       "name": "delegation",
       "type": "struct",

src/flamenco/types/fd_types_custom.c

@@ -343,3 +343,11 @@ void fd_vote_accounts_decode_inner_global( void * struct_mem, void * * alloc_mem
   self->vote_accounts_pool_offset = (ulong)fd_vote_accounts_pair_global_t_map_leave( vote_accounts_pool ) - (ulong)struct_mem;
   self->vote_accounts_root_offset = (ulong)vote_accounts_root - (ulong)struct_mem;
 }
+
+#define REDBLK_T fd_stake_weight_t_mapnode_t
+#define REDBLK_NAME fd_stake_weight_t_map
+#define REDBLK_IMPL_STYLE 2
+#include "../../util/tmpl/fd_redblack.c"
+long fd_stake_weight_t_map_compare( fd_stake_weight_t_mapnode_t * left, fd_stake_weight_t_mapnode_t * right ) {
+  return memcmp( left->elem.key.uc, right->elem.key.uc, sizeof(right->elem.key) );
+}