Line data    Source code

       1             : /* Automatically generated by fd_pb_gen.py.  Do not edit. */
       2             : 
       3             : #include "gossip.pb.h"
       4             : 
       5             : static int
       6             : fd_exec_test_gossip_ping_encode( fd_pb_encoder_t * enc,
       7        1694 :                                  void const *      msg_ ) {
       8        1694 :   fd_exec_test_gossip_ping_t const * msg = msg_;
       9        1694 :   if( msg->from && msg->from->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 1U, msg->from->bytes, msg->from->size ) ) ) return 0;
      10        1696 :   if( msg->token && msg->token->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 2U, msg->token->bytes, msg->token->size ) ) ) return 0;
      11        1697 :   if( msg->signature && msg->signature->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 3U, msg->signature->bytes, msg->signature->size ) ) ) return 0;
      12        1694 :   return 1;
      13        1694 : }
      14             : 
      15             : static int
      16             : fd_exec_test_gossip_ping_decode( fd_pb_inbuf_t * in,
      17             :                                  void *          msg_,
      18         849 :                                  fd_spad_t *     spad ) {
      19         849 :   fd_exec_test_gossip_ping_t * msg = msg_;
      20        3390 :   while( fd_pb_inbuf_sz( in ) ) {
      21        2542 :     fd_pb_tlv_t tlv[1];
      22        2542 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
      23        2542 :     switch( tlv->field_id ) {
      24         849 :     case 1:
      25         849 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->from ) ) ) return 0;
      26         849 :       break;
      27         849 :     case 2:
      28         849 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->token ) ) ) return 0;
      29         849 :       break;
      30         850 :     case 3:
      31         850 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->signature ) ) ) return 0;
      32         850 :       break;
      33         850 :     default:
      34           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
      35           0 :       break;
      36        2542 :     }
      37        2542 :   }
      38         848 :   return 1;
      39         849 : }
      40             : 
      41             : fd_pb_msgdesc_t const fd_exec_test_gossip_ping_desc = {
      42             :   .encode = fd_exec_test_gossip_ping_encode,
      43             :   .decode = fd_exec_test_gossip_ping_decode
      44             : };
      45             : 
      46             : static int
      47             : fd_exec_test_gossip_pong_encode( fd_pb_encoder_t * enc,
      48        1700 :                                  void const *      msg_ ) {
      49        1700 :   fd_exec_test_gossip_pong_t const * msg = msg_;
      50        1701 :   if( msg->from && msg->from->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 1U, msg->from->bytes, msg->from->size ) ) ) return 0;
      51        1705 :   if( msg->hash && msg->hash->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 2U, msg->hash->bytes, msg->hash->size ) ) ) return 0;
      52        1708 :   if( msg->signature && msg->signature->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 3U, msg->signature->bytes, msg->signature->size ) ) ) return 0;
      53        1700 :   return 1;
      54        1700 : }
      55             : 
      56             : static int
      57             : fd_exec_test_gossip_pong_decode( fd_pb_inbuf_t * in,
      58             :                                  void *          msg_,
      59         857 :                                  fd_spad_t *     spad ) {
      60         857 :   fd_exec_test_gossip_pong_t * msg = msg_;
      61        3413 :   while( fd_pb_inbuf_sz( in ) ) {
      62        2558 :     fd_pb_tlv_t tlv[1];
      63        2558 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
      64        2558 :     switch( tlv->field_id ) {
      65         856 :     case 1:
      66         856 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->from ) ) ) return 0;
      67         856 :       break;
      68         856 :     case 2:
      69         856 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->hash ) ) ) return 0;
      70         856 :       break;
      71         856 :     case 3:
      72         856 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->signature ) ) ) return 0;
      73         856 :       break;
      74         856 :     default:
      75           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
      76           0 :       break;
      77        2558 :     }
      78        2558 :   }
      79         855 :   return 1;
      80         857 : }
      81             : 
      82             : fd_pb_msgdesc_t const fd_exec_test_gossip_pong_desc = {
      83             :   .encode = fd_exec_test_gossip_pong_encode,
      84             :   .decode = fd_exec_test_gossip_pong_decode
      85             : };
      86             : 
      87             : static int
      88             : fd_exec_test_gossip_bloom_encode( fd_pb_encoder_t * enc,
      89          12 :                                   void const *      msg_ ) {
      90          12 :   fd_exec_test_gossip_bloom_t const * msg = msg_;
      91          12 :   if( FD_UNLIKELY( !fd_pb_enc_packed( enc, 1U, FD_PB_GEN_UINT64, msg->keys, msg->keys_count ) ) ) return 0;
      92          12 :   if( msg->bits && msg->bits->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 2U, msg->bits->bytes, msg->bits->size ) ) ) return 0;
      93          12 :   if( msg->num_bits_set && FD_UNLIKELY( !fd_pb_push_uint64( enc, 3U, msg->num_bits_set ) ) ) return 0;
      94          12 :   return 1;
      95          12 : }
      96             : 
      97             : static int
      98             : fd_exec_test_gossip_bloom_decode( fd_pb_inbuf_t * in,
      99             :                                   void *          msg_,
     100           6 :                                   fd_spad_t *     spad ) {
     101           6 :   fd_exec_test_gossip_bloom_t * msg = msg_;
     102           9 :   while( fd_pb_inbuf_sz( in ) ) {
     103           3 :     fd_pb_tlv_t tlv[1];
     104           3 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     105           3 :     switch( tlv->field_id ) {
     106           0 :     case 1:
     107           0 :       if( FD_UNLIKELY( !fd_pb_dec_repeated( in, tlv, spad, FD_PB_GEN_UINT64, &msg->keys, &msg->keys_count ) ) ) return 0;
     108           0 :       break;
     109           2 :     case 2:
     110           2 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->bits ) ) ) return 0;
     111           2 :       break;
     112           2 :     case 3:
     113           1 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->num_bits_set ) ) ) return 0;
     114           1 :       break;
     115           1 :     default:
     116           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     117           0 :       break;
     118           3 :     }
     119           3 :   }
     120           6 :   return 1;
     121           6 : }
     122             : 
     123             : fd_pb_msgdesc_t const fd_exec_test_gossip_bloom_desc = {
     124             :   .encode = fd_exec_test_gossip_bloom_encode,
     125             :   .decode = fd_exec_test_gossip_bloom_decode
     126             : };
     127             : 
     128             : static int
     129             : fd_exec_test_gossip_crds_filter_encode( fd_pb_encoder_t * enc,
     130          12 :                                         void const *      msg_ ) {
     131          12 :   fd_exec_test_gossip_crds_filter_t const * msg = msg_;
     132          12 :   if( msg->has_filter && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 1U, &fd_exec_test_gossip_bloom_desc, &msg->filter ) ) ) return 0;
     133          12 :   if( msg->mask && FD_UNLIKELY( !fd_pb_push_uint64( enc, 2U, msg->mask ) ) ) return 0;
     134          12 :   if( msg->mask_bits && FD_UNLIKELY( !fd_pb_push_uint32( enc, 3U, msg->mask_bits ) ) ) return 0;
     135          12 :   return 1;
     136          12 : }
     137             : 
     138             : static int
     139             : fd_exec_test_gossip_crds_filter_decode( fd_pb_inbuf_t * in,
     140             :                                         void *          msg_,
     141           6 :                                         fd_spad_t *     spad ) {
     142           6 :   fd_exec_test_gossip_crds_filter_t * msg = msg_;
     143          23 :   while( fd_pb_inbuf_sz( in ) ) {
     144          17 :     fd_pb_tlv_t tlv[1];
     145          17 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     146          17 :     switch( tlv->field_id ) {
     147           6 :     case 1:
     148           6 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_bloom_desc, &msg->filter ) ) ) return 0;
     149           6 :       msg->has_filter = 1;
     150           6 :       break;
     151           5 :     case 2:
     152           5 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->mask ) ) ) return 0;
     153           5 :       break;
     154           6 :     case 3:
     155           6 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->mask_bits ) ) ) return 0;
     156           6 :       break;
     157           6 :     default:
     158           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     159           0 :       break;
     160          17 :     }
     161          17 :   }
     162           6 :   return 1;
     163           6 : }
     164             : 
     165             : fd_pb_msgdesc_t const fd_exec_test_gossip_crds_filter_desc = {
     166             :   .encode = fd_exec_test_gossip_crds_filter_encode,
     167             :   .decode = fd_exec_test_gossip_crds_filter_decode
     168             : };
     169             : 
     170             : static int
     171             : fd_exec_test_gossip_ipv6_addr_encode( fd_pb_encoder_t * enc,
     172           0 :                                       void const *      msg_ ) {
     173           0 :   fd_exec_test_gossip_ipv6_addr_t const * msg = msg_;
     174           0 :   if( msg->hi && FD_UNLIKELY( !fd_pb_push_fixed64( enc, 1U, msg->hi ) ) ) return 0;
     175           0 :   if( msg->lo && FD_UNLIKELY( !fd_pb_push_fixed64( enc, 2U, msg->lo ) ) ) return 0;
     176           0 :   return 1;
     177           0 : }
     178             : 
     179             : static int
     180             : fd_exec_test_gossip_ipv6_addr_decode( fd_pb_inbuf_t * in,
     181             :                                       void *          msg_,
     182           0 :                                       fd_spad_t *     spad FD_PARAM_UNUSED ) {
     183           0 :   fd_exec_test_gossip_ipv6_addr_t * msg = msg_;
     184           0 :   while( fd_pb_inbuf_sz( in ) ) {
     185           0 :     fd_pb_tlv_t tlv[1];
     186           0 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     187           0 :     switch( tlv->field_id ) {
     188           0 :     case 1:
     189           0 :       if( FD_UNLIKELY( !fd_pb_dec_fixed64( tlv, &msg->hi ) ) ) return 0;
     190           0 :       break;
     191           0 :     case 2:
     192           0 :       if( FD_UNLIKELY( !fd_pb_dec_fixed64( tlv, &msg->lo ) ) ) return 0;
     193           0 :       break;
     194           0 :     default:
     195           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     196           0 :       break;
     197           0 :     }
     198           0 :   }
     199           0 :   return 1;
     200           0 : }
     201             : 
     202             : fd_pb_msgdesc_t const fd_exec_test_gossip_ipv6_addr_desc = {
     203             :   .encode = fd_exec_test_gossip_ipv6_addr_encode,
     204             :   .decode = fd_exec_test_gossip_ipv6_addr_decode
     205             : };
     206             : 
     207             : static int
     208             : fd_exec_test_gossip_ip_addr_encode( fd_pb_encoder_t * enc,
     209          88 :                                     void const *      msg_ ) {
     210          88 :   fd_exec_test_gossip_ip_addr_t const * msg = msg_;
     211          88 :   if( msg->which_addr==1 && FD_UNLIKELY( !fd_pb_push_fixed32( enc, 1U, msg->addr.ipv4 ) ) ) return 0;
     212          88 :   if( msg->which_addr==2 && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 2U, &fd_exec_test_gossip_ipv6_addr_desc, &msg->addr.ipv6 ) ) ) return 0;
     213          88 :   return 1;
     214          88 : }
     215             : 
     216             : static int
     217             : fd_exec_test_gossip_ip_addr_decode( fd_pb_inbuf_t * in,
     218             :                                     void *          msg_,
     219          44 :                                     fd_spad_t *     spad FD_PARAM_UNUSED ) {
     220          44 :   fd_exec_test_gossip_ip_addr_t * msg = msg_;
     221          88 :   while( fd_pb_inbuf_sz( in ) ) {
     222          44 :     fd_pb_tlv_t tlv[1];
     223          44 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     224          44 :     switch( tlv->field_id ) {
     225          44 :     case 1:
     226          44 :       if( msg->which_addr!=1 ) fd_memset( &msg->addr, 0, sizeof(msg->addr) );
     227          44 :       if( FD_UNLIKELY( !fd_pb_dec_fixed32( tlv, &msg->addr.ipv4 ) ) ) return 0;
     228          44 :       msg->which_addr = 1;
     229          44 :       break;
     230           0 :     case 2:
     231           0 :       if( msg->which_addr!=2 ) fd_memset( &msg->addr, 0, sizeof(msg->addr) );
     232           0 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_ipv6_addr_desc, &msg->addr.ipv6 ) ) ) return 0;
     233           0 :       msg->which_addr = 2;
     234           0 :       break;
     235           0 :     default:
     236           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     237           0 :       break;
     238          44 :     }
     239          44 :   }
     240          44 :   return 1;
     241          44 : }
     242             : 
     243             : fd_pb_msgdesc_t const fd_exec_test_gossip_ip_addr_desc = {
     244             :   .encode = fd_exec_test_gossip_ip_addr_encode,
     245             :   .decode = fd_exec_test_gossip_ip_addr_decode
     246             : };
     247             : 
     248             : static int
     249             : fd_exec_test_gossip_socket_entry_encode( fd_pb_encoder_t * enc,
     250          88 :                                          void const *      msg_ ) {
     251          88 :   fd_exec_test_gossip_socket_entry_t const * msg = msg_;
     252          88 :   if( msg->key && FD_UNLIKELY( !fd_pb_push_uint32( enc, 1U, msg->key ) ) ) return 0;
     253          88 :   if( msg->index && FD_UNLIKELY( !fd_pb_push_uint32( enc, 2U, msg->index ) ) ) return 0;
     254          88 :   if( msg->offset && FD_UNLIKELY( !fd_pb_push_uint32( enc, 3U, msg->offset ) ) ) return 0;
     255          88 :   return 1;
     256          88 : }
     257             : 
     258             : static int
     259             : fd_exec_test_gossip_socket_entry_decode( fd_pb_inbuf_t * in,
     260             :                                          void *          msg_,
     261          44 :                                          fd_spad_t *     spad FD_PARAM_UNUSED ) {
     262          44 :   fd_exec_test_gossip_socket_entry_t * msg = msg_;
     263         130 :   while( fd_pb_inbuf_sz( in ) ) {
     264          86 :     fd_pb_tlv_t tlv[1];
     265          86 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     266          86 :     switch( tlv->field_id ) {
     267          21 :     case 1:
     268          21 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->key ) ) ) return 0;
     269          21 :       break;
     270          21 :     case 2:
     271          21 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->index ) ) ) return 0;
     272          21 :       break;
     273          44 :     case 3:
     274          44 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->offset ) ) ) return 0;
     275          44 :       break;
     276          44 :     default:
     277           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     278           0 :       break;
     279          86 :     }
     280          86 :   }
     281          44 :   return 1;
     282          44 : }
     283             : 
     284             : fd_pb_msgdesc_t const fd_exec_test_gossip_socket_entry_desc = {
     285             :   .encode = fd_exec_test_gossip_socket_entry_encode,
     286             :   .decode = fd_exec_test_gossip_socket_entry_decode
     287             : };
     288             : 
     289             : static int
     290             : fd_exec_test_gossip_contact_info_encode( fd_pb_encoder_t * enc,
     291          48 :                                          void const *      msg_ ) {
     292          48 :   fd_exec_test_gossip_contact_info_t const * msg = msg_;
     293          48 :   if( msg->pubkey && msg->pubkey->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 1U, msg->pubkey->bytes, msg->pubkey->size ) ) ) return 0;
     294          48 :   if( msg->wallclock && FD_UNLIKELY( !fd_pb_push_uint64( enc, 2U, msg->wallclock ) ) ) return 0;
     295          48 :   if( msg->outset && FD_UNLIKELY( !fd_pb_push_uint64( enc, 3U, msg->outset ) ) ) return 0;
     296          48 :   if( msg->shred_version && FD_UNLIKELY( !fd_pb_push_uint32( enc, 4U, msg->shred_version ) ) ) return 0;
     297          48 :   if( msg->version_major && FD_UNLIKELY( !fd_pb_push_uint32( enc, 5U, msg->version_major ) ) ) return 0;
     298          48 :   if( msg->version_minor && FD_UNLIKELY( !fd_pb_push_uint32( enc, 6U, msg->version_minor ) ) ) return 0;
     299          48 :   if( msg->version_patch && FD_UNLIKELY( !fd_pb_push_uint32( enc, 7U, msg->version_patch ) ) ) return 0;
     300          48 :   if( msg->version_commit && FD_UNLIKELY( !fd_pb_push_uint32( enc, 8U, msg->version_commit ) ) ) return 0;
     301          48 :   if( msg->version_feature_set && FD_UNLIKELY( !fd_pb_push_uint32( enc, 9U, msg->version_feature_set ) ) ) return 0;
     302          48 :   if( msg->version_client && FD_UNLIKELY( !fd_pb_push_uint32( enc, 10U, msg->version_client ) ) ) return 0;
     303         136 :   for( ulong i=0UL; i<msg->addrs_count; i++ ) {
     304          88 :     if( FD_UNLIKELY( !fd_pb_enc_submsg( enc, 11U, &fd_exec_test_gossip_ip_addr_desc, &msg->addrs[ i ] ) ) ) return 0;
     305          88 :   }
     306         136 :   for( ulong i=0UL; i<msg->sockets_count; i++ ) {
     307          88 :     if( FD_UNLIKELY( !fd_pb_enc_submsg( enc, 12U, &fd_exec_test_gossip_socket_entry_desc, &msg->sockets[ i ] ) ) ) return 0;
     308          88 :   }
     309          48 :   if( msg->extensions && msg->extensions->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 13U, msg->extensions->bytes, msg->extensions->size ) ) ) return 0;
     310          48 :   return 1;
     311          48 : }
     312             : 
     313             : static int
     314             : fd_exec_test_gossip_contact_info_decode( fd_pb_inbuf_t * in,
     315             :                                          void *          msg_,
     316          24 :                                          fd_spad_t *     spad ) {
     317          24 :   fd_exec_test_gossip_contact_info_t * msg = msg_;
     318         328 :   while( fd_pb_inbuf_sz( in ) ) {
     319         304 :     fd_pb_tlv_t tlv[1];
     320         304 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     321         304 :     switch( tlv->field_id ) {
     322          24 :     case 1:
     323          24 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->pubkey ) ) ) return 0;
     324          24 :       break;
     325          24 :     case 2:
     326          23 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->wallclock ) ) ) return 0;
     327          23 :       break;
     328          23 :     case 3:
     329          23 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->outset ) ) ) return 0;
     330          23 :       break;
     331          23 :     case 4:
     332          23 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->shred_version ) ) ) return 0;
     333          23 :       break;
     334          23 :     case 5:
     335          21 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->version_major ) ) ) return 0;
     336          21 :       break;
     337          21 :     case 6:
     338          21 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->version_minor ) ) ) return 0;
     339          21 :       break;
     340          22 :     case 7:
     341          22 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->version_patch ) ) ) return 0;
     342          22 :       break;
     343          23 :     case 8:
     344          23 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->version_commit ) ) ) return 0;
     345          23 :       break;
     346          23 :     case 9:
     347          23 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->version_feature_set ) ) ) return 0;
     348          23 :       break;
     349          23 :     case 10:
     350          13 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->version_client ) ) ) return 0;
     351          13 :       break;
     352          44 :     case 11:
     353          44 :       {
     354          44 :         void * ele = fd_pb_dec_grow( spad, &msg->addrs, &msg->addrs_count, alignof(fd_exec_test_gossip_ip_addr_t), sizeof(fd_exec_test_gossip_ip_addr_t) );
     355          44 :         if( FD_UNLIKELY( !ele ) ) return 0;
     356          44 :         if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_ip_addr_desc, ele ) ) ) return 0;
     357          44 :       }
     358          44 :       break;
     359          44 :     case 12:
     360          44 :       {
     361          44 :         void * ele = fd_pb_dec_grow( spad, &msg->sockets, &msg->sockets_count, alignof(fd_exec_test_gossip_socket_entry_t), sizeof(fd_exec_test_gossip_socket_entry_t) );
     362          44 :         if( FD_UNLIKELY( !ele ) ) return 0;
     363          44 :         if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_socket_entry_desc, ele ) ) ) return 0;
     364          44 :       }
     365          44 :       break;
     366          44 :     case 13:
     367           0 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->extensions ) ) ) return 0;
     368           0 :       break;
     369           0 :     default:
     370           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     371           0 :       break;
     372         304 :     }
     373         304 :   }
     374          24 :   return 1;
     375          24 : }
     376             : 
     377             : fd_pb_msgdesc_t const fd_exec_test_gossip_contact_info_desc = {
     378             :   .encode = fd_exec_test_gossip_contact_info_encode,
     379             :   .decode = fd_exec_test_gossip_contact_info_decode
     380             : };
     381             : 
     382             : static int
     383             : fd_exec_test_gossip_vote_encode( fd_pb_encoder_t * enc,
     384         104 :                                  void const *      msg_ ) {
     385         104 :   fd_exec_test_gossip_vote_t const * msg = msg_;
     386         104 :   if( msg->index && FD_UNLIKELY( !fd_pb_push_uint32( enc, 1U, msg->index ) ) ) return 0;
     387         104 :   if( msg->from && msg->from->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 2U, msg->from->bytes, msg->from->size ) ) ) return 0;
     388         104 :   if( msg->wallclock && FD_UNLIKELY( !fd_pb_push_uint64( enc, 3U, msg->wallclock ) ) ) return 0;
     389         104 :   if( msg->transaction && msg->transaction->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 4U, msg->transaction->bytes, msg->transaction->size ) ) ) return 0;
     390         104 :   return 1;
     391         104 : }
     392             : 
     393             : static int
     394             : fd_exec_test_gossip_vote_decode( fd_pb_inbuf_t * in,
     395             :                                  void *          msg_,
     396          52 :                                  fd_spad_t *     spad ) {
     397          52 :   fd_exec_test_gossip_vote_t * msg = msg_;
     398         259 :   while( fd_pb_inbuf_sz( in ) ) {
     399         207 :     fd_pb_tlv_t tlv[1];
     400         207 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     401         207 :     switch( tlv->field_id ) {
     402          51 :     case 1:
     403          51 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->index ) ) ) return 0;
     404          51 :       break;
     405          52 :     case 2:
     406          52 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->from ) ) ) return 0;
     407          52 :       break;
     408          52 :     case 3:
     409          52 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->wallclock ) ) ) return 0;
     410          52 :       break;
     411          52 :     case 4:
     412          52 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->transaction ) ) ) return 0;
     413          52 :       break;
     414          52 :     default:
     415           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     416           0 :       break;
     417         207 :     }
     418         207 :   }
     419          52 :   return 1;
     420          52 : }
     421             : 
     422             : fd_pb_msgdesc_t const fd_exec_test_gossip_vote_desc = {
     423             :   .encode = fd_exec_test_gossip_vote_encode,
     424             :   .decode = fd_exec_test_gossip_vote_decode
     425             : };
     426             : 
     427             : static int
     428             : fd_exec_test_gossip_lowest_slot_encode( fd_pb_encoder_t * enc,
     429         126 :                                         void const *      msg_ ) {
     430         126 :   fd_exec_test_gossip_lowest_slot_t const * msg = msg_;
     431         126 :   if( msg->index && FD_UNLIKELY( !fd_pb_push_uint32( enc, 1U, msg->index ) ) ) return 0;
     432         126 :   if( msg->from && msg->from->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 2U, msg->from->bytes, msg->from->size ) ) ) return 0;
     433         126 :   if( msg->lowest && FD_UNLIKELY( !fd_pb_push_uint64( enc, 3U, msg->lowest ) ) ) return 0;
     434         126 :   if( msg->wallclock && FD_UNLIKELY( !fd_pb_push_uint64( enc, 4U, msg->wallclock ) ) ) return 0;
     435         126 :   return 1;
     436         126 : }
     437             : 
     438             : static int
     439             : fd_exec_test_gossip_lowest_slot_decode( fd_pb_inbuf_t * in,
     440             :                                         void *          msg_,
     441          63 :                                         fd_spad_t *     spad ) {
     442          63 :   fd_exec_test_gossip_lowest_slot_t * msg = msg_;
     443         251 :   while( fd_pb_inbuf_sz( in ) ) {
     444         189 :     fd_pb_tlv_t tlv[1];
     445         189 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     446         189 :     switch( tlv->field_id ) {
     447           0 :     case 1:
     448           0 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->index ) ) ) return 0;
     449           0 :       break;
     450          63 :     case 2:
     451          63 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->from ) ) ) return 0;
     452          63 :       break;
     453          63 :     case 3:
     454          63 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->lowest ) ) ) return 0;
     455          63 :       break;
     456          63 :     case 4:
     457          63 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->wallclock ) ) ) return 0;
     458          63 :       break;
     459          63 :     default:
     460           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     461           0 :       break;
     462         189 :     }
     463         189 :   }
     464          62 :   return 1;
     465          63 : }
     466             : 
     467             : fd_pb_msgdesc_t const fd_exec_test_gossip_lowest_slot_desc = {
     468             :   .encode = fd_exec_test_gossip_lowest_slot_encode,
     469             :   .decode = fd_exec_test_gossip_lowest_slot_decode
     470             : };
     471             : 
     472             : static int
     473             : fd_exec_test_gossip_compressed_slots_encode( fd_pb_encoder_t * enc,
     474         150 :                                              void const *      msg_ ) {
     475         150 :   fd_exec_test_gossip_compressed_slots_t const * msg = msg_;
     476         150 :   if( msg->first_slot && FD_UNLIKELY( !fd_pb_push_uint64( enc, 1U, msg->first_slot ) ) ) return 0;
     477         150 :   if( msg->num && FD_UNLIKELY( !fd_pb_push_uint64( enc, 2U, msg->num ) ) ) return 0;
     478         150 :   if( msg->which_data==3 && FD_UNLIKELY( !fd_pb_enc_bytes_ptr( enc, 3U, msg->data.uncompressed ) ) ) return 0;
     479         150 :   if( msg->which_data==4 && FD_UNLIKELY( !fd_pb_enc_bytes_ptr( enc, 4U, msg->data.flate2 ) ) ) return 0;
     480         150 :   return 1;
     481         150 : }
     482             : 
     483             : static int
     484             : fd_exec_test_gossip_compressed_slots_decode( fd_pb_inbuf_t * in,
     485             :                                              void *          msg_,
     486          75 :                                              fd_spad_t *     spad ) {
     487          75 :   fd_exec_test_gossip_compressed_slots_t * msg = msg_;
     488         297 :   while( fd_pb_inbuf_sz( in ) ) {
     489         222 :     fd_pb_tlv_t tlv[1];
     490         222 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     491         222 :     switch( tlv->field_id ) {
     492          72 :     case 1:
     493          72 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->first_slot ) ) ) return 0;
     494          72 :       break;
     495          75 :     case 2:
     496          75 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->num ) ) ) return 0;
     497          75 :       break;
     498          75 :     case 3:
     499          43 :       if( msg->which_data!=3 ) fd_memset( &msg->data, 0, sizeof(msg->data) );
     500          43 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->data.uncompressed ) ) ) return 0;
     501          43 :       msg->which_data = 3;
     502          43 :       break;
     503          32 :     case 4:
     504          32 :       if( msg->which_data!=4 ) fd_memset( &msg->data, 0, sizeof(msg->data) );
     505          32 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->data.flate2 ) ) ) return 0;
     506          32 :       msg->which_data = 4;
     507          32 :       break;
     508           0 :     default:
     509           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     510           0 :       break;
     511         222 :     }
     512         222 :   }
     513          75 :   return 1;
     514          75 : }
     515             : 
     516             : fd_pb_msgdesc_t const fd_exec_test_gossip_compressed_slots_desc = {
     517             :   .encode = fd_exec_test_gossip_compressed_slots_encode,
     518             :   .decode = fd_exec_test_gossip_compressed_slots_decode
     519             : };
     520             : 
     521             : static int
     522             : fd_exec_test_gossip_epoch_slots_encode( fd_pb_encoder_t * enc,
     523         102 :                                         void const *      msg_ ) {
     524         102 :   fd_exec_test_gossip_epoch_slots_t const * msg = msg_;
     525         102 :   if( msg->index && FD_UNLIKELY( !fd_pb_push_uint32( enc, 1U, msg->index ) ) ) return 0;
     526         102 :   if( msg->from && msg->from->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 2U, msg->from->bytes, msg->from->size ) ) ) return 0;
     527         102 :   if( msg->wallclock && FD_UNLIKELY( !fd_pb_push_uint64( enc, 3U, msg->wallclock ) ) ) return 0;
     528         252 :   for( ulong i=0UL; i<msg->slots_count; i++ ) {
     529         150 :     if( FD_UNLIKELY( !fd_pb_enc_submsg( enc, 4U, &fd_exec_test_gossip_compressed_slots_desc, &msg->slots[ i ] ) ) ) return 0;
     530         150 :   }
     531         102 :   return 1;
     532         102 : }
     533             : 
     534             : static int
     535             : fd_exec_test_gossip_epoch_slots_decode( fd_pb_inbuf_t * in,
     536             :                                         void *          msg_,
     537          51 :                                         fd_spad_t *     spad ) {
     538          51 :   fd_exec_test_gossip_epoch_slots_t * msg = msg_;
     539         276 :   while( fd_pb_inbuf_sz( in ) ) {
     540         225 :     fd_pb_tlv_t tlv[1];
     541         225 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     542         225 :     switch( tlv->field_id ) {
     543          48 :     case 1:
     544          48 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->index ) ) ) return 0;
     545          48 :       break;
     546          51 :     case 2:
     547          51 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->from ) ) ) return 0;
     548          51 :       break;
     549          51 :     case 3:
     550          51 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->wallclock ) ) ) return 0;
     551          51 :       break;
     552          75 :     case 4:
     553          75 :       {
     554          75 :         void * ele = fd_pb_dec_grow( spad, &msg->slots, &msg->slots_count, alignof(fd_exec_test_gossip_compressed_slots_t), sizeof(fd_exec_test_gossip_compressed_slots_t) );
     555          75 :         if( FD_UNLIKELY( !ele ) ) return 0;
     556          75 :         if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_compressed_slots_desc, ele ) ) ) return 0;
     557          75 :       }
     558          75 :       break;
     559          75 :     default:
     560           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     561           0 :       break;
     562         225 :     }
     563         225 :   }
     564          51 :   return 1;
     565          51 : }
     566             : 
     567             : fd_pb_msgdesc_t const fd_exec_test_gossip_epoch_slots_desc = {
     568             :   .encode = fd_exec_test_gossip_epoch_slots_encode,
     569             :   .decode = fd_exec_test_gossip_epoch_slots_decode
     570             : };
     571             : 
     572             : static int
     573             : fd_exec_test_gossip_incremental_hash_encode( fd_pb_encoder_t * enc,
     574         177 :                                              void const *      msg_ ) {
     575         177 :   fd_exec_test_gossip_incremental_hash_t const * msg = msg_;
     576         177 :   if( msg->slot && FD_UNLIKELY( !fd_pb_push_uint64( enc, 1U, msg->slot ) ) ) return 0;
     577         178 :   if( msg->hash && msg->hash->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 2U, msg->hash->bytes, msg->hash->size ) ) ) return 0;
     578         177 :   return 1;
     579         177 : }
     580             : 
     581             : static int
     582             : fd_exec_test_gossip_incremental_hash_decode( fd_pb_inbuf_t * in,
     583             :                                              void *          msg_,
     584          87 :                                              fd_spad_t *     spad ) {
     585          87 :   fd_exec_test_gossip_incremental_hash_t * msg = msg_;
     586         264 :   while( fd_pb_inbuf_sz( in ) ) {
     587         175 :     fd_pb_tlv_t tlv[1];
     588         175 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     589         175 :     switch( tlv->field_id ) {
     590          88 :     case 1:
     591          88 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->slot ) ) ) return 0;
     592          88 :       break;
     593          89 :     case 2:
     594          89 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->hash ) ) ) return 0;
     595          89 :       break;
     596          89 :     default:
     597           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     598           0 :       break;
     599         175 :     }
     600         175 :   }
     601          89 :   return 1;
     602          87 : }
     603             : 
     604             : fd_pb_msgdesc_t const fd_exec_test_gossip_incremental_hash_desc = {
     605             :   .encode = fd_exec_test_gossip_incremental_hash_encode,
     606             :   .decode = fd_exec_test_gossip_incremental_hash_decode
     607             : };
     608             : 
     609             : static int
     610             : fd_exec_test_gossip_snapshot_hashes_encode( fd_pb_encoder_t * enc,
     611         121 :                                             void const *      msg_ ) {
     612         121 :   fd_exec_test_gossip_snapshot_hashes_t const * msg = msg_;
     613         121 :   if( msg->from && msg->from->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 1U, msg->from->bytes, msg->from->size ) ) ) return 0;
     614         122 :   if( msg->full_slot && FD_UNLIKELY( !fd_pb_push_uint64( enc, 2U, msg->full_slot ) ) ) return 0;
     615         121 :   if( msg->full_hash && msg->full_hash->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 3U, msg->full_hash->bytes, msg->full_hash->size ) ) ) return 0;
     616         298 :   for( ulong i=0UL; i<msg->incremental_count; i++ ) {
     617         177 :     if( FD_UNLIKELY( !fd_pb_enc_submsg( enc, 4U, &fd_exec_test_gossip_incremental_hash_desc, &msg->incremental[ i ] ) ) ) return 0;
     618         177 :   }
     619         122 :   if( msg->wallclock && FD_UNLIKELY( !fd_pb_push_uint64( enc, 5U, msg->wallclock ) ) ) return 0;
     620         121 :   return 1;
     621         121 : }
     622             : 
     623             : static int
     624             : fd_exec_test_gossip_snapshot_hashes_decode( fd_pb_inbuf_t * in,
     625             :                                             void *          msg_,
     626          61 :                                             fd_spad_t *     spad ) {
     627          61 :   fd_exec_test_gossip_snapshot_hashes_t * msg = msg_;
     628         392 :   while( fd_pb_inbuf_sz( in ) ) {
     629         331 :     fd_pb_tlv_t tlv[1];
     630         331 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     631         331 :     switch( tlv->field_id ) {
     632          61 :     case 1:
     633          61 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->from ) ) ) return 0;
     634          61 :       break;
     635          61 :     case 2:
     636          61 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->full_slot ) ) ) return 0;
     637          61 :       break;
     638          61 :     case 3:
     639          61 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->full_hash ) ) ) return 0;
     640          61 :       break;
     641          89 :     case 4:
     642          89 :       {
     643          89 :         void * ele = fd_pb_dec_grow( spad, &msg->incremental, &msg->incremental_count, alignof(fd_exec_test_gossip_incremental_hash_t), sizeof(fd_exec_test_gossip_incremental_hash_t) );
     644          89 :         if( FD_UNLIKELY( !ele ) ) return 0;
     645          89 :         if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_incremental_hash_desc, ele ) ) ) return 0;
     646          89 :       }
     647          89 :       break;
     648          89 :     case 5:
     649          61 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->wallclock ) ) ) return 0;
     650          61 :       break;
     651          61 :     default:
     652           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     653           0 :       break;
     654         331 :     }
     655         331 :   }
     656          61 :   return 1;
     657          61 : }
     658             : 
     659             : fd_pb_msgdesc_t const fd_exec_test_gossip_snapshot_hashes_desc = {
     660             :   .encode = fd_exec_test_gossip_snapshot_hashes_encode,
     661             :   .decode = fd_exec_test_gossip_snapshot_hashes_decode
     662             : };
     663             : 
     664             : static int
     665             : fd_exec_test_gossip_duplicate_shred_encode( fd_pb_encoder_t * enc,
     666          92 :                                             void const *      msg_ ) {
     667          92 :   fd_exec_test_gossip_duplicate_shred_t const * msg = msg_;
     668          92 :   if( msg->index && FD_UNLIKELY( !fd_pb_push_uint32( enc, 1U, msg->index ) ) ) return 0;
     669          92 :   if( msg->from && msg->from->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 2U, msg->from->bytes, msg->from->size ) ) ) return 0;
     670          92 :   if( msg->wallclock && FD_UNLIKELY( !fd_pb_push_uint64( enc, 3U, msg->wallclock ) ) ) return 0;
     671          92 :   if( msg->slot && FD_UNLIKELY( !fd_pb_push_uint64( enc, 4U, msg->slot ) ) ) return 0;
     672          92 :   if( msg->shred_index && FD_UNLIKELY( !fd_pb_push_uint32( enc, 5U, msg->shred_index ) ) ) return 0;
     673          92 :   if( msg->shred_type && FD_UNLIKELY( !fd_pb_push_uint32( enc, 6U, msg->shred_type ) ) ) return 0;
     674          92 :   if( msg->num_chunks && FD_UNLIKELY( !fd_pb_push_uint32( enc, 7U, msg->num_chunks ) ) ) return 0;
     675          92 :   if( msg->chunk_index && FD_UNLIKELY( !fd_pb_push_uint32( enc, 8U, msg->chunk_index ) ) ) return 0;
     676          92 :   if( msg->chunk && msg->chunk->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 9U, msg->chunk->bytes, msg->chunk->size ) ) ) return 0;
     677          92 :   return 1;
     678          92 : }
     679             : 
     680             : static int
     681             : fd_exec_test_gossip_duplicate_shred_decode( fd_pb_inbuf_t * in,
     682             :                                             void *          msg_,
     683          46 :                                             fd_spad_t *     spad ) {
     684          46 :   fd_exec_test_gossip_duplicate_shred_t * msg = msg_;
     685         355 :   while( fd_pb_inbuf_sz( in ) ) {
     686         309 :     fd_pb_tlv_t tlv[1];
     687         309 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     688         309 :     switch( tlv->field_id ) {
     689          46 :     case 1:
     690          46 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->index ) ) ) return 0;
     691          46 :       break;
     692          46 :     case 2:
     693          46 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->from ) ) ) return 0;
     694          46 :       break;
     695          46 :     case 3:
     696          46 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->wallclock ) ) ) return 0;
     697          46 :       break;
     698          46 :     case 4:
     699          46 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->slot ) ) ) return 0;
     700          46 :       break;
     701          46 :     case 5:
     702           0 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->shred_index ) ) ) return 0;
     703           0 :       break;
     704           0 :     case 6:
     705           0 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->shred_type ) ) ) return 0;
     706           0 :       break;
     707          46 :     case 7:
     708          46 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->num_chunks ) ) ) return 0;
     709          46 :       break;
     710          46 :     case 8:
     711          35 :       if( FD_UNLIKELY( !fd_pb_dec_uint32( tlv, &msg->chunk_index ) ) ) return 0;
     712          35 :       break;
     713          46 :     case 9:
     714          46 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->chunk ) ) ) return 0;
     715          46 :       break;
     716          46 :     default:
     717           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     718           0 :       break;
     719         309 :     }
     720         309 :   }
     721          46 :   return 1;
     722          46 : }
     723             : 
     724             : fd_pb_msgdesc_t const fd_exec_test_gossip_duplicate_shred_desc = {
     725             :   .encode = fd_exec_test_gossip_duplicate_shred_encode,
     726             :   .decode = fd_exec_test_gossip_duplicate_shred_decode
     727             : };
     728             : 
     729             : static int
     730             : fd_exec_test_gossip_crds_data_encode( fd_pb_encoder_t * enc,
     731         783 :                                       void const *      msg_ ) {
     732         783 :   fd_exec_test_gossip_crds_data_t const * msg = msg_;
     733         783 :   if( msg->which_data==1 && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 1U, &fd_exec_test_gossip_contact_info_desc, &msg->data.contact_info ) ) ) return 0;
     734         783 :   if( msg->which_data==2 && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 2U, &fd_exec_test_gossip_vote_desc, &msg->data.vote ) ) ) return 0;
     735         783 :   if( msg->which_data==3 && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 3U, &fd_exec_test_gossip_lowest_slot_desc, &msg->data.lowest_slot ) ) ) return 0;
     736         783 :   if( msg->which_data==4 && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 4U, &fd_exec_test_gossip_epoch_slots_desc, &msg->data.epoch_slots ) ) ) return 0;
     737         783 :   if( msg->which_data==5 && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 5U, &fd_exec_test_gossip_snapshot_hashes_desc, &msg->data.snapshot_hashes ) ) ) return 0;
     738         783 :   if( msg->which_data==6 && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 6U, &fd_exec_test_gossip_duplicate_shred_desc, &msg->data.duplicate_shred ) ) ) return 0;
     739         783 :   return 1;
     740         783 : }
     741             : 
     742             : static int
     743             : fd_exec_test_gossip_crds_data_decode( fd_pb_inbuf_t * in,
     744             :                                       void *          msg_,
     745         392 :                                       fd_spad_t *     spad ) {
     746         392 :   fd_exec_test_gossip_crds_data_t * msg = msg_;
     747         688 :   while( fd_pb_inbuf_sz( in ) ) {
     748         297 :     fd_pb_tlv_t tlv[1];
     749         297 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     750         297 :     switch( tlv->field_id ) {
     751          24 :     case 1:
     752          24 :       if( msg->which_data!=1 ) fd_memset( &msg->data, 0, sizeof(msg->data) );
     753          24 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_contact_info_desc, &msg->data.contact_info ) ) ) return 0;
     754          24 :       msg->which_data = 1;
     755          24 :       break;
     756          52 :     case 2:
     757          52 :       if( msg->which_data!=2 ) fd_memset( &msg->data, 0, sizeof(msg->data) );
     758          52 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_vote_desc, &msg->data.vote ) ) ) return 0;
     759          52 :       msg->which_data = 2;
     760          52 :       break;
     761          63 :     case 3:
     762          63 :       if( msg->which_data!=3 ) fd_memset( &msg->data, 0, sizeof(msg->data) );
     763          63 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_lowest_slot_desc, &msg->data.lowest_slot ) ) ) return 0;
     764          63 :       msg->which_data = 3;
     765          63 :       break;
     766          51 :     case 4:
     767          51 :       if( msg->which_data!=4 ) fd_memset( &msg->data, 0, sizeof(msg->data) );
     768          51 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_epoch_slots_desc, &msg->data.epoch_slots ) ) ) return 0;
     769          51 :       msg->which_data = 4;
     770          51 :       break;
     771          61 :     case 5:
     772          61 :       if( msg->which_data!=5 ) fd_memset( &msg->data, 0, sizeof(msg->data) );
     773          61 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_snapshot_hashes_desc, &msg->data.snapshot_hashes ) ) ) return 0;
     774          61 :       msg->which_data = 5;
     775          61 :       break;
     776          46 :     case 6:
     777          46 :       if( msg->which_data!=6 ) fd_memset( &msg->data, 0, sizeof(msg->data) );
     778          46 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_duplicate_shred_desc, &msg->data.duplicate_shred ) ) ) return 0;
     779          46 :       msg->which_data = 6;
     780          46 :       break;
     781           0 :     default:
     782           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     783           0 :       break;
     784         297 :     }
     785         297 :   }
     786         391 :   return 1;
     787         392 : }
     788             : 
     789             : fd_pb_msgdesc_t const fd_exec_test_gossip_crds_data_desc = {
     790             :   .encode = fd_exec_test_gossip_crds_data_encode,
     791             :   .decode = fd_exec_test_gossip_crds_data_decode
     792             : };
     793             : 
     794             : static int
     795             : fd_exec_test_gossip_crds_value_encode( fd_pb_encoder_t * enc,
     796         782 :                                        void const *      msg_ ) {
     797         782 :   fd_exec_test_gossip_crds_value_t const * msg = msg_;
     798         782 :   if( msg->signature && msg->signature->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 1U, msg->signature->bytes, msg->signature->size ) ) ) return 0;
     799         782 :   if( msg->has_data && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 2U, &fd_exec_test_gossip_crds_data_desc, &msg->data ) ) ) return 0;
     800         782 :   return 1;
     801         782 : }
     802             : 
     803             : static int
     804             : fd_exec_test_gossip_crds_value_decode( fd_pb_inbuf_t * in,
     805             :                                        void *          msg_,
     806         390 :                                        fd_spad_t *     spad ) {
     807         390 :   fd_exec_test_gossip_crds_value_t * msg = msg_;
     808        1171 :   while( fd_pb_inbuf_sz( in ) ) {
     809         782 :     fd_pb_tlv_t tlv[1];
     810         782 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     811         782 :     switch( tlv->field_id ) {
     812         390 :     case 1:
     813         390 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->signature ) ) ) return 0;
     814         390 :       break;
     815         392 :     case 2:
     816         392 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_crds_data_desc, &msg->data ) ) ) return 0;
     817         392 :       msg->has_data = 1;
     818         392 :       break;
     819           0 :     default:
     820           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     821           0 :       break;
     822         782 :     }
     823         782 :   }
     824         389 :   return 1;
     825         390 : }
     826             : 
     827             : fd_pb_msgdesc_t const fd_exec_test_gossip_crds_value_desc = {
     828             :   .encode = fd_exec_test_gossip_crds_value_encode,
     829             :   .decode = fd_exec_test_gossip_crds_value_decode
     830             : };
     831             : 
     832             : static int
     833             : fd_exec_test_gossip_pull_request_encode( fd_pb_encoder_t * enc,
     834          12 :                                          void const *      msg_ ) {
     835          12 :   fd_exec_test_gossip_pull_request_t const * msg = msg_;
     836          12 :   if( msg->has_filter && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 1U, &fd_exec_test_gossip_crds_filter_desc, &msg->filter ) ) ) return 0;
     837          12 :   if( msg->has_value && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 2U, &fd_exec_test_gossip_crds_value_desc, &msg->value ) ) ) return 0;
     838          12 :   return 1;
     839          12 : }
     840             : 
     841             : static int
     842             : fd_exec_test_gossip_pull_request_decode( fd_pb_inbuf_t * in,
     843             :                                          void *          msg_,
     844           6 :                                          fd_spad_t *     spad ) {
     845           6 :   fd_exec_test_gossip_pull_request_t * msg = msg_;
     846          18 :   while( fd_pb_inbuf_sz( in ) ) {
     847          12 :     fd_pb_tlv_t tlv[1];
     848          12 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     849          12 :     switch( tlv->field_id ) {
     850           6 :     case 1:
     851           6 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_crds_filter_desc, &msg->filter ) ) ) return 0;
     852           6 :       msg->has_filter = 1;
     853           6 :       break;
     854           6 :     case 2:
     855           6 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_crds_value_desc, &msg->value ) ) ) return 0;
     856           6 :       msg->has_value = 1;
     857           6 :       break;
     858           0 :     default:
     859           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     860           0 :       break;
     861          12 :     }
     862          12 :   }
     863           6 :   return 1;
     864           6 : }
     865             : 
     866             : fd_pb_msgdesc_t const fd_exec_test_gossip_pull_request_desc = {
     867             :   .encode = fd_exec_test_gossip_pull_request_encode,
     868             :   .decode = fd_exec_test_gossip_pull_request_decode
     869             : };
     870             : 
     871             : static int
     872             : fd_exec_test_gossip_pull_response_encode( fd_pb_encoder_t * enc,
     873         383 :                                           void const *      msg_ ) {
     874         383 :   fd_exec_test_gossip_pull_response_t const * msg = msg_;
     875         383 :   if( msg->pubkey && msg->pubkey->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 1U, msg->pubkey->bytes, msg->pubkey->size ) ) ) return 0;
     876         766 :   for( ulong i=0UL; i<msg->values_count; i++ ) {
     877         383 :     if( FD_UNLIKELY( !fd_pb_enc_submsg( enc, 2U, &fd_exec_test_gossip_crds_value_desc, &msg->values[ i ] ) ) ) return 0;
     878         383 :   }
     879         383 :   return 1;
     880         383 : }
     881             : 
     882             : static int
     883             : fd_exec_test_gossip_pull_response_decode( fd_pb_inbuf_t * in,
     884             :                                           void *          msg_,
     885         192 :                                           fd_spad_t *     spad ) {
     886         192 :   fd_exec_test_gossip_pull_response_t * msg = msg_;
     887         576 :   while( fd_pb_inbuf_sz( in ) ) {
     888         384 :     fd_pb_tlv_t tlv[1];
     889         384 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     890         384 :     switch( tlv->field_id ) {
     891         192 :     case 1:
     892         192 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->pubkey ) ) ) return 0;
     893         192 :       break;
     894         192 :     case 2:
     895         192 :       {
     896         192 :         void * ele = fd_pb_dec_grow( spad, &msg->values, &msg->values_count, alignof(fd_exec_test_gossip_crds_value_t), sizeof(fd_exec_test_gossip_crds_value_t) );
     897         192 :         if( FD_UNLIKELY( !ele ) ) return 0;
     898         192 :         if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_crds_value_desc, ele ) ) ) return 0;
     899         192 :       }
     900         192 :       break;
     901         192 :     default:
     902           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     903           0 :       break;
     904         384 :     }
     905         384 :   }
     906         192 :   return 1;
     907         192 : }
     908             : 
     909             : fd_pb_msgdesc_t const fd_exec_test_gossip_pull_response_desc = {
     910             :   .encode = fd_exec_test_gossip_pull_response_encode,
     911             :   .decode = fd_exec_test_gossip_pull_response_decode
     912             : };
     913             : 
     914             : static int
     915             : fd_exec_test_gossip_push_message_encode( fd_pb_encoder_t * enc,
     916         388 :                                          void const *      msg_ ) {
     917         388 :   fd_exec_test_gossip_push_message_t const * msg = msg_;
     918         388 :   if( msg->pubkey && msg->pubkey->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 1U, msg->pubkey->bytes, msg->pubkey->size ) ) ) return 0;
     919         775 :   for( ulong i=0UL; i<msg->values_count; i++ ) {
     920         387 :     if( FD_UNLIKELY( !fd_pb_enc_submsg( enc, 2U, &fd_exec_test_gossip_crds_value_desc, &msg->values[ i ] ) ) ) return 0;
     921         387 :   }
     922         388 :   return 1;
     923         388 : }
     924             : 
     925             : static int
     926             : fd_exec_test_gossip_push_message_decode( fd_pb_inbuf_t * in,
     927             :                                          void *          msg_,
     928         194 :                                          fd_spad_t *     spad ) {
     929         194 :   fd_exec_test_gossip_push_message_t * msg = msg_;
     930         581 :   while( fd_pb_inbuf_sz( in ) ) {
     931         388 :     fd_pb_tlv_t tlv[1];
     932         388 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     933         388 :     switch( tlv->field_id ) {
     934         194 :     case 1:
     935         194 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->pubkey ) ) ) return 0;
     936         194 :       break;
     937         194 :     case 2:
     938         194 :       {
     939         194 :         void * ele = fd_pb_dec_grow( spad, &msg->values, &msg->values_count, alignof(fd_exec_test_gossip_crds_value_t), sizeof(fd_exec_test_gossip_crds_value_t) );
     940         194 :         if( FD_UNLIKELY( !ele ) ) return 0;
     941         194 :         if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_crds_value_desc, ele ) ) ) return 0;
     942         194 :       }
     943         194 :       break;
     944         194 :     default:
     945           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
     946           0 :       break;
     947         388 :     }
     948         388 :   }
     949         193 :   return 1;
     950         194 : }
     951             : 
     952             : fd_pb_msgdesc_t const fd_exec_test_gossip_push_message_desc = {
     953             :   .encode = fd_exec_test_gossip_push_message_encode,
     954             :   .decode = fd_exec_test_gossip_push_message_decode
     955             : };
     956             : 
     957             : static int
     958             : fd_exec_test_gossip_prune_data_encode( fd_pb_encoder_t * enc,
     959        1194 :                                        void const *      msg_ ) {
     960        1194 :   fd_exec_test_gossip_prune_data_t const * msg = msg_;
     961        1194 :   if( msg->pubkey && msg->pubkey->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 1U, msg->pubkey->bytes, msg->pubkey->size ) ) ) return 0;
     962       18106 :   for( ulong i=0UL; i<msg->prunes_count; i++ ) {
     963       16912 :     if( FD_UNLIKELY( !fd_pb_enc_bytes_ptr( enc, 2U, msg->prunes[ i ] ) ) ) return 0;
     964       16912 :   }
     965        1194 :   if( msg->signature && msg->signature->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 3U, msg->signature->bytes, msg->signature->size ) ) ) return 0;
     966        1195 :   if( msg->destination && msg->destination->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 4U, msg->destination->bytes, msg->destination->size ) ) ) return 0;
     967        1196 :   if( msg->wallclock && FD_UNLIKELY( !fd_pb_push_uint64( enc, 5U, msg->wallclock ) ) ) return 0;
     968        1194 :   return 1;
     969        1194 : }
     970             : 
     971             : static int
     972             : fd_exec_test_gossip_prune_data_decode( fd_pb_inbuf_t * in,
     973             :                                        void *          msg_,
     974         599 :                                        fd_spad_t *     spad ) {
     975         599 :   fd_exec_test_gossip_prune_data_t * msg = msg_;
     976       11265 :   while( fd_pb_inbuf_sz( in ) ) {
     977       10674 :     fd_pb_tlv_t tlv[1];
     978       10674 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
     979       10674 :     switch( tlv->field_id ) {
     980         598 :     case 1:
     981         598 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->pubkey ) ) ) return 0;
     982         598 :       break;
     983        8445 :     case 2:
     984        8445 :       {
     985        8445 :         fd_pb_bytes_array_t ** ele = fd_pb_dec_grow( spad, &msg->prunes, &msg->prunes_count, alignof(fd_pb_bytes_array_t *), sizeof(fd_pb_bytes_array_t *) );
     986        8445 :         if( FD_UNLIKELY( !ele ) ) return 0;
     987        8445 :         if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, ele ) ) ) return 0;
     988        8445 :       }
     989        8445 :       break;
     990        8445 :     case 3:
     991         598 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->signature ) ) ) return 0;
     992         598 :       break;
     993         599 :     case 4:
     994         599 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->destination ) ) ) return 0;
     995         599 :       break;
     996         599 :     case 5:
     997         598 :       if( FD_UNLIKELY( !fd_pb_dec_uint64( tlv, &msg->wallclock ) ) ) return 0;
     998         598 :       break;
     999         598 :     default:
    1000           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
    1001           0 :       break;
    1002       10674 :     }
    1003       10674 :   }
    1004         591 :   return 1;
    1005         599 : }
    1006             : 
    1007             : fd_pb_msgdesc_t const fd_exec_test_gossip_prune_data_desc = {
    1008             :   .encode = fd_exec_test_gossip_prune_data_encode,
    1009             :   .decode = fd_exec_test_gossip_prune_data_decode
    1010             : };
    1011             : 
    1012             : static int
    1013             : fd_exec_test_gossip_prune_message_encode( fd_pb_encoder_t * enc,
    1014        1197 :                                           void const *      msg_ ) {
    1015        1197 :   fd_exec_test_gossip_prune_message_t const * msg = msg_;
    1016        1197 :   if( msg->pubkey && msg->pubkey->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 1U, msg->pubkey->bytes, msg->pubkey->size ) ) ) return 0;
    1017        1197 :   if( msg->has_data && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 2U, &fd_exec_test_gossip_prune_data_desc, &msg->data ) ) ) return 0;
    1018        1197 :   return 1;
    1019        1197 : }
    1020             : 
    1021             : static int
    1022             : fd_exec_test_gossip_prune_message_decode( fd_pb_inbuf_t * in,
    1023             :                                           void *          msg_,
    1024         599 :                                           fd_spad_t *     spad ) {
    1025         599 :   fd_exec_test_gossip_prune_message_t * msg = msg_;
    1026        1796 :   while( fd_pb_inbuf_sz( in ) ) {
    1027        1195 :     fd_pb_tlv_t tlv[1];
    1028        1195 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
    1029        1195 :     switch( tlv->field_id ) {
    1030         599 :     case 1:
    1031         599 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->pubkey ) ) ) return 0;
    1032         599 :       break;
    1033         599 :     case 2:
    1034         599 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_prune_data_desc, &msg->data ) ) ) return 0;
    1035         599 :       msg->has_data = 1;
    1036         599 :       break;
    1037           0 :     default:
    1038           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
    1039           0 :       break;
    1040        1195 :     }
    1041        1195 :   }
    1042         601 :   return 1;
    1043         599 : }
    1044             : 
    1045             : fd_pb_msgdesc_t const fd_exec_test_gossip_prune_message_desc = {
    1046             :   .encode = fd_exec_test_gossip_prune_message_encode,
    1047             :   .decode = fd_exec_test_gossip_prune_message_decode
    1048             : };
    1049             : 
    1050             : static int
    1051             : fd_exec_test_gossip_msg_encode( fd_pb_encoder_t * enc,
    1052        5351 :                                 void const *      msg_ ) {
    1053        5351 :   fd_exec_test_gossip_msg_t const * msg = msg_;
    1054        5351 :   if( msg->which_msg==1 && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 1U, &fd_exec_test_gossip_ping_desc, &msg->msg.ping ) ) ) return 0;
    1055        5351 :   if( msg->which_msg==2 && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 2U, &fd_exec_test_gossip_pong_desc, &msg->msg.pong ) ) ) return 0;
    1056        5351 :   if( msg->which_msg==3 && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 3U, &fd_exec_test_gossip_pull_request_desc, &msg->msg.pull_request ) ) ) return 0;
    1057        5351 :   if( msg->which_msg==4 && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 4U, &fd_exec_test_gossip_pull_response_desc, &msg->msg.pull_response ) ) ) return 0;
    1058        5351 :   if( msg->which_msg==5 && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 5U, &fd_exec_test_gossip_push_message_desc, &msg->msg.push_message ) ) ) return 0;
    1059        5351 :   if( msg->which_msg==6 && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 6U, &fd_exec_test_gossip_prune_message_desc, &msg->msg.prune_message ) ) ) return 0;
    1060        5351 :   return 1;
    1061        5351 : }
    1062             : 
    1063             : static int
    1064             : fd_exec_test_gossip_msg_decode( fd_pb_inbuf_t * in,
    1065             :                                 void *          msg_,
    1066        2687 :                                 fd_spad_t *     spad ) {
    1067        2687 :   fd_exec_test_gossip_msg_t * msg = msg_;
    1068        5371 :   while( fd_pb_inbuf_sz( in ) ) {
    1069        2686 :     fd_pb_tlv_t tlv[1];
    1070        2686 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
    1071        2686 :     switch( tlv->field_id ) {
    1072         848 :     case 1:
    1073         850 :       if( msg->which_msg!=1 ) fd_memset( &msg->msg, 0, sizeof(msg->msg) );
    1074         848 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_ping_desc, &msg->msg.ping ) ) ) return 0;
    1075         848 :       msg->which_msg = 1;
    1076         848 :       break;
    1077         854 :     case 2:
    1078         856 :       if( msg->which_msg!=2 ) fd_memset( &msg->msg, 0, sizeof(msg->msg) );
    1079         854 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_pong_desc, &msg->msg.pong ) ) ) return 0;
    1080         854 :       msg->which_msg = 2;
    1081         854 :       break;
    1082           6 :     case 3:
    1083           6 :       if( msg->which_msg!=3 ) fd_memset( &msg->msg, 0, sizeof(msg->msg) );
    1084           6 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_pull_request_desc, &msg->msg.pull_request ) ) ) return 0;
    1085           6 :       msg->which_msg = 3;
    1086           6 :       break;
    1087         192 :     case 4:
    1088         192 :       if( msg->which_msg!=4 ) fd_memset( &msg->msg, 0, sizeof(msg->msg) );
    1089         192 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_pull_response_desc, &msg->msg.pull_response ) ) ) return 0;
    1090         192 :       msg->which_msg = 4;
    1091         192 :       break;
    1092         194 :     case 5:
    1093         194 :       if( msg->which_msg!=5 ) fd_memset( &msg->msg, 0, sizeof(msg->msg) );
    1094         194 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_push_message_desc, &msg->msg.push_message ) ) ) return 0;
    1095         194 :       msg->which_msg = 5;
    1096         194 :       break;
    1097         599 :     case 6:
    1098         599 :       if( msg->which_msg!=6 ) fd_memset( &msg->msg, 0, sizeof(msg->msg) );
    1099         599 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_prune_message_desc, &msg->msg.prune_message ) ) ) return 0;
    1100         599 :       msg->which_msg = 6;
    1101         599 :       break;
    1102           0 :     default:
    1103           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
    1104           0 :       break;
    1105        2686 :     }
    1106        2686 :   }
    1107        2685 :   return 1;
    1108        2687 : }
    1109             : 
    1110             : fd_pb_msgdesc_t const fd_exec_test_gossip_msg_desc = {
    1111             :   .encode = fd_exec_test_gossip_msg_encode,
    1112             :   .decode = fd_exec_test_gossip_msg_decode
    1113             : };
    1114             : 
    1115             : static int
    1116             : fd_exec_test_gossip_effects_encode( fd_pb_encoder_t * enc,
    1117        9846 :                                     void const *      msg_ ) {
    1118        9846 :   fd_exec_test_gossip_effects_t const * msg = msg_;
    1119        9846 :   if( msg->valid && FD_UNLIKELY( !fd_pb_push_bool( enc, 1U, msg->valid ) ) ) return 0;
    1120        9846 :   if( msg->has_msg && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 2U, &fd_exec_test_gossip_msg_desc, &msg->msg ) ) ) return 0;
    1121        9846 :   return 1;
    1122        9846 : }
    1123             : 
    1124             : static int
    1125             : fd_exec_test_gossip_effects_decode( fd_pb_inbuf_t * in,
    1126             :                                     void *          msg_,
    1127        4988 :                                     fd_spad_t *     spad ) {
    1128        4988 :   fd_exec_test_gossip_effects_t * msg = msg_;
    1129       10314 :   while( fd_pb_inbuf_sz( in ) ) {
    1130        5356 :     fd_pb_tlv_t tlv[1];
    1131        5356 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
    1132        5356 :     switch( tlv->field_id ) {
    1133        2688 :     case 1:
    1134        2688 :       if( FD_UNLIKELY( !fd_pb_dec_bool( tlv, &msg->valid ) ) ) return 0;
    1135        2688 :       break;
    1136        2688 :     case 2:
    1137        2683 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_msg_desc, &msg->msg ) ) ) return 0;
    1138        2683 :       msg->has_msg = 1;
    1139        2683 :       break;
    1140           0 :     default:
    1141           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
    1142           0 :       break;
    1143        5356 :     }
    1144        5356 :   }
    1145        4958 :   return 1;
    1146        4988 : }
    1147             : 
    1148             : fd_pb_msgdesc_t const fd_exec_test_gossip_effects_desc = {
    1149             :   .encode = fd_exec_test_gossip_effects_encode,
    1150             :   .decode = fd_exec_test_gossip_effects_decode
    1151             : };
    1152             : 
    1153             : static int
    1154             : fd_exec_test_gossip_fixture_encode( fd_pb_encoder_t * enc,
    1155           0 :                                     void const *      msg_ ) {
    1156           0 :   fd_exec_test_gossip_fixture_t const * msg = msg_;
    1157           0 :   if( msg->has_metadata && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 1U, &fd_exec_test_fixture_metadata_desc, &msg->metadata ) ) ) return 0;
    1158           0 :   if( msg->input && msg->input->size && FD_UNLIKELY( !fd_pb_push_bytes( enc, 2U, msg->input->bytes, msg->input->size ) ) ) return 0;
    1159           0 :   if( msg->has_output && FD_UNLIKELY( !fd_pb_enc_submsg( enc, 3U, &fd_exec_test_gossip_effects_desc, &msg->output ) ) ) return 0;
    1160           0 :   return 1;
    1161           0 : }
    1162             : 
    1163             : static int
    1164             : fd_exec_test_gossip_fixture_decode( fd_pb_inbuf_t * in,
    1165             :                                     void *          msg_,
    1166        5005 :                                     fd_spad_t *     spad ) {
    1167        5005 :   fd_exec_test_gossip_fixture_t * msg = msg_;
    1168       19615 :   while( fd_pb_inbuf_sz( in ) ) {
    1169       14738 :     fd_pb_tlv_t tlv[1];
    1170       14738 :     if( FD_UNLIKELY( !fd_pb_dec_tlv( in, tlv ) ) ) return 0;
    1171       14738 :     switch( tlv->field_id ) {
    1172        5003 :     case 1:
    1173        5003 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_fixture_metadata_desc, &msg->metadata ) ) ) return 0;
    1174        5003 :       msg->has_metadata = 1;
    1175        5003 :       break;
    1176        4989 :     case 2:
    1177        4989 :       if( FD_UNLIKELY( !fd_pb_dec_bytes_ptr( in, tlv, spad, &msg->input ) ) ) return 0;
    1178        4989 :       break;
    1179        4989 :     case 3:
    1180        4983 :       if( FD_UNLIKELY( !fd_pb_dec_submsg( in, tlv, spad, &fd_exec_test_gossip_effects_desc, &msg->output ) ) ) return 0;
    1181        4983 :       msg->has_output = 1;
    1182        4983 :       break;
    1183           0 :     default:
    1184           0 :       if( FD_UNLIKELY( !fd_pb_dec_skip( in, tlv ) ) ) return 0;
    1185           0 :       break;
    1186       14738 :     }
    1187       14738 :   }
    1188        4877 :   return 1;
    1189        5005 : }
    1190             : 
    1191             : fd_pb_msgdesc_t const fd_exec_test_gossip_fixture_desc = {
    1192             :   .encode = fd_exec_test_gossip_fixture_encode,
    1193             :   .decode = fd_exec_test_gossip_fixture_decode
    1194             : };
    1195             :