solana-ruby-kit 0.1.0

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

@@ -0,0 +1,58 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Solana::Ruby::Kit
+  module Codecs
+    # Low-level byte-string utilities.
+    # All methods work with binary-encoded Ruby Strings (encoding = ASCII-8BIT).
+    module Bytes
+      extend T::Sig
+
+      module_function
+
+      # Concatenate multiple binary strings into one.
+      sig { params(byte_strings: String).returns(String) }
+      def merge_bytes(*byte_strings)
+        result = ''.b
+        byte_strings.each { |bs| result << bs.b }
+        result
+      end
+
+      # Pad +bytes+ to exactly +size+ bytes.
+      # @param direction [:right, :left]  which side to pad
+      sig do
+        params(bytes: String, size: Integer, direction: Symbol, pad_byte: String)
+          .returns(String)
+      end
+      def pad_bytes(bytes, size, direction: :right, pad_byte: "\x00")
+        b = bytes.b
+        return b if b.bytesize >= size
+
+        padding = (pad_byte.b * (size - b.bytesize))
+        direction == :left ? padding + b : b + padding
+      end
+
+      # Return exactly +size+ bytes from +bytes+, raising if sizes don't match.
+      sig { params(bytes: String, size: Integer).returns(String) }
+      def fix_bytes(bytes, size)
+        b = bytes.b
+        unless b.bytesize == size
+          Kernel.raise ArgumentError,
+                "Expected #{size} bytes, got #{b.bytesize}"
+        end
+
+        b
+      end
+
+      # Return true if +inner+ appears inside +outer+ starting at +offset+.
+      sig { params(outer: String, inner: String, offset: Integer).returns(T::Boolean) }
+      def contains_bytes?(outer, inner, offset: 0)
+        ob = outer.b
+        ib = inner.b
+        return false if offset + ib.bytesize > ob.bytesize
+
+        ob.byteslice(offset, ib.bytesize) == ib
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Solana::Ruby::Kit
+  module Codecs
+    extend T::Sig
+    # A Codec combines an Encoder and a Decoder for the same type.
+    # It also provides combinators that mirror @solana/codecs-core helpers:
+    #   fix_codec_size, add_codec_size_prefix, offset_codec, reverse_codec
+    class Codec
+      extend T::Sig
+
+      sig { returns(Encoder) }
+      attr_reader :encoder
+
+      sig { returns(Decoder) }
+      attr_reader :decoder
+
+      sig { params(encoder: Encoder, decoder: Decoder).void }
+      def initialize(encoder, decoder)
+        @encoder = encoder
+        @decoder = decoder
+      end
+
+      # Build a Codec from separate Encoder and Decoder.
+      sig { params(encoder: Encoder, decoder: Decoder).returns(Codec) }
+      def self.combine(encoder, decoder)
+        new(encoder, decoder)
+      end
+
+      # Delegate encode / decode for convenience.
+      sig { params(value: T.untyped).returns(String) }
+      def encode(value) = @encoder.encode(value)
+
+      sig { params(bytes: String, offset: Integer).returns([T.untyped, Integer]) }
+      def decode(bytes, offset: 0) = @decoder.decode(bytes, offset: offset)
+
+      sig { returns(T.nilable(Integer)) }
+      def fixed_size = @encoder.fixed_size
+
+      # Return a new Codec whose Encoder maps values through +map_fn+ before
+      # encoding (pre-encode transform).
+      sig { params(map_fn: T.proc.params(value: T.untyped).returns(T.untyped)).returns(Codec) }
+      def transform_encoder(&map_fn)
+        original_enc = @encoder
+        new_enc = Encoder.new(fixed_size: original_enc.fixed_size, max_size: original_enc.max_size) do |value|
+          original_enc.encode(map_fn.call(value))
+        end
+        Codec.new(new_enc, @decoder)
+      end
+
+      # Return a new Codec whose Decoder maps decoded values through +map_fn+
+      # (post-decode transform).
+      sig { params(map_fn: T.proc.params(value: T.untyped).returns(T.untyped)).returns(Codec) }
+      def transform_decoder(&map_fn)
+        original_dec = @decoder
+        new_dec = Decoder.new(fixed_size: original_dec.fixed_size) do |bytes, offset|
+          value, consumed = original_dec.decode(bytes, offset: offset)
+          [map_fn.call(value), consumed]
+        end
+        Codec.new(@encoder, new_dec)
+      end
+    end
+
+    # ── Combinators ─────────────────────────────────────────────────────────────
+
+    module_function
+
+    # Return a Codec whose output is always exactly +size+ bytes
+    # (zero-padded on right, truncated if too large).
+    sig { params(codec: Codec, size: Integer).returns(Codec) }
+    def fix_codec_size(codec, size)
+      enc = Encoder.new(fixed_size: size) do |value|
+        raw = codec.encode(value)
+        if raw.bytesize < size
+          raw.b + ("\x00".b * (size - raw.bytesize))
+        else
+          raw.b[0, size] || ''.b
+        end
+      end
+      dec = Decoder.new(fixed_size: size) do |bytes, offset|
+        slice = bytes.b.byteslice(offset, size) || ''.b
+        value, = codec.decoder.decode(slice, offset: 0)
+        [value, size]
+      end
+      Codec.new(enc, dec)
+    end
+
+    # Prefix encoded data with its byte length using +prefix_codec+
+    # (typically a u32 little-endian codec).
+    sig { params(codec: Codec, prefix_codec: Codec).returns(Codec) }
+    def add_codec_size_prefix(codec, prefix_codec)
+      enc = Encoder.new do |value|
+        data   = codec.encode(value)
+        prefix = prefix_codec.encode(data.bytesize)
+        prefix + data
+      end
+      dec = Decoder.new do |bytes, offset|
+        len, prefix_size = prefix_codec.decode(bytes, offset: offset)
+        value, data_size = codec.decode(bytes, offset: offset + prefix_size)
+        [value, prefix_size + data_size]
+      end
+      Codec.new(enc, dec)
+    end
+
+    # Shift the decode offset by +pre_offset+ before decoding and add
+    # +post_offset+ to the consumed byte count afterwards.
+    sig do
+      params(codec: Codec, pre_offset: Integer, post_offset: Integer).returns(Codec)
+    end
+    def offset_codec(codec, pre_offset: 0, post_offset: 0)
+      enc = Encoder.new(fixed_size: codec.fixed_size) { |v| codec.encode(v) }
+      dec = Decoder.new(fixed_size: codec.fixed_size) do |bytes, offset|
+        value, consumed = codec.decode(bytes, offset: offset + pre_offset)
+        [value, consumed + post_offset]
+      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)
+      enc = Encoder.new(fixed_size: codec.fixed_size) do |value|
+        codec.encode(value).b.reverse
+      end
+      dec = Decoder.new(fixed_size: codec.fixed_size) do |bytes, offset|
+        size    = codec.fixed_size || bytes.bytesize - offset
+        slice   = bytes.b.byteslice(offset, size) || ''.b
+        value, = codec.decode(slice.reverse, offset: 0)
+        [value, size]
+      end
+      Codec.new(enc, dec)
+    end
+  end
+end

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

@@ -0,0 +1,177 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Solana::Ruby::Kit
+  module Codecs
+    # Data-structure codecs — mirrors @solana/codecs-data-structures.
+    module DataStructures
+      extend T::Sig
+
+      module_function
+
+      # Encode/decode a fixed ordered list of named fields.
+      # +fields+ is an Array of [name, codec] pairs (name can be String or Symbol).
+      # Encodes to a Hash on decode; expects a Hash for encode.
+      sig { params(fields: T::Array[[T.any(String, Symbol), Codec]]).returns(Codec) }
+      def struct_codec(fields)
+        fixed = fields.all? { |_, c| c.fixed_size }
+        total = fixed ? fields.sum { |_, c| T.must(c.fixed_size) } : nil
+
+        enc = Encoder.new(fixed_size: total) do |value|
+          h = T.cast(value, T::Hash[T.untyped, T.untyped])
+          fields.map { |name, codec| codec.encode(h[name] || h[name.to_s]) }.join.b
+        end
+        dec = Decoder.new(fixed_size: total) do |bytes, offset|
+          result   = {}
+          consumed = 0
+          fields.each do |name, codec|
+            val, n = codec.decode(bytes, offset: offset + consumed)
+            result[name.to_sym] = val
+            consumed += n
+          end
+          [result, consumed]
+        end
+        Codec.new(enc, dec)
+      end
+
+      # Encode/decode a fixed positional tuple (Array of values, one codec each).
+      sig { params(codecs: T::Array[Codec]).returns(Codec) }
+      def tuple_codec(codecs)
+        fixed = codecs.all?(&:fixed_size)
+        total = fixed ? codecs.sum { |c| T.must(c.fixed_size) } : nil
+
+        enc = Encoder.new(fixed_size: total) do |values|
+          arr = T.cast(values, T::Array[T.untyped])
+          codecs.each_with_index.map { |c, i| c.encode(arr[i]) }.join.b
+        end
+        dec = Decoder.new(fixed_size: total) do |bytes, offset|
+          result   = []
+          consumed = 0
+          codecs.each do |c|
+            val, n = c.decode(bytes, offset: offset + consumed)
+            result << val
+            consumed += n
+          end
+          [result, consumed]
+        end
+        Codec.new(enc, dec)
+      end
+
+      # 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)
+        if size
+          fixed = element_codec.fixed_size ? size * T.must(element_codec.fixed_size) : nil
+          enc = Encoder.new(fixed_size: fixed) do |values|
+            T.cast(values, T::Array[T.untyped]).map { |v| element_codec.encode(v) }.join.b
+          end
+          dec = Decoder.new(fixed_size: fixed) do |bytes, offset|
+            result   = []
+            consumed = 0
+            size.times do
+              val, n = element_codec.decode(bytes, offset: offset + consumed)
+              result << val
+              consumed += n
+            end
+            [result, consumed]
+          end
+          Codec.new(enc, dec)
+        else
+          prefix = Numbers.u32_codec
+          enc = Encoder.new do |values|
+            arr    = T.cast(values, T::Array[T.untyped])
+            header = prefix.encode(arr.length)
+            body   = arr.map { |v| element_codec.encode(v) }.join.b
+            header + body
+          end
+          dec = Decoder.new do |bytes, offset|
+            len, prefix_bytes = prefix.decode(bytes, offset: offset)
+            result   = []
+            consumed = prefix_bytes
+            len.times do
+              val, n = element_codec.decode(bytes, offset: offset + consumed)
+              result << val
+              consumed += n
+            end
+            [result, consumed]
+          end
+          Codec.new(enc, dec)
+        end
+      end
+
+      # 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)
+        pair_codec = tuple_codec([key_codec, value_codec])
+        array_codec(pair_codec, size: size).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] }
+        end
+      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)
+          .transform_encoder { |s| T.cast(s, T::Set[T.untyped]).to_a }
+          .transform_decoder { |arr| Set.new(arr) }
+      end
+
+      # Discriminated-union codec.
+      # +variants+ is an Array of [tag, codec] pairs; +discriminator_codec+ encodes
+      # the tag (typically a u8 codec).
+      # Encode expects +[tag, value]+; decode returns +[tag, value]+.
+      sig do
+        params(
+          variants:           T::Array[[T.untyped, Codec]],
+          discriminator_codec: Codec
+        ).returns(Codec)
+      end
+      def union_codec(variants, discriminator_codec)
+        tag_to_codec  = variants.to_h
+        idx_to_tag    = variants.map(&:first)
+
+        enc = Encoder.new do |tagged_value|
+          tag, value = T.cast(tagged_value, [T.untyped, T.untyped])
+          inner_codec = tag_to_codec.fetch(tag) { Kernel.raise ArgumentError, "Unknown union tag: #{tag}" }
+          discriminator_codec.encode(idx_to_tag.index(tag)) + inner_codec.encode(value)
+        end
+        dec = Decoder.new do |bytes, offset|
+          idx, disc_size = discriminator_codec.decode(bytes, offset: offset)
+          tag        = idx_to_tag.fetch(idx) { Kernel.raise ArgumentError, "Unknown union discriminant: #{idx}" }
+          inner      = tag_to_codec.fetch(tag)
+          value, n   = inner.decode(bytes, offset: offset + disc_size)
+          [[tag, value], disc_size + n]
+        end
+        Codec.new(enc, dec)
+      end
+
+      # Option codec — 1 byte discriminant (0 = None, 1 = Some) + optional value.
+      # Encode expects an Solana::Ruby::Kit::Options::Option; decode returns one.
+      sig { params(value_codec: Codec).returns(Codec) }
+      def option_codec(value_codec)
+        disc = Numbers.u8_codec
+        enc = Encoder.new do |option|
+          if option.is_a?(Solana::Ruby::Kit::Options::Some)
+            disc.encode(1) + value_codec.encode(option.value)
+          else
+            disc.encode(0)
+          end
+        end
+        dec = Decoder.new do |bytes, offset|
+          flag, flag_size = disc.decode(bytes, offset: offset)
+          if flag == 1
+            val, n = value_codec.decode(bytes, offset: offset + flag_size)
+            [Solana::Ruby::Kit::Options::Some.new(val), flag_size + n]
+          else
+            [Solana::Ruby::Kit::Options::None.constants, flag_size]
+          end
+        end
+        Codec.new(enc, dec)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Solana::Ruby::Kit
+  module Codecs
+    # Mirrors the TypeScript Decoder<T> interface from @solana/codecs-core.
+    #
+    # A Decoder knows how to turn binary bytes into a Ruby value.
+    # Fixed-size decoders advertise their byte length via +fixed_size+;
+    # variable-size decoders leave it nil.
+    #
+    # The inner block receives +(bytes, offset)+ and must return
+    # +[value, bytes_consumed]+.
+    class Decoder
+      extend T::Sig
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :fixed_size
+
+      sig do
+        params(
+          fixed_size: T.nilable(Integer),
+          block:      T.proc.params(bytes: String, offset: Integer)
+                             .returns([T.untyped, Integer])
+        ).void
+      end
+      def initialize(fixed_size: nil, &block)
+        @fixed_size = fixed_size
+        @fn = T.let(
+          block,
+          T.proc.params(bytes: String, offset: Integer).returns([T.untyped, Integer])
+        )
+      end
+
+      # Decode from +bytes+ starting at +offset+.
+      # Returns +[value, bytes_consumed]+.
+      sig { params(bytes: String, offset: Integer).returns([T.untyped, Integer]) }
+      def decode(bytes, offset: 0)
+        @fn.call(bytes.b, offset)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Solana::Ruby::Kit
+  module Codecs
+    # Mirrors the TypeScript Encoder<T> interface from @solana/codecs-core.
+    #
+    # An Encoder knows how to turn a Ruby value into a binary String.
+    # Fixed-size encoders advertise their byte length via +fixed_size+;
+    # variable-size encoders leave it nil and may advertise +max_size+.
+    class Encoder
+      extend T::Sig
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :fixed_size
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :max_size
+
+      sig do
+        params(
+          fixed_size: T.nilable(Integer),
+          max_size:   T.nilable(Integer),
+          block:      T.proc.params(value: T.untyped).returns(String)
+        ).void
+      end
+      def initialize(fixed_size: nil, max_size: nil, &block)
+        @fixed_size = fixed_size
+        @max_size   = max_size
+        @fn         = T.let(block, T.proc.params(value: T.untyped).returns(String))
+      end
+
+      # Encode +value+ and return a binary String.
+      sig { params(value: T.untyped).returns(String) }
+      def encode(value)
+        @fn.call(value).b
+      end
+
+      # Encode +value+ into +target+ starting at +offset+.
+      # Returns the number of bytes written.
+      sig { params(value: T.untyped, target: String, offset: Integer).returns(Integer) }
+      def encode_into(value, target, offset)
+        bytes = encode(value)
+        target.b
+        # Ensure target is long enough
+        target << ("\x00".b * [0, offset + bytes.bytesize - target.bytesize].max)
+        target[offset, bytes.bytesize] = bytes
+        bytes.bytesize
+      end
+    end
+  end
+end

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

@@ -0,0 +1,217 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Solana::Ruby::Kit
+  module Codecs
+    # Numeric codecs — mirrors @solana/codecs-numbers.
+    # All pack/unpack directives follow Ruby's Array#pack notation.
+    # Default endian is :little (Solana is always little-endian on-chain).
+    #
+    # Fixed sizes (bytes):
+    #   u8/i8 = 1, u16/i16 = 2, u32/i32 = 4, u64/i64 = 8,
+    #   u128/i128 = 16, f32 = 4, f64 = 8
+    module Numbers
+      extend T::Sig
+
+      module_function
+
+      # ── Unsigned integers ────────────────────────────────────────────────────
+
+      sig { returns(Codec) }
+      def u8_codec
+        enc = Encoder.new(fixed_size: 1) { |v| [Kernel.Integer(v)].pack('C') }
+        dec = Decoder.new(fixed_size: 1) do |bytes, offset|
+          [bytes.b.byteslice(offset, 1)&.unpack1('C') || 0, 1]
+        end
+        Codec.new(enc, dec)
+      end
+
+      sig { params(endian: Symbol).returns(Codec) }
+      def u16_codec(endian: :little)
+        dir = endian == :little ? 'v' : 'n'
+        enc = Encoder.new(fixed_size: 2) { |v| [Kernel.Integer(v)].pack(dir) }
+        dec = Decoder.new(fixed_size: 2) do |bytes, offset|
+          [bytes.b.byteslice(offset, 2)&.unpack1(dir) || 0, 2]
+        end
+        Codec.new(enc, dec)
+      end
+
+      sig { params(endian: Symbol).returns(Codec) }
+      def u32_codec(endian: :little)
+        dir = endian == :little ? 'V' : 'N'
+        enc = Encoder.new(fixed_size: 4) { |v| [Kernel.Integer(v)].pack(dir) }
+        dec = Decoder.new(fixed_size: 4) do |bytes, offset|
+          [bytes.b.byteslice(offset, 4)&.unpack1(dir) || 0, 4]
+        end
+        Codec.new(enc, dec)
+      end
+
+      sig { params(endian: Symbol).returns(Codec) }
+      def u64_codec(endian: :little)
+        dir = endian == :little ? 'Q<' : 'Q>'
+        enc = Encoder.new(fixed_size: 8) { |v| [Kernel.Integer(v)].pack(dir) }
+        dec = Decoder.new(fixed_size: 8) do |bytes, offset|
+          [bytes.b.byteslice(offset, 8)&.unpack1(dir) || 0, 8]
+        end
+        Codec.new(enc, dec)
+      end
+
+      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)
+      end
+
+      # ── Signed integers ──────────────────────────────────────────────────────
+
+      sig { returns(Codec) }
+      def i8_codec
+        enc = Encoder.new(fixed_size: 1) { |v| [Kernel.Integer(v)].pack('c') }
+        dec = Decoder.new(fixed_size: 1) do |bytes, offset|
+          [bytes.b.byteslice(offset, 1)&.unpack1('c') || 0, 1]
+        end
+        Codec.new(enc, dec)
+      end
+
+      sig { params(endian: Symbol).returns(Codec) }
+      def i16_codec(endian: :little)
+        dir = endian == :little ? 's<' : 's>'
+        enc = Encoder.new(fixed_size: 2) { |v| [Kernel.Integer(v)].pack(dir) }
+        dec = Decoder.new(fixed_size: 2) do |bytes, offset|
+          [bytes.b.byteslice(offset, 2)&.unpack1(dir) || 0, 2]
+        end
+        Codec.new(enc, dec)
+      end
+
+      sig { params(endian: Symbol).returns(Codec) }
+      def i32_codec(endian: :little)
+        dir = endian == :little ? 'l<' : 'l>'
+        enc = Encoder.new(fixed_size: 4) { |v| [Kernel.Integer(v)].pack(dir) }
+        dec = Decoder.new(fixed_size: 4) do |bytes, offset|
+          [bytes.b.byteslice(offset, 4)&.unpack1(dir) || 0, 4]
+        end
+        Codec.new(enc, dec)
+      end
+
+      sig { params(endian: Symbol).returns(Codec) }
+      def i64_codec(endian: :little)
+        dir = endian == :little ? 'q<' : 'q>'
+        enc = Encoder.new(fixed_size: 8) { |v| [Kernel.Integer(v)].pack(dir) }
+        dec = Decoder.new(fixed_size: 8) do |bytes, offset|
+          [bytes.b.byteslice(offset, 8)&.unpack1(dir) || 0, 8]
+        end
+        Codec.new(enc, dec)
+      end
+
+      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)
+      end
+
+      # ── Floating point ───────────────────────────────────────────────────────
+
+      sig { params(endian: Symbol).returns(Codec) }
+      def f32_codec(endian: :little)
+        dir = endian == :little ? 'e' : 'g'
+        enc = Encoder.new(fixed_size: 4) { |v| [Kernel.Float(v)].pack(dir) }
+        dec = Decoder.new(fixed_size: 4) do |bytes, offset|
+          [bytes.b.byteslice(offset, 4)&.unpack1(dir) || 0.0, 4]
+        end
+        Codec.new(enc, dec)
+      end
+
+      sig { params(endian: Symbol).returns(Codec) }
+      def f64_codec(endian: :little)
+        dir = endian == :little ? 'E' : 'G'
+        enc = Encoder.new(fixed_size: 8) { |v| [Kernel.Float(v)].pack(dir) }
+        dec = Decoder.new(fixed_size: 8) do |bytes, offset|
+          [bytes.b.byteslice(offset, 8)&.unpack1(dir) || 0.0, 8]
+        end
+        Codec.new(enc, dec)
+      end
+
+      # ── Short vector (Solana compact-u16) ────────────────────────────────────
+      # Variable-length encoding used in transaction wire format.
+      # Each byte uses the 7 low bits for data and bit 7 as a continuation flag.
+
+      sig { returns(Codec) }
+      def compact_u16_codec
+        enc = Encoder.new do |v|
+          n = Kernel.Integer(v)
+          Kernel.raise ArgumentError, "compact_u16 value out of range: #{n}" if n > 0xFFFF || n.negative?
+
+          bytes = []
+          Kernel.loop do
+            low7 = n & 0x7F
+            n >>= 7
+            bytes << (n.positive? ? (low7 | 0x80) : low7)
+            break if n.zero?
+          end
+          bytes.pack('C*')
+        end
+        dec = Decoder.new do |bytes, offset|
+          b  = bytes.b
+          n  = 0
+          shift = 0
+          consumed = 0
+          Kernel.loop do
+            byte = b.byteslice(offset + consumed, 1)&.unpack1('C') || 0
+            consumed += 1
+            n |= (byte & 0x7F) << shift
+            shift += 7
+            break if (byte & 0x80).zero?
+          end
+          [n, consumed]
+        end
+        Codec.new(enc, dec)
+      end
+    end
+  end
+end