solana-ruby-kit 7.1.1.2 → 8.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a30b73ebab9578e0345910ab3f7d019cb6cacc9840797abfb8a177a3de9b2bb
-  data.tar.gz: e540ed2b2b3cc1bb87a5f584b587d1ea4f86cad324c04385311289501ce48cf7
+  metadata.gz: c281fe52274deb9bbf493d3848b3bcb64ecc42b11e4acc6b727ef5e301dcb252
+  data.tar.gz: 6fefa37ee1da4bc377bc58f609adad46c2940b3377a9333168df0f6ff83cef6c
 SHA512:
-  metadata.gz: 29728a4e25c5f9d7dabd89e75cb9fd2b583f03930b6640c48c68ff070e90e06345bbfa75d636383dda51c9dc8044f9942f4a299866f39f8b93189f832fbf03a6
-  data.tar.gz: 04c68d1f2e6f249c4be788e1c9e6919b056f9780eebd5a26bb6dc8aae6b15ceafe7838d39ed6af4ba24269ebdc5cbdd4cc028f8947db842631aace626750df45
+  metadata.gz: ba02f18c40de9b8b9ab544551ac477e94b1f4dcd4b177e8d513680b3d406830991acb770f4f427b5e9d4ca4abaf0cdda28d5849d649e6e50037104fe653390a7
+  data.tar.gz: 5ccc70a501ac546deb6520394b9efedc8ddbd7b2278318ab0fdf3944352e9a66ac06d66bd8b8288b1bf4b10a9cb395266d23f3feec3d7708741421a83033af9d

data/README.md

@@ -189,9 +189,17 @@ msg = TxMsg.append_instructions(msg, [instruction])
 msg = TxMsg.prepend_instructions(msg, [priority_fee_ix])
 
 # Compute unit limit (SetComputeUnitLimit instruction from the Compute Budget program)
+# The limit is validated: it must be an integer in [0, MAX_COMPUTE_UNIT_LIMIT] (1,400,000).
+# The runtime silently clamps a larger request rather than failing, so asking for more than
+# the maximum would run on a budget you did not ask for — this raises instead.
 msg = TxMsg.set_transaction_message_compute_unit_limit(200_000, msg)
 TxMsg.get_transaction_message_compute_unit_limit(msg)  # => 200_000
 
+# The check is also available on its own, alongside one for heap frame sizes — a whole
+# number of KiB in [MIN_HEAP_SIZE, MAX_HEAP_SIZE] (32 KiB to 256 KiB).
+TxMsg.assert_is_valid_compute_unit_limit(200_000)
+TxMsg.assert_is_valid_heap_size(64 * 1024)
+
 # Loaded accounts data size limit
 msg = TxMsg.set_transaction_message_loaded_accounts_data_size_limit(64_000, msg)
 TxMsg.get_transaction_message_loaded_accounts_data_size_limit(msg)  # => 64_000
@@ -274,6 +282,7 @@ rpc.get_block_time(slot)
 rpc.get_inflation_reward([address])
 rpc.get_signatures_for_address(address)
 rpc.get_vote_accounts
+rpc.get_ag_genesis_cert                      # Alpenglow genesis cert, or nil
 rpc.simulate_transaction(encoded_tx)
 rpc.send_transaction(encoded_tx)
 rpc.request_airdrop(address, lamports)        # devnet / testnet only
@@ -351,20 +360,25 @@ Binary encoder/decoder framework for Solana on-chain data.
 ```ruby
 Codecs = Solana::Ruby::Kit::Codecs
 
-# Numbers
-u8  = Codecs.u8
-u16 = Codecs.u16_le   # little-endian (default for Solana)
-u32 = Codecs.u32_le
-u64 = Codecs.u64_le
-i8  = Codecs.i8
-f32 = Codecs.f32_le
-
-u16.encode(1000)       # => "\xe8\x03"
-u16.decode("\xe8\x03") # => 1000
+# Numbers. Every multi-byte codec takes `endian:`, defaulting to :little
+# (which is what Solana uses on-chain).
+u8   = Codecs.u8_codec
+u16  = Codecs.u16_codec
+u32  = Codecs.u32_codec
+u64  = Codecs.u64_codec
+u128 = Codecs.u128_codec
+u256 = Codecs.u256_codec              # 32 bytes
+i8   = Codecs.i8_codec
+i256 = Codecs.i256_codec              # 32 bytes, two's complement
+f32  = Codecs.f32_codec
+be   = Codecs.u16_codec(endian: :big)
+
+u16.encode(1000)         # => "\xe8\x03"
+u16.decode("\xe8\x03")   # => [1000, 2]   # [value, bytes consumed]
 
 # Strings
-utf8  = Codecs.utf8
-bytes = Codecs.bytes_codec
+utf8  = Codecs.utf8_codec
+bytes = Codecs.bytes_codec(32)
 
 # Data structures
 struct_codec = Codecs.struct_codec([
@@ -373,6 +387,71 @@ struct_codec = Codecs.struct_codec([
 ])
 ```
 
+#### UTF-8 options
+
+By default the UTF-8 codec substitutes `U+FFFD` for malformed input, strips a
+leading byte order mark, and strips null characters - the last of which is what
+makes fixed-size padded strings read back cleanly, at the cost of being lossy
+for strings that legitimately contain nulls.
+
+```ruby
+# Reject invalid UTF-8 instead of substituting the replacement character.
+strict = Codecs.utf8_codec(fatal: true)
+strict.encode("a\xC0\x80")   # raises SolanaError (invalid UTF-8 string)
+strict.decode("\xFF".b)      # raises SolanaError (invalid UTF-8 bytes)
+
+# Decode losslessly, keeping null characters and a leading byte order mark.
+lossless = Codecs.utf8_codec(ignore_bom: true, remove_null_characters: false)
+
+# The assertions are usable on their own.
+Codecs.find_malformed_utf8_sequence_offset("a\xC0\x80".b)  # => 1 (overlong)
+Codecs.assert_is_well_formed_utf8_bytes("\xE8\xAA\x9E".b)  # passes ("語")
+Codecs.remove_null_characters("a\x00b")                        # => "ab"
+```
+
+Note that `ignore_bom` follows `TextDecoder`'s confusing spelling: the default,
+`false`, *strips* the mark; `true` keeps it.
+
+#### Requiring a size prefix
+
+A prefixed collection decodes an exhausted buffer to an empty collection rather
+than failing, so a program can append a collection to an existing account layout
+and still read accounts written before the change. Formats that cannot accept
+that leniency - borsh requires the prefix to be present - can opt into failing:
+
+```ruby
+Codecs.array_codec(u8).decode(''.b)                              # => [[], 0]
+Codecs.array_codec(u8, require_size_prefix: true).decode(''.b)   # raises SolanaError
+```
+
+`map_codec` and `set_codec` take the same option. It has no effect on
+fixed-count collections, which carry no prefix.
+
+#### Tap combinators
+
+Wrap a codec in one that observes a value - or the bytes - without changing it,
+for validation guards or logging. A tap that raises aborts the operation.
+
+```ruby
+guarded = Codecs.tap_encoder(u8.encoder) do |value|
+  raise ArgumentError, 'Value must not exceed 100' if value > 100
+end
+guarded.encode(42)   # => "\x2a"
+guarded.encode(200)  # raises ArgumentError
+
+# Both sides at once; decode_tap is optional.
+Codecs.tap_codec(u8, encode_tap: ->(v) { log(v) }, decode_tap: ->(v) { log(v) })
+
+# Observe the bytes instead of the value.
+Codecs.tap_decoder_bytes(u8.decoder) do |bytes, offset|
+  raise ArgumentError, 'Expected a 0 or a 1' if bytes.bytes[offset] > 1
+end
+```
+
+Upstream's byte taps take `(bytes, pre_offset, post_offset)` because encoders
+there write into a shared buffer. A Ruby `Encoder` returns a standalone byte
+String, so the encode-side taps receive exactly the bytes that were written.
+
 ### `Solana::Ruby::Kit::RpcSubscriptions` — `@solana/rpc-subscriptions`
 
 WebSocket-based subscription client.
@@ -640,6 +719,21 @@ result = executor.call(transaction_plan)
 # A one-argument lambda returning { transaction:, context: } — the shape this method
 # required before v7.1.0 — is still accepted and adapted onto the flow above.
 
+# ── 3b. Executing every leaf concurrently ────────────────────────────────────
+# For work that has no execution dependencies — signing or serializing, say —
+# create_transaction_plan_executor_with_concurrent_leaves takes the same callback
+# contract but starts every leaf immediately, each on its own thread. It preserves
+# the plan's nesting, order and divisibility in the result, supports non-divisible
+# sequential plans, and cancels nothing: a leaf that raises does not stop the others,
+# so every leaf runs to completion before the failure is reported. Because the leaves
+# run at the same time, the callback must be safe to call concurrently with itself.
+concurrent = Plans.create_transaction_plan_executor_with_concurrent_leaves(
+  execute_transaction_message: ->(_context, message) {
+    { transaction: Kit::Transactions.compile_transaction_message(message) }
+  }
+)
+result = concurrent.call(transaction_plan)
+
 # ── 4. Plan types ─────────────────────────────────────────────────────────────
 Plans.single_instruction_plan(ix)                      # wrap one instruction
 Plans.sequential_instruction_plan([ix1, ix2])          # ordered, divisible

data/lib/solana/ruby/kit/accounts/maybe_account.rb

@@ -28,7 +28,7 @@ module Solana::Ruby::Kit
       const :space,           T.nilable(Integer)
     end
 
-    module_function
+    extend self
 
     # Builds a MaybeAccount representing a found account.
     sig { params(account: Account).returns(MaybeAccount) }

data/lib/solana/ruby/kit/addresses/address.rb

@@ -61,7 +61,7 @@ module Solana::Ruby::Kit
     ADDRESS_MIN_STR_LEN = T.let(32, Integer)
     ADDRESS_MAX_STR_LEN = T.let(44, Integer)
 
-    module_function
+    extend self
 
     # Encodes raw bytes (binary String, length == 32) to a base58 address string.
     # Mirrors `getAddressEncoder()` in TypeScript.

data/lib/solana/ruby/kit/addresses/curve.rb

@@ -27,7 +27,7 @@ module Solana::Ruby::Kit
     # sqrt(−1) mod p  =  2^((p−1)/4) mod p
     CURVE_SQRT_M1 = T.let(2.pow((CURVE_P - 1) / 4, CURVE_P), Integer)
 
-    module_function
+    extend self
 
     # Returns true if the 32-byte binary string represents a point on the
     # Ed25519 twisted-Edwards curve.

data/lib/solana/ruby/kit/addresses/program_derived_address.rb

@@ -38,7 +38,7 @@ module Solana::Ruby::Kit
     # Marker bytes appended during hashing: UTF-8 "ProgramDerivedAddress".
     PDA_MARKER_BYTES = T.let('ProgramDerivedAddress'.b, String)
 
-    module_function
+    extend self
 
     # Returns true if the value is a well-formed ProgramDerivedAddress.
     # Mirrors `isProgramDerivedAddress()` in TypeScript.

data/lib/solana/ruby/kit/addresses/public_key.rb

@@ -8,7 +8,7 @@ require_relative '../errors'
 module Solana::Ruby::Kit
   module Addresses
     extend T::Sig
-    module_function
+    extend self
 
     # Given an RbNaCl::VerifyKey (Ed25519 public key), returns its Solana Address.
     #

data/lib/solana/ruby/kit/codecs/codec.rb

@@ -64,7 +64,7 @@ module Solana::Ruby::Kit
 
     # ── Combinators ─────────────────────────────────────────────────────────────
 
-    module_function
+    extend self
 
     # Return a Codec whose output is always exactly +size+ bytes
     # (zero-padded on right, truncated if too large).
@@ -117,6 +117,100 @@ module Solana::Ruby::Kit
       Codec.new(enc, dec)
     end
 
+    # ── Tap combinators ─────────────────────────────────────────────────────────
+    #
+    # Each of these wraps a codec in one that observes a value (or the bytes)
+    # without changing it, for validation guards, logging or other read-only
+    # side effects. A tap that raises aborts the operation and the error
+    # propagates to the caller.
+    #
+    # Where upstream's byte taps take +(bytes, pre_offset, post_offset)+ over a
+    # shared output buffer, a Ruby Encoder returns a standalone byte String, so
+    # the encode-side taps below receive exactly the bytes that were written -
+    # the window upstream's tap has to slice out for itself. The decode-side
+    # taps keep +(bytes, offset)+, which Ruby Decoders already receive.
+
+    # Observe each value before it is encoded, leaving it unchanged.
+    sig do
+      params(encoder: Encoder, tap_fn: T.proc.params(value: T.untyped).void).returns(Encoder)
+    end
+    def tap_encoder(encoder, &tap_fn)
+      Encoder.new(fixed_size: encoder.fixed_size, max_size: encoder.max_size) do |value|
+        tap_fn.call(value)
+        encoder.encode(value)
+      end
+    end
+
+    # Observe each decoded value after it is decoded, leaving it unchanged.
+    sig do
+      params(decoder: Decoder, tap_fn: T.proc.params(value: T.untyped).void).returns(Decoder)
+    end
+    def tap_decoder(decoder, &tap_fn)
+      Decoder.new(fixed_size: decoder.fixed_size) do |bytes, offset|
+        value, consumed = decoder.decode(bytes, offset: offset)
+        tap_fn.call(value)
+        [value, consumed]
+      end
+    end
+
+    # Observe a codec's values on both sides. +decode_tap+ is optional.
+    sig do
+      params(
+        codec:      Codec,
+        encode_tap: T.proc.params(value: T.untyped).void,
+        decode_tap: T.nilable(T.proc.params(value: T.untyped).void)
+      ).returns(Codec)
+    end
+    def tap_codec(codec, encode_tap:, decode_tap: nil)
+      enc = tap_encoder(codec.encoder) { |value| encode_tap.call(value) }
+      dec = decode_tap ? tap_decoder(codec.decoder) { |value| decode_tap.call(value) } : codec.decoder
+      Codec.new(enc, dec)
+    end
+
+    # Observe the bytes an encoder produced, after they are written.
+    sig do
+      params(encoder: Encoder, tap_fn: T.proc.params(bytes: String).void).returns(Encoder)
+    end
+    def tap_encoder_bytes(encoder, &tap_fn)
+      Encoder.new(fixed_size: encoder.fixed_size, max_size: encoder.max_size) do |value|
+        bytes = encoder.encode(value)
+        tap_fn.call(bytes)
+        bytes
+      end
+    end
+
+    # Observe the raw bytes a decoder is about to read, before decoding.
+    sig do
+      params(
+        decoder: Decoder,
+        tap_fn:  T.proc.params(bytes: String, offset: Integer).void
+      ).returns(Decoder)
+    end
+    def tap_decoder_bytes(decoder, &tap_fn)
+      Decoder.new(fixed_size: decoder.fixed_size) do |bytes, offset|
+        tap_fn.call(bytes, offset)
+        decoder.decode(bytes, offset: offset)
+      end
+    end
+
+    # Observe a codec's raw bytes on both sides. +decode_tap+ is optional.
+    sig do
+      params(
+        codec:      Codec,
+        encode_tap: T.proc.params(bytes: String).void,
+        decode_tap: T.nilable(T.proc.params(bytes: String, offset: Integer).void)
+      ).returns(Codec)
+    end
+    def tap_codec_bytes(codec, encode_tap:, decode_tap: nil)
+      enc = tap_encoder_bytes(codec.encoder) { |bytes| encode_tap.call(bytes) }
+      dec = if decode_tap
+              tap_decoder_bytes(codec.decoder) { |bytes, offset| decode_tap.call(bytes, offset) }
+            else
+              codec.decoder
+            end
+      Codec.new(enc, dec)
+    end
+
     # Reverse the byte order of the encoded output (and input).
     sig { params(codec: Codec).returns(Codec) }
     def reverse_codec(codec)

data/lib/solana/ruby/kit/codecs/data_structures.rb

@@ -63,8 +63,23 @@ module Solana::Ruby::Kit
 
       # Encode/decode a variable-length array with a u32LE length prefix.
       # When +size+ is given the array has a fixed element count (no prefix).
-      sig { params(element_codec: Codec, size: T.nilable(Integer)).returns(Codec) }
-      def array_codec(element_codec, size: nil)
+      #
+      # When the size is stored as a prefix and there are not enough bytes left
+      # to read it, the decoder yields an empty array rather than failing. That
+      # is deliberate: it lets a program append a collection to an existing
+      # account layout and still decode accounts written before the change.
+      # Formats that cannot accept that leniency - borsh, for one, requires the
+      # prefix to be present - can pass +require_size_prefix: true+ to make a
+      # truncated buffer raise instead. The option has no effect when +size+ is
+      # given, since a fixed-count array carries no prefix.
+      sig do
+        params(
+          element_codec:       Codec,
+          size:                T.nilable(Integer),
+          require_size_prefix: T::Boolean
+        ).returns(Codec)
+      end
+      def array_codec(element_codec, size: nil, require_size_prefix: false)
         if size
           fixed = element_codec.fixed_size ? size * T.must(element_codec.fixed_size) : nil
           enc = Encoder.new(fixed_size: fixed) do |values|
@@ -90,6 +105,19 @@ module Solana::Ruby::Kit
             header + body
           end
           dec = Decoder.new do |bytes, offset|
+            prefix_size = T.must(prefix.fixed_size)
+            remaining   = [bytes.b.bytesize - offset, 0].max
+            if remaining < prefix_size
+              # The prefix is missing or truncated. By default that decodes to
+              # an empty collection having consumed nothing; under
+              # +require_size_prefix+ it is an error.
+              Kernel.raise SolanaError.new(
+                SolanaError::CODECS__INVALID_BYTE_LENGTH,
+                { expected: prefix_size, actual: remaining }
+              ) if require_size_prefix
+
+              next [[], 0]
+            end
             len, prefix_bytes = prefix.decode(bytes, offset: offset)
             result   = []
             consumed = prefix_bytes
@@ -106,10 +134,18 @@ module Solana::Ruby::Kit
 
       # Encode/decode a Hash.
       # Encoded as: [length prefix] + [key, value, key, value, ...]
-      sig { params(key_codec: Codec, value_codec: Codec, size: T.nilable(Integer)).returns(Codec) }
-      def map_codec(key_codec, value_codec, size: nil)
+      # See +array_codec+ for what +require_size_prefix+ does.
+      sig do
+        params(
+          key_codec:           Codec,
+          value_codec:         Codec,
+          size:                T.nilable(Integer),
+          require_size_prefix: T::Boolean
+        ).returns(Codec)
+      end
+      def map_codec(key_codec, value_codec, size: nil, require_size_prefix: false)
         pair_codec = tuple_codec([key_codec, value_codec])
-        array_codec(pair_codec, size: size).transform_decoder do |pairs|
+        array_codec(pair_codec, size: size, require_size_prefix: require_size_prefix).transform_decoder do |pairs|
           pairs.each_with_object({}) { |(k, v), h| h[k] = v }
         end.transform_encoder do |hash|
           T.cast(hash, T::Hash[T.untyped, T.untyped]).map { |k, v| [k, v] }
@@ -117,9 +153,16 @@ module Solana::Ruby::Kit
       end
 
       # Encode/decode a Set (stored as an array of unique elements).
-      sig { params(element_codec: Codec, size: T.nilable(Integer)).returns(Codec) }
-      def set_codec(element_codec, size: nil)
-        array_codec(element_codec, size: size)
+      # See +array_codec+ for what +require_size_prefix+ does.
+      sig do
+        params(
+          element_codec:       Codec,
+          size:                T.nilable(Integer),
+          require_size_prefix: T::Boolean
+        ).returns(Codec)
+      end
+      def set_codec(element_codec, size: nil, require_size_prefix: false)
+        array_codec(element_codec, size: size, require_size_prefix: require_size_prefix)
           .transform_encoder { |s| T.cast(s, T::Set[T.untyped]).to_a }
           .transform_decoder { |arr| Set.new(arr) }
       end

data/lib/solana/ruby/kit/codecs/numbers.rb

@@ -19,6 +19,43 @@ module Solana::Ruby::Kit
       # defeated the "directly available as Codecs.x" intent in codecs.rb.
       extend self
 
+      # ── Multi-byte integers ──────────────────────────────────────────────────
+
+      # Shared implementation behind u128 / i128 / u256 / i256.
+      #
+      # Upstream splits these values into 64-bit words because a JS `DataView`
+      # has no accessor wider than 64 bits. Ruby's Integer is arbitrary
+      # precision, so there is nothing to split: the value is shifted out one
+      # byte at a time and reassembled the same way, which keeps a single
+      # implementation correct for any +byte_count+.
+      #
+      # +signed+ selects two's-complement interpretation over +byte_count * 8+
+      # bits, so negative values round-trip.
+      sig { params(byte_count: Integer, signed: T::Boolean, endian: Symbol).returns(Codec) }
+      def big_int_codec(byte_count, signed:, endian: :little)
+        bits = byte_count * 8
+        enc = Encoder.new(fixed_size: byte_count) do |v|
+          n = Kernel.Integer(v)
+          n += (1 << bits) if signed && n.negative?
+          out = Array.new(byte_count) do
+            byte = n & 0xFF
+            n >>= 8
+            byte
+          end
+          # `out` is least-significant-byte first.
+          (endian == :little ? out : out.reverse).pack('C*')
+        end
+        dec = Decoder.new(fixed_size: byte_count) do |bytes, offset|
+          slice = bytes.b.byteslice(offset, byte_count) || ("\x00" * byte_count).b
+          arr   = T.cast(T.unsafe(slice).unpack('C*'), T::Array[Integer])
+          arr   = arr.reverse if endian == :little
+          n     = arr.reduce(0) { |acc, byte| (acc << 8) | byte }
+          n -= (1 << bits) if signed && n >= (1 << (bits - 1))
+          [n, byte_count]
+        end
+        Codec.new(enc, dec)
+      end
+
       # ── Unsigned integers ────────────────────────────────────────────────────
 
       sig { returns(Codec) }
@@ -62,29 +99,12 @@ module Solana::Ruby::Kit
 
       sig { params(endian: Symbol).returns(Codec) }
       def u128_codec(endian: :little)
-        enc = Encoder.new(fixed_size: 16) do |v|
-          n = Kernel.Integer(v)
-          if endian == :little
-            bytes = []
-            16.times { bytes << (n & 0xFF); n >>= 8 }
-            bytes.pack('C*')
-          else
-            bytes = []
-            16.times { bytes.unshift(n & 0xFF); n >>= 8 }
-            bytes.pack('C*')
-          end
-        end
-        dec = Decoder.new(fixed_size: 16) do |bytes, offset|
-          slice = bytes.b.byteslice(offset, 16) || ("\x00" * 16).b
-          arr   = T.cast(T.unsafe(slice).unpack('C*'), T::Array[Integer])
-          n = if endian == :little
-                arr.reverse.reduce(0) { |acc, b| (acc << 8) | b }
-              else
-                arr.reduce(0) { |acc, b| (acc << 8) | b }
-              end
-          [n, 16]
-        end
-        Codec.new(enc, dec)
+        big_int_codec(16, signed: false, endian: endian)
+      end
+
+      sig { params(endian: Symbol).returns(Codec) }
+      def u256_codec(endian: :little)
+        big_int_codec(32, signed: false, endian: endian)
       end
 
       # ── Signed integers ──────────────────────────────────────────────────────
@@ -130,33 +150,12 @@ module Solana::Ruby::Kit
 
       sig { params(endian: Symbol).returns(Codec) }
       def i128_codec(endian: :little)
-        enc = Encoder.new(fixed_size: 16) do |v|
-          n    = Kernel.Integer(v)
-          # Two's complement for negative numbers
-          n += (1 << 128) if n.negative?
-          if endian == :little
-            bytes = []
-            16.times { bytes << (n & 0xFF); n >>= 8 }
-            bytes.pack('C*')
-          else
-            bytes = []
-            16.times { bytes.unshift(n & 0xFF); n >>= 8 }
-            bytes.pack('C*')
-          end
-        end
-        dec = Decoder.new(fixed_size: 16) do |bytes, offset|
-          slice = bytes.b.byteslice(offset, 16) || ("\x00" * 16).b
-          arr   = T.cast(T.unsafe(slice).unpack('C*'), T::Array[Integer])
-          n = if endian == :little
-                arr.reverse.reduce(0) { |acc, b| (acc << 8) | b }
-              else
-                arr.reduce(0) { |acc, b| (acc << 8) | b }
-              end
-          # Convert from unsigned to signed 128-bit
-          n -= (1 << 128) if n >= (1 << 127)
-          [n, 16]
-        end
-        Codec.new(enc, dec)
+        big_int_codec(16, signed: true, endian: endian)
+      end
+
+      sig { params(endian: Symbol).returns(Codec) }
+      def i256_codec(endian: :little)
+        big_int_codec(32, signed: true, endian: endian)
       end
 
       # ── Floating point ───────────────────────────────────────────────────────