LCOV - code coverage report
Current view: top level - ballet/shred - fd_shred.h (source / functions) Hit Total Coverage
Test: cov.lcov Lines: 101 116 87.1 %
Date: 2025-07-01 05:00:49 Functions: 61 4986 1.2 %

          Line data    Source code
       1             : #ifndef HEADER_fd_src_ballet_shred_fd_shred_h
       2             : #define HEADER_fd_src_ballet_shred_fd_shred_h
       3             : 
       4             : #include "../bmtree/fd_bmtree.h"
       5             : 
       6             : /* Shreds form the on-wire representation of Solana block data
       7             :    optimized for transmission over unreliable links/WAN.
       8             : 
       9             :    ### Layout
      10             : 
      11             :    Each shred is 1228 bytes long.
      12             : 
      13             :       +------------------------+
      14             :       | Common Shred Header    | 83 bytes
      15             :       +------------------------+
      16             :       | Data Header            | 5 bytes
      17             :       | or Coding Header       | or 6 bytes
      18             :       +------------------------+
      19             :       |                        | variable
      20             :       | Payload                | length
      21             :       |                        |
      22             :       +------------------------+
      23             : 
      24             :        for Merkle shreds, followed by:
      25             : 
      26             :       +------------------------+
      27             :       | (Chained merkle root)  | 32 bytes
      28             :       +------------------------+
      29             :       +------------------------+
      30             :       | Merkle node #0 (root)  | 20 bytes
      31             :       +------------------------+
      32             :       | Merkle node #1         | 20 bytes
      33             :       ..........................
      34             : 
      35             :        for resigned shreds, followed by:
      36             : 
      37             :       +------------------------+
      38             :       | signature              | 64 bytes
      39             :       ..........................
      40             : 
      41             :    ### Shredding
      42             : 
      43             :    For a given input data blob (usually an entry batch),
      44             :    data shreds are derived by simply splitting up the blob into subslices.
      45             : 
      46             :    Each shred is sized such that it fits into a single UDP packet,
      47             :    i.e. currently bound by the generally accepted IPv6 MTU of 1280 bytes.
      48             : 
      49             :    ### Forward Error Correction
      50             : 
      51             :    Coding shreds implement Reed-Solomon error correction to provide tolerance against packet loss.
      52             : 
      53             :    Each data shred is first assigned an FEC set.
      54             :    For the vector of data shreds in each set, a corresponding vector of coding shreds contains parity data.
      55             : 
      56             :    FEC sets and entry batches do not necessarily align.
      57             : 
      58             :    ### Merkle Inclusion Proofs
      59             : 
      60             :    Data and coding shreds come in two variants respectively: legacy and merkle.
      61             :    Merkle shreds extend legacy shreds by adding FEC set inclusion proofs.
      62             : 
      63             :    It allows the block producer to commit to the vector of shreds that make up an FEC set.
      64             :    The inclusion proof is used to verify whether a shred is part of the FEC set commitment.
      65             : 
      66             :    The length of the inclusion proof is indicated by the variant field.
      67             : 
      68             :    ### resigned shreds
      69             : 
      70             :    Resigned shreds allow for an additional signature to be added on to lock down
      71             :    the retransmitter for turbine propagation
      72             : 
      73             :    ### Authentication
      74             : 
      75             :    Shreds are signed by the block producer.
      76             :    Consequentially, only the block producer is able to create valid shreds for any given block. */
      77             : 
      78             : #include "../fd_ballet.h"
      79             : 
      80             : /* FD_SHRED_MAX_SZ: The max byte size of a shred.
      81             :    This limit derives from the IPv6 MTU of 1280 bytes, minus 48 bytes
      82             :    for the UDP/IPv6 headers and another 4 bytes for good measure.  Most
      83             :    shreds are this size, but Merkle data shreds may be smaller. */
      84   208698579 : #define FD_SHRED_MAX_SZ (1228UL)
      85             : /* FD_SHRED_MIN_SZ: The minimum byte size of a shred.
      86             :    A code shred of the max size covers a data shred of the minimum size
      87             :    with no padding. */
      88   208696650 : #define FD_SHRED_MIN_SZ (1203UL)
      89             : /* FD_SHRED_DATA_HEADER_SZ: size of all headers for data type shreds. */
      90   104868267 : #define FD_SHRED_DATA_HEADER_SZ (0x58UL)
      91             : /* FD_SHRED_CODE_HEADER_SZ: size of all headers for coding type shreds. */
      92    55720704 : #define FD_SHRED_CODE_HEADER_SZ (0x59UL)
      93             : /* This is a conservative bound.
      94             :    It's possible for a modified validator to create a data shred with
      95             :    this much payload.
      96             :    A validator that follows the default shredding policy should have
      97             :    payloads of no more than 1015 bytes.
      98             :    In general, shreds that are chained or resigned should have smaller
      99             :    payloads and a tigher bound. */
     100           0 : #define FD_SHRED_DATA_PAYLOAD_MAX (FD_SHRED_MIN_SZ-FD_SHRED_DATA_HEADER_SZ)
     101             : 
     102             : /* FD_SHRED_TYPE_* identifies the type of a shred.
     103             :    It is located at the four high bits of byte 0x40 (64) of the shred header
     104             :    and can be extracted using the fd_shred_type() function. */
     105             : /* FD_SHRED_TYPE_LEGACY_DATA: A shred carrying raw binary data. */
     106   140953794 : #define FD_SHRED_TYPE_LEGACY_DATA ((uchar)0xA0)
     107             : /* FD_SHRED_TYPE_LEGACY_CODE: A shred carrying Reed-Solomon ECC. */
     108             : #define FD_SHRED_TYPE_LEGACY_CODE ((uchar)0x50)
     109             : /* FD_SHRED_TYPE_MERKLE_DATA: A shred carrying raw binary data and a merkle inclusion proof. */
     110     1631202 : #define FD_SHRED_TYPE_MERKLE_DATA ((uchar)0x80)
     111             : /* FD_SHRED_TYPE_MERKLE_CODE: A shred carrying Reed-Solomon ECC and a merkle inclusion proof. */
     112   210678171 : #define FD_SHRED_TYPE_MERKLE_CODE ((uchar)0x40)
     113             : /* FD_SHRED_TYPE_MERKLE_DATA_CHAINED: A shred carrying raw binary data and a chained merkle inclusion proof. */
     114    40251312 : #define FD_SHRED_TYPE_MERKLE_DATA_CHAINED ((uchar)0x90)
     115             : /* FD_SHRED_TYPE_MERKLE_CODE_CHAINED: A shred carrying Reed-Solomon ECC and a chained merkle inclusion proof. */
     116    40250445 : #define FD_SHRED_TYPE_MERKLE_CODE_CHAINED ((uchar)0x60)
     117             : 
     118             : /* FD_SHRED_TYPE_MERKLE_DATA_CHAINED_RESIGNED: A shred carrying raw binary data and a chained merkle inclusion proof and resigned. */
     119   271975962 : #define FD_SHRED_TYPE_MERKLE_DATA_CHAINED_RESIGNED ((uchar)0xB0)
     120             : /* FD_SHRED_TYPE_MERKLE_CODE_CHAINED_RESIGNED: A shred carrying Reed-Solomon ECC and a chained merkle inclusion proof and resigned. */
     121   271974327 : #define FD_SHRED_TYPE_MERKLE_CODE_CHAINED_RESIGNED ((uchar)0x70)
     122             : 
     123             : /* FD_SHRED_TYPEMASK_DATA: bitwise AND with type matches data shred */
     124             : #define FD_SHRED_TYPEMASK_DATA FD_SHRED_TYPE_MERKLE_DATA
     125             : /* FD_SHRED_TYPEMASK_CODE: bitwise AND with type matches code shred */
     126   208654776 : #define FD_SHRED_TYPEMASK_CODE FD_SHRED_TYPE_MERKLE_CODE
     127             : 
     128             : /* FD_SHRED_MERKLE_ROOT_SZ: the size of a merkle tree root in bytes. */
     129   136389294 : #define FD_SHRED_MERKLE_ROOT_SZ (32UL)
     130             : /* FD_SHRED_MERKLE_NODE_SZ: the size of a merkle inclusion proof node in bytes. */
     131   175169571 : #define FD_SHRED_MERKLE_NODE_SZ (20UL)
     132             : /* FD_SHRED_MERKLE_LAYER_CNT: the count of inclusion proof layers in the binary merkle tree. */
     133         531 : #define FD_SHRED_MERKLE_LAYER_CNT (10UL)
     134             : /* FD_SHRED_SIGNATURE_SZ: the size of a signature in a shred. */
     135   211549560 : #define FD_SHRED_SIGNATURE_SZ (64UL)
     136             : /* A merkle inclusion proof node. */
     137             : typedef uchar fd_shred_merkle_t[FD_SHRED_MERKLE_NODE_SZ];
     138             : 
     139             : FD_STATIC_ASSERT( sizeof(fd_bmtree_node_t) == FD_SHRED_MERKLE_ROOT_SZ, update FD_SHRED_MERKLE_ROOT_SZ );
     140             : 
     141             : /* Constants relating to the data shred "flags" field. */
     142             : 
     143             : /* Mask of the "reference tick"    field in shred.data.flags */
     144           0 : #define FD_SHRED_DATA_REF_TICK_MASK      ((uchar)0x3f)
     145             : /* Mask of the "slot complete"       bit in shred.data.flags
     146             :    Indicates the last shred in a slot. */
     147           0 : #define FD_SHRED_DATA_FLAG_SLOT_COMPLETE ((uchar)0x80)
     148             : /* Mask of the "data batch complete" bit in shred.data.flags */
     149           0 : #define FD_SHRED_DATA_FLAG_DATA_COMPLETE ((uchar)0x40)
     150             : 
     151             : /* Maximum number of data shreds in a slot, also maximum number of parity shreds in a slot */
     152           0 : #define FD_SHRED_BLK_MAX (1 << 15UL) /* 32,768 shreds */
     153             : #define FD_SHRED_IDX_MAX (FD_SHRED_BLK_MAX - 1)
     154             : 
     155             : /* Many static bounds are specified around the assumption that this is a
     156             :    protocol limit on the max number of shreds in a slot. If this limit
     157             :    changes, all the relevant usages in other areas of the Firedancer
     158             :    codebase should be updated before modifying this assertion. */
     159             : 
     160             : FD_STATIC_ASSERT( FD_SHRED_BLK_MAX == 32768, check all usages before changing this limit! );
     161             : 
     162             : /* Many static bounds are specified around the assumption that this is a
     163             :    protocol limit on the max number of shreds in a slot. If this limit
     164             :    changes, all the relevant usages in other areas of the Firedancer
     165             :    codebase should be updated before modifying this assertion. */
     166             : 
     167             : FD_STATIC_ASSERT( FD_SHRED_BLK_MAX == 32768, check all usages before changing this limit! );
     168             : 
     169             : /* 36,536,320 bytes per slot */
     170           0 : #define FD_SHRED_DATA_PAYLOAD_MAX_PER_SLOT (FD_SHRED_DATA_PAYLOAD_MAX * FD_SHRED_BLK_MAX)
     171             : 
     172             : /* Offset of the shred variant. Used for parsing. */
     173             : #define FD_SHRED_VARIANT_OFF 0x40
     174             : 
     175             : /* Firedancer-specific internal error codes.
     176             : 
     177             :    These are not part of the Solana protocol. */
     178             : 
     179           0 : #define FD_SHRED_EBATCH  0x4000 /* End of batch reached (success)
     180             :                                    no more shreds and found FD_SHRED_DATA_FLAG_DATA_COMPLETE */
     181           0 : #define FD_SHRED_ESLOT   0x8000 /* End of slot reached (success)
     182             :                                    no more shreds and found FD_SHRED_DATA_FLAG_SLOT_COMPLETE */
     183           0 : #define FD_SHRED_ENOMEM      12 /* Error: Target buffer too small */
     184           0 : #define FD_SHRED_EINVAL      22 /* Error: Invalid shred data */
     185           0 : #define FD_SHRED_EPIPE       32 /* Error: Expected data in source buffer, got EOF */
     186             : 
     187             : /* Primary shred data structure.
     188             :    Relies heavily on packed fields and unaligned memory accesses. */
     189             : struct __attribute__((packed)) fd_shred {
     190             :   /* Ed25519 signature over the shred
     191             : 
     192             :      For legacy type shreds, signs over content of the shred structure past this signature field.
     193             :      For merkle type shreds, signs over the first node of the inclusion proof (merkle root). */
     194             :   /* 0x00 */ fd_ed25519_sig_t signature;
     195             : 
     196             :   /* Shred variant specifier
     197             :      Consists of two four bit fields. (Deliberately not using bit fields here)
     198             : 
     199             :      The high four bits indicate the shred type:
     200             :      - 0101: legacy code
     201             :      - 1010: legacy data
     202             :      - 0100: merkle code
     203             :      - 0110: merkle code (chained)
     204             :      - 0111: merkle code (chained resigned)
     205             :      - 1000: merkle data
     206             :      - 1001: merkle data (chained)
     207             :      - 1011: merkle data (chained resigned)
     208             : 
     209             :      For legacy type shreds, the low four bits are set to static patterns.
     210             :      For merkle type shreds, the low four bits are set to the number of non-root nodes in the inclusion proof.
     211             :      For merkle code type shreds, the 3rd highest bit represents if the merkle tree is chained.
     212             :      For merkle data type shreds, the 4th highest bit represents if the merkle tree is chained.
     213             :      For merkle code type shreds, the 4th highest bit represents if the shred is resigned.
     214             :      For merkle data type shreds, the 3th highest bit represents if the shred is resigned.
     215             : */
     216             :   /* 0x40 */ uchar  variant;
     217             : 
     218             :   /* Slot number that this shred is part of */
     219             :   /* 0x41 */ ulong  slot;
     220             : 
     221             :   /* Index of this shred within the slot */
     222             :   /* 0x49 */ uint   idx;
     223             : 
     224             :   /* Hash of the genesis version and historical hard forks of the current chain */
     225             :   /* 0x4d */ ushort version;
     226             : 
     227             :   /* Index into the vector of FEC sets for this slot. For data shreds, fec_set_idx<=idx. */
     228             :   /* 0x4f */ uint   fec_set_idx;
     229             : 
     230             :   union {
     231             :     /* Common data shred header */
     232             :     struct __attribute__((packed)) {
     233             :       /* Slot number difference between this block and the parent block.
     234             :          parent_off <= slot.
     235             :          Always greater than zero, except for slot 0, in which case the
     236             :          previous invariant forces this to be 0. */
     237             :       /* 0x53 */ ushort parent_off;
     238             : 
     239             :       /* Bit field (MSB first)
     240             :          See FD_SHRED_DATA_FLAG_*
     241             : 
     242             :           [XX.. ....] Block complete?       0b00=no 0b01=no 0b11=yes (implies Entry batch complete)
     243             :           [.X.. ....] Entry batch complete?  0b0=no  0b1=yes
     244             :           [..XX XXXX] Reference tick number */
     245             :       /* 0x55 */ uchar  flags;
     246             : 
     247             :       /* Shred size: size of data shred headers (88 bytes) + payload length */
     248             :       /* 0x56 */ ushort size;
     249             :     } data;
     250             : 
     251             :     /* Common coding shred header */
     252             :     struct __attribute__((packed)) {
     253             :       /* Total number of data shreds in FEC set. Must be positive <= FD_REEDSOL_DATA_SHREDS_MAX. */
     254             :       /* 0x53 */ ushort data_cnt;
     255             : 
     256             :       /* Total number of coding shreds in FEC set. Must be positive <= FD_REEDSOL_CODE_SHREDS_MAX. */
     257             :       /* 0x55 */ ushort code_cnt;
     258             : 
     259             :       /* Index within the vector of coding shreds in slot. In [0,
     260             :          code_cnt).  Also, shred.code.idx <= shred.idx. */
     261             :       /* 0x57 */ ushort idx;
     262             :     } code;
     263             :   };
     264             : };
     265             : typedef struct fd_shred fd_shred_t;
     266             : 
     267             : FD_PROTOTYPES_BEGIN
     268             : 
     269             : /* fd_shred_parse: Parses and validates an untrusted shred stored in
     270             :    bytes buf[i] for i in [0, sz).  sz must be at least FD_SHRED_MIN_SZ
     271             :    bytes.  Allows trailing data.
     272             : 
     273             :    The returned pointer either equals the input pointer or is NULL if
     274             :    the given shred is malformed or violates any invariants described
     275             :    above. */
     276             : FD_FN_PURE fd_shred_t const *
     277             : fd_shred_parse( uchar const * buf,
     278             :                 ulong         sz );
     279             : 
     280             : /* fd_shred_type: Returns the value of the shred's type field. (FD_SHRED_TYPE_*) */
     281             : FD_FN_CONST static inline uchar
     282   493020495 : fd_shred_type( uchar variant ) {
     283   493020495 :   return variant & 0xf0;
     284   493020495 : }
     285             : 
     286             : /* fd_shred_variant: Returns the encoded variant field
     287             :    given the shred type and merkle proof length. */
     288             : FD_FN_CONST static inline uchar
     289             : fd_shred_variant( uchar type,
     290   106355181 :                   uchar merkle_cnt ) {
     291   106355181 :   if( FD_LIKELY( type==FD_SHRED_TYPE_LEGACY_DATA ) )
     292           3 :     merkle_cnt = 0x05;
     293   106355181 :   if( FD_LIKELY( type==FD_SHRED_TYPE_LEGACY_CODE ) )
     294           3 :     merkle_cnt = 0x0a;
     295   106355181 :   return (uchar)(type | merkle_cnt);
     296   106355181 : }
     297             : 
     298             : FD_FN_PURE static inline ulong
     299   140937675 : fd_shred_sz( fd_shred_t const * shred ) {
     300   140937675 :   uchar type = fd_shred_type( shred->variant );
     301   140937675 :   return fd_ulong_if(
     302   140937675 :     type & FD_SHRED_TYPEMASK_CODE,
     303   140937675 :     FD_SHRED_MAX_SZ,
     304   140937675 :     fd_ulong_if( type==FD_SHRED_TYPE_LEGACY_DATA, shred->data.size, FD_SHRED_MIN_SZ)
     305   140937675 :   ); /* Legacy data */
     306   140937675 : }
     307             : 
     308             : /* fd_shred_header_sz: Returns the header size of a shred.
     309             :    Returns zero if the shred has an invalid variant.
     310             : 
     311             :    Accesses offsets up to FD_SHRED_HEADER_MIN_SZ. */
     312             : FD_FN_CONST static inline ulong
     313       33462 : fd_shred_header_sz( uchar variant ) {
     314       33462 :   uchar type = fd_shred_type( variant );
     315       33462 :   if( FD_LIKELY( type & FD_SHRED_TYPEMASK_DATA ) )
     316       16266 :     return FD_SHRED_DATA_HEADER_SZ;
     317       17196 :   if( FD_LIKELY( type & FD_SHRED_TYPEMASK_CODE ) )
     318       17196 :     return FD_SHRED_CODE_HEADER_SZ;
     319           0 :   return 0;
     320       17196 : }
     321             : 
     322             : /* fd_shred_merkle_cnt: Returns number of nodes in the merkle inclusion
     323             :    proof.  Note that this excludes the root.  Returns zero if the given
     324             :    shred is not a merkle variant. */
     325             : FD_FN_CONST static inline uint
     326   173756343 : fd_shred_merkle_cnt( uchar variant ) {
     327   173756343 :   uchar type = fd_shred_type( variant );
     328   173756343 :   if( FD_UNLIKELY( ( type == FD_SHRED_TYPE_LEGACY_DATA ) | ( type == FD_SHRED_TYPE_LEGACY_CODE ) ) )
     329          45 :     return 0;
     330   173756298 :   return (variant&0xfU);
     331   173756343 : }
     332             : 
     333             : /* fd_shred_merkle_sz: Returns the size in bytes of the merkle inclusion proof.
     334             :    Returns zero if the given shred is not a merkle variant.  */
     335             : FD_FN_CONST static inline ulong
     336   173729163 : fd_shred_merkle_sz( uchar variant ) {
     337   173729163 :   return fd_shred_merkle_cnt( variant ) * FD_SHRED_MERKLE_NODE_SZ;
     338   173729163 : }
     339             : 
     340             : 
     341             : /* fd_shred_is_chained: Returns true if the shred is a chained merkle data or code shred. */
     342             : FD_FN_CONST static inline uchar
     343    38816274 : fd_shred_is_chained( ulong type ) {
     344    38816274 :   return (uchar)(
     345    38816274 :          ( type == FD_SHRED_TYPE_MERKLE_DATA_CHAINED )
     346    38816274 :        | ( type == FD_SHRED_TYPE_MERKLE_CODE_CHAINED )
     347    38816274 :        | ( type == FD_SHRED_TYPE_MERKLE_DATA_CHAINED_RESIGNED )
     348    38816274 :        | ( type == FD_SHRED_TYPE_MERKLE_CODE_CHAINED_RESIGNED ) );
     349    38816274 : }
     350             : 
     351             : /* fd_shred_is_resigned: Returns true if the shred is resigned by the retransmitter */
     352             : FD_FN_CONST static inline uchar
     353   231725562 : fd_shred_is_resigned( ulong type ) {
     354   231725562 :   return ( type == FD_SHRED_TYPE_MERKLE_DATA_CHAINED_RESIGNED )
     355   231725562 :        | ( type == FD_SHRED_TYPE_MERKLE_CODE_CHAINED_RESIGNED );
     356   231725562 : }
     357             : 
     358             : /* fd_shred_is_{data,code} return 1 if the provided shred type is one of
     359             :    the data (or code, respectively) types, and 0 if not.  The value
     360             :    provided for type must be a valid shred type (one of the
     361             :    FD_SHRED_TYPE_* values).  For the purposes of these functions,
     362             :    properties beyond data/code are ignored; e.g. a chained resigned
     363             :    Merkle data shred is considered a data shred. */
     364     4516164 : FD_FN_CONST static inline uchar fd_shred_is_data( ulong type ) { return (type & 0xC0UL)==0x80UL; }
     365         294 : FD_FN_CONST static inline uchar fd_shred_is_code( ulong type ) { return (type & 0xC0UL)==0x40UL; }
     366             : 
     367             : /* fd_shred_swap_type: changes data into code or vice versa without
     368             :    affecting leagacy, merkle, chained, or resigned status.  For example,
     369             :    fd_shred_swap_type( chained resigned data ) == chained resigned code.
     370             :    fd_shred_swap_type( merkle code ) == merkle data. */
     371             : FD_FN_CONST static inline uchar
     372        9372 : fd_shred_swap_type( ulong type ) {
     373             :   /* Swap bits 4 and 5. Swap bits 6 and 7. */
     374        9372 :   return (uchar)(((type & 0x50UL)<<1) | ((type&0xA0UL)>>1));
     375        9372 : }
     376             : 
     377             : /* fd_shred_payload_sz: Returns the payload size of a shred.
     378             :    Undefined behavior if the shred has not passed `fd_shred_parse`. */
     379             : FD_FN_PURE static inline ulong
     380         294 : fd_shred_payload_sz( fd_shred_t const * shred ) {
     381         294 :   ulong type = fd_shred_type( shred->variant );
     382         294 :   if( FD_LIKELY( type & FD_SHRED_TYPEMASK_DATA ) ) {
     383         147 :     return shred->data.size - FD_SHRED_DATA_HEADER_SZ;
     384         147 :   } else {
     385         147 :     return fd_shred_sz( shred ) - FD_SHRED_CODE_HEADER_SZ
     386         147 :       - fd_shred_merkle_sz( shred->variant )
     387         147 :       - fd_ulong_if( fd_shred_is_chained( type ), FD_SHRED_MERKLE_ROOT_SZ, 0 )
     388         147 :       - fd_ulong_if( fd_shred_is_resigned( type ), FD_SHRED_SIGNATURE_SZ, 0 );
     389         147 :   }
     390         294 : }
     391             : 
     392             : /* fd_shred_merkle_off: Returns the byte offset of the merkle inclusion proof of a shred.
     393             : 
     394             :    The provided shred must have passed validation in fd_shred_parse(). */
     395             : FD_FN_PURE static inline ulong
     396   105978453 : fd_shred_merkle_off( fd_shred_t const * shred ) {
     397   105978453 :   ulong type = fd_shred_type( shred->variant );
     398   105978453 :   return fd_shred_sz( shred )
     399   105978453 :     - fd_shred_merkle_sz( shred->variant )
     400   105978453 :     - fd_ulong_if( fd_shred_is_resigned( type ), FD_SHRED_SIGNATURE_SZ, 0 );
     401   105978453 : }
     402             : 
     403             : /* fd_shred_merkle_nodes: Returns a pointer to the shred's merkle proof data.
     404             : 
     405             :    The provided shred must have passed validation in fd_shred_parse(). */
     406             : FD_FN_PURE static inline fd_shred_merkle_t const *
     407        8931 : fd_shred_merkle_nodes( fd_shred_t const * shred ) {
     408        8931 :   uchar const * ptr = (uchar const *)shred;
     409        8931 :   ptr += fd_shred_merkle_off( shred );
     410        8931 :   return (fd_shred_merkle_t const *)ptr;
     411        8931 : }
     412             : 
     413             : /* fd_shred_merkle_root: Assuming that `shred` is a Merkle variant,
     414             :    reconstructs the merkle root from a shred and populates it in
     415             :    root_out.  Returns 1 on success, 0 on failure.  The output value must
     416             :    be ignored if a failure is returned.  U.B. if the shred is not a
     417             :    merkle variant. */
     418             : FD_FN_PURE int
     419             : fd_shred_merkle_root( fd_shred_t const * shred, void * bmtree_mem, fd_bmtree_node_t * root_out );
     420             : 
     421             : /* fd_shred_data_payload: Returns a pointer to a data shred payload.
     422             : 
     423             :   The provided shred must have passed validation in fd_shred_parse(),
     424             :   and must satisfy `type&FD_SHRED_TYPEMASK_DATA`
     425             :   where `uchar type = fd_shred_type( shred->variant )`. */
     426             : FD_FN_CONST static inline uchar const *
     427           9 : fd_shred_data_payload( fd_shred_t const * shred ) {
     428           9 :   return (uchar const *)shred + FD_SHRED_DATA_HEADER_SZ;
     429           9 : }
     430             : 
     431             : /* fd_shred_code_payload: Returns a pointer to a coding shred payload.
     432             : 
     433             :   The provided shred must have passed validation in fd_shred_parse(),
     434             :   and must satisfy `type&FD_SHRED_TYPEMASK_CODE`
     435             :   where `uchar type = fd_shred_type( shred->variant )`. */
     436             : FD_FN_CONST static inline uchar const *
     437           0 : fd_shred_code_payload( fd_shred_t const * shred ) {
     438           0 :   return (uchar const *)shred + FD_SHRED_CODE_HEADER_SZ;
     439           0 : }
     440             : 
     441             : /* fd_shred_chain_offset: Assuming that `shred` is a chained Merkle
     442             :    variant, compute the offset from the start of the shred to the start
     443             :    of the chained Merkle root.  U.B. if the shred is not a chained
     444             :    variant. */
     445             : FD_FN_CONST static inline ulong
     446    67717101 : fd_shred_chain_off( uchar variant ) {
     447    67717101 :   ulong type = fd_shred_type( variant );
     448    67717101 :   return fd_ulong_if( type & FD_SHRED_TYPEMASK_CODE, FD_SHRED_MAX_SZ, FD_SHRED_MIN_SZ )
     449    67717101 :     - FD_SHRED_MERKLE_ROOT_SZ
     450    67717101 :     - fd_shred_merkle_sz( variant )
     451    67717101 :     - fd_ulong_if( fd_shred_is_resigned( type ), FD_SHRED_SIGNATURE_SZ, 0 );
     452    67717101 : }
     453             : 
     454             : /* fd_shred_retrasmitter_sig_off: Assuming that `shred` is a resigned
     455             :    variant, compute the offset from the start of the shred to the start
     456             :    of the retransmitter signature.  U.B if the shred is not a resigned
     457             :    chained type. */
     458             : FD_FN_PURE static inline ulong
     459    34941159 : fd_shred_retransmitter_sig_off( fd_shred_t const * shred ) {
     460    34941159 :   return fd_shred_sz( shred )-FD_SHRED_SIGNATURE_SZ;
     461    34941159 : }
     462             : 
     463             : FD_PROTOTYPES_END
     464             : 
     465             : #endif /* HEADER_fd_src_ballet_shred_fd_shred_h */

Generated by: LCOV version 1.14