solana-ruby-kit 7.1.1.2 → 8.3.0

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

@@ -15,14 +15,134 @@ module Solana::Ruby::Kit
       # defeated the "directly available as Codecs.x" intent in codecs.rb.
       extend self
 
+      # Byte order mark, U+FEFF, in its UTF-8 encoding.
+      BOM = T.let("\xEF\xBB\xBF".b.freeze, String)
+
+      # Remove every null character from a decoded string.
+      # Mirrors `removeNullCharacters`.
+      sig { params(value: String).returns(String) }
+      def remove_null_characters(value)
+        value.delete("\x00")
+      end
+
+      # Find the first malformed UTF-8 sequence in +bytes+, starting at +offset+.
+      # Returns the byte offset at which it starts, or -1 when the bytes are
+      # well-formed.
+      #
+      # This rejects everything the Unicode standard rejects: unexpected
+      # continuation bytes, overlong encodings, encoded surrogates, code points
+      # above U+10FFFF and truncated sequences. Ruby's own +valid_encoding?+
+      # answers the same question, but only yes or no - this reports *where*,
+      # which is what the error context needs.
+      # Mirrors `findMalformedUtf8SequenceOffset`.
+      sig { params(bytes: String, offset: Integer).returns(Integer) }
+      def find_malformed_utf8_sequence_offset(bytes, offset = 0)
+        arr    = T.cast(T.unsafe(bytes.b).unpack('C*'), T::Array[Integer])
+        length = arr.length
+        index  = offset
+        while index < length
+          lead = T.must(arr[index])
+          min  = 0x80
+          max  = 0xBF
+          if lead < 0x80
+            index += 1
+            next
+          elsif lead >= 0xC2 && lead <= 0xDF
+            count = 1
+          elsif lead >= 0xE0 && lead <= 0xEF
+            count = 2
+            min = 0xA0 if lead == 0xE0 # Overlong.
+            max = 0x9F if lead == 0xED # Encoded surrogate.
+          elsif lead >= 0xF0 && lead <= 0xF4
+            count = 3
+            min = 0x90 if lead == 0xF0 # Overlong.
+            max = 0x8F if lead == 0xF4 # Above U+10FFFF.
+          else
+            return index
+          end
+
+          start  = index
+          index += 1
+          count.times do |i|
+            return start if index >= length
+
+            byte     = T.must(arr[index])
+            in_range = i.zero? ? byte >= min && byte <= max : byte >= 0x80 && byte <= 0xBF
+            return start unless in_range
+
+            index += 1
+          end
+        end
+        -1
+      end
+
+      # Raise unless +bytes+, from +offset+, form well-formed UTF-8.
+      # Mirrors `assertIsWellFormedUtf8Bytes`.
+      sig { params(bytes: String, offset: Integer).void }
+      def assert_is_well_formed_utf8_bytes(bytes, offset = 0)
+        malformed = find_malformed_utf8_sequence_offset(bytes, offset)
+        return if malformed == -1
+
+        Kernel.raise SolanaError.new(
+          SolanaError::CODECS__INVALID_UTF8_BYTES,
+          { bytes: bytes.b, offset: malformed }
+        )
+      end
+
+      # Raise unless +value+ can be encoded as UTF-8 without loss.
+      # Mirrors `assertIsWellFormedUtf8String`.
+      #
+      # Upstream guards against lone surrogates, which a JavaScript string can
+      # hold because it is a sequence of UTF-16 code units. A Ruby String is a
+      # byte sequence with an encoding tag, so the equivalent flaw is a String
+      # whose bytes are not valid UTF-8. Upstream's reported +index+ counts
+      # UTF-16 code units; the +index+ here is a byte offset.
+      sig { params(value: String).void }
+      def assert_is_well_formed_utf8_string(value)
+        index = find_malformed_utf8_sequence_offset(value.b)
+        return if index == -1
+
+        Kernel.raise SolanaError.new(
+          SolanaError::CODECS__INVALID_UTF8_STRING,
+          { index: index, value: value }
+        )
+      end
+
       # UTF-8 string codec.
       # When +size+ is given the encoded bytes are fixed to that length
       # (zero-padded or truncated); otherwise the codec is variable-length
       # and must be used inside a size-prefixed container.
-      sig { params(size: T.nilable(Integer)).returns(Codec) }
-      def utf8_codec(size: nil)
+      #
+      # +fatal+ rejects invalid UTF-8 instead of passing it through: on encode a
+      # String whose bytes are not valid UTF-8, on decode a malformed byte
+      # sequence.
+      #
+      # +ignore_bom+ follows TextDecoder's confusing spelling: the default,
+      # +false+, *strips* a leading byte order mark; +true+ keeps it.
+      #
+      # +remove_null_characters+ strips every null character from the decoded
+      # string, which is what makes fixed-size padded strings read back cleanly.
+      # It is on by default, matching upstream, and makes the codec lossy for
+      # strings that legitimately contain nulls - pass +false+ for a lossless
+      # round trip.
+      sig do
+        params(
+          size:                   T.nilable(Integer),
+          fatal:                  T::Boolean,
+          ignore_bom:             T::Boolean,
+          remove_null_characters: T::Boolean
+        ).returns(Codec)
+      end
+      def utf8_codec(size: nil, fatal: false, ignore_bom: false, remove_null_characters: true)
+        strip_nulls = remove_null_characters
         enc = Encoder.new(fixed_size: size) do |v|
-          raw = v.to_s.encode('UTF-8').b
+          str = v.to_s
+          # Transcode anything that is not already UTF-8 (or raw bytes); a
+          # UTF-8 to UTF-8 `encode` is a no-op and would not validate, which is
+          # what `fatal` is for.
+          str = str.encode(::Encoding::UTF_8) unless [::Encoding::UTF_8, ::Encoding::BINARY].include?(str.encoding)
+          raw = str.b
+          assert_is_well_formed_utf8_string(raw) if fatal
           if size
             raw.bytesize <= size ? raw.ljust(size, "\x00") : raw.byteslice(0, size) || ''.b
           else
@@ -32,9 +152,15 @@ module Solana::Ruby::Kit
         dec = Decoder.new(fixed_size: size) do |bytes, offset|
           len   = size || (bytes.bytesize - offset)
           slice = bytes.b.byteslice(offset, len) || ''.b
-          # Strip null padding for fixed-size strings
-          str   = size ? slice.delete_suffix("\x00" * slice.bytesize.times.take_while { |i| slice.b[-1 - i] == "\x00" }.length) : slice
-          [str.force_encoding('UTF-8'), len]
+          assert_is_well_formed_utf8_bytes(slice) if fatal
+          slice = T.must(slice.byteslice(BOM.bytesize..)) if !ignore_bom && slice.start_with?(BOM)
+          str   = slice.force_encoding(::Encoding::UTF_8)
+          # Non-fatal decoding substitutes U+FFFD for malformed sequences, as
+          # TextDecoder does. `scrub` is Ruby's version of exactly that, and it
+          # also keeps the null-stripping below from raising on invalid bytes.
+          str   = str.scrub unless fatal
+          str   = remove_null_characters(str) if strip_nulls
+          [str, len]
         end
         Codec.new(enc, dec)
       end

data/lib/solana/ruby/kit/encoding/base58.rb

@@ -13,7 +13,7 @@ module Solana::Ruby::Kit
         String
       )
 
-      module_function
+      extend self
 
       # Encodes a binary String to a base58 string.
       sig { params(bytes: String).returns(String) }

data/lib/solana/ruby/kit/errors.rb

@@ -60,6 +60,10 @@ module Solana::Ruby::Kit
     TRANSACTION__FAILED_TO_DECOMPILE_INSTRUCTION_ACCOUNT_INDEX_OUT_OF_RANGE = :SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_INSTRUCTION_ACCOUNT_INDEX_OUT_OF_RANGE
     # context: { unsupported_version: }
     TRANSACTION__VERSION_NUMBER_NOT_SUPPORTED            = :SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_NOT_SUPPORTED
+    # context: { compute_unit_limit:, max_compute_unit_limit: }
+    TRANSACTION__COMPUTE_UNIT_LIMIT_OUT_OF_RANGE         = :SOLANA_ERROR__TRANSACTION__COMPUTE_UNIT_LIMIT_OUT_OF_RANGE
+    # context: { heap_size:, max_heap_size:, min_heap_size:, multiple_of: }
+    TRANSACTION__INVALID_HEAP_SIZE                       = :SOLANA_ERROR__TRANSACTION__INVALID_HEAP_SIZE
     TRANSACTIONS__SEND_TRANSACTION_PREFLIGHT_FAILURE     = :SOLANA_ERROR__TRANSACTIONS__SEND_TRANSACTION_PREFLIGHT_FAILURE
     TRANSACTIONS__BLOCKHASH_NOT_FOUND                    = :SOLANA_ERROR__TRANSACTIONS__BLOCKHASH_NOT_FOUND
     TRANSACTIONS__FAILED_TRANSACTION_PLAN                = :SOLANA_ERROR__TRANSACTIONS__FAILED_TRANSACTION_PLAN
@@ -91,6 +95,10 @@ module Solana::Ruby::Kit
     CODECS__INVALID_BYTE_LENGTH                          = :SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH
     CODECS__EXPECTED_ZERO_VALUE_TO_MATCH_ITEM_FIXED_DISCRIMINATOR = :SOLANA_ERROR__CODECS__EXPECTED_ZERO_VALUE_TO_MATCH_ITEM_FIXED_DISCRIMINATOR
     CODECS__FIXED_NULLABLE_CANNOT_WRAP_VARIABLE_SIZE_CODEC = :SOLANA_ERROR__CODECS__FIXED_NULLABLE_CANNOT_WRAP_VARIABLE_SIZE_CODEC
+    # context: { bytes:, offset: }
+    CODECS__INVALID_UTF8_BYTES                           = :SOLANA_ERROR__CODECS__INVALID_UTF8_BYTES
+    # context: { index:, value: }
+    CODECS__INVALID_UTF8_STRING                          = :SOLANA_ERROR__CODECS__INVALID_UTF8_STRING
 
     # ── RPC / JSON-RPC ────────────────────────────────────────────────────────
     RPC__INTEGER_OVERFLOW_WHILE_SERIALIZING_LARGE_INTEGER = :SOLANA_ERROR__RPC__INTEGER_OVERFLOW_WHILE_SERIALIZING_LARGE_INTEGER
@@ -207,6 +215,8 @@ module Solana::Ruby::Kit
         TRANSACTIONS__FAILED_TO_DECOMPILE_INSTRUCTION_PROGRAM_ADDRESS_NOT_FOUND => 'Failed to decompile instruction: program address not found at index %{index}',
         TRANSACTION__FAILED_TO_DECOMPILE_INSTRUCTION_ACCOUNT_INDEX_OUT_OF_RANGE => 'Failed to decompile instruction: account index %{index} is out of range',
         TRANSACTION__VERSION_NUMBER_NOT_SUPPORTED        => 'Transaction version %{unsupported_version} is not supported',
+        TRANSACTION__COMPUTE_UNIT_LIMIT_OUT_OF_RANGE     => 'Transaction compute unit limit must be an integer in the range [0, %{max_compute_unit_limit}]. `%{compute_unit_limit}` given',
+        TRANSACTION__INVALID_HEAP_SIZE                   => 'Transaction heap size must be an integer multiple of %{multiple_of} bytes in the range [%{min_heap_size}, %{max_heap_size}]. `%{heap_size}` given',
         TRANSACTIONS__SEND_TRANSACTION_PREFLIGHT_FAILURE => 'Transaction simulation failed: %{message}',
         TRANSACTIONS__BLOCKHASH_NOT_FOUND                => 'Blockhash not found',
         TRANSACTIONS__FAILED_TRANSACTION_PLAN            => 'Failed to execute transaction plan',
@@ -238,6 +248,8 @@ module Solana::Ruby::Kit
         CODECS__INVALID_BYTE_LENGTH                      => 'Expected %{expected} bytes but got %{actual}',
         CODECS__EXPECTED_ZERO_VALUE_TO_MATCH_ITEM_FIXED_DISCRIMINATOR => 'Expected zero value to match fixed discriminator',
         CODECS__FIXED_NULLABLE_CANNOT_WRAP_VARIABLE_SIZE_CODEC => 'A fixed-size nullable codec cannot wrap a variable-size codec',
+        CODECS__INVALID_UTF8_BYTES                       => 'Invalid UTF-8 byte sequence at offset %{offset}',
+        CODECS__INVALID_UTF8_STRING                      => 'Invalid UTF-8 string at index %{index}',
 
         # RPC
         RPC__INTEGER_OVERFLOW_WHILE_SERIALIZING_LARGE_INTEGER   => 'Integer overflow while serializing large integer %{value}',

data/lib/solana/ruby/kit/fast_stable_stringify.rb

@@ -8,7 +8,7 @@ module Solana::Ruby::Kit
   module FastStableStringify
     extend T::Sig
 
-    module_function
+    extend self
 
     # Serialize +value+ to a deterministic JSON string.
     # Hash keys are sorted lexicographically at every level.

data/lib/solana/ruby/kit/functional.rb

@@ -6,7 +6,7 @@ module Solana::Ruby::Kit
   # Mirrors the TypeScript package @solana/functional.
   module Functional
     extend T::Sig
-    module_function
+    extend self
 
     # Passes an initial value through a series of single-argument callables,
     # returning the final result.

data/lib/solana/ruby/kit/instruction_plans/instruction_plan.rb

@@ -97,7 +97,7 @@ module Solana::Ruby::Kit
 
     # ── Factory helpers ────────────────────────────────────────────────────────
 
-    module_function
+    extend self
 
     # Wraps a single instruction in a plan.
     # Mirrors `singleInstructionPlan(instruction)`.

data/lib/solana/ruby/kit/instruction_plans/max_instructions.rb

@@ -16,7 +16,7 @@ module Solana::Ruby::Kit
     # The hard maximum number of top-level instructions the transaction format can encode.
     TRANSACTION_INSTRUCTION_LIMIT = T.let(64, Integer)
 
-    module_function
+    extend self
 
     # Resolves the effective maximum number of instructions allowed in a transaction message,
     # falling back to the default when no value is provided.

data/lib/solana/ruby/kit/instruction_plans/transaction_plan.rb

@@ -41,7 +41,7 @@ module Solana::Ruby::Kit
       def kind = :parallel
     end
 
-    module_function
+    extend self
 
     # Creates a single-message plan.
     # Mirrors `singleTransactionPlan(transactionMessage)`.

data/lib/solana/ruby/kit/instruction_plans/transaction_plan_executor.rb

@@ -9,7 +9,7 @@ module Solana::Ruby::Kit
   module InstructionPlans
     extend T::Sig
 
-    module_function
+    extend self
 
     # Creates a TransactionPlanExecutor — a callable that traverses a TransactionPlan,
     # executing each single transaction message and collecting results.
@@ -58,9 +58,60 @@ module Solana::Ruby::Kit
       }
     end
 
+    # Creates a TransactionPlanExecutor that processes every leaf concurrently.
+    #
+    # It takes the same configuration as +create_transaction_plan_executor+ and its
+    # +execute_transaction_message+ callback follows the same contract: it receives a fresh
+    # mutable +context+ Hash for every leaf and returns the Hash a successful result should
+    # carry. On success the two are merged with the returned value winning; when the callback
+    # raises, the context accumulated so far is preserved on the failed result. The legacy
+    # one-argument callable shape is accepted here too.
+    #
+    # The difference is the traversal. This executor preserves the input plan's nesting, order
+    # and divisibility in the returned result, but it does not enforce the execution
+    # dependencies expressed by sequential plans: every leaf is started immediately, each on
+    # its own thread, with no concurrency limit. That makes it suitable for work that can be
+    # performed independently, such as signing or serializing transactions. For the same
+    # reason a callback that raises does not cancel the other leaves — each one runs to
+    # completion — and non-divisible sequential plans are supported rather than rejected.
+    #
+    # Once every leaf has settled, a result tree containing any failure raises
+    # INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN carrying the complete tree on its
+    # +transaction_plan_result+ reader.
+    #
+    # Because each leaf runs on its own thread, the callback must be safe to run concurrently
+    # with itself. Each leaf gets its own context Hash, so the contexts do not need guarding,
+    # but anything the callback shares between invocations does.
+    #
+    # Mirrors `createTransactionPlanExecutorWithConcurrentLeaves(config)` from
+    # @solana/instruction-plans.
+    # NOTE: Ruby translation has no abort signal; leaves are never canceled, only failed.
+    sig { params(execute_transaction_message: T.untyped).returns(T.untyped) }
+    def create_transaction_plan_executor_with_concurrent_leaves(execute_transaction_message:)
+      ->(transaction_plan) {
+        # Traversal spawns every leaf's thread on the way down and returns a tree of thunks;
+        # resolving them afterwards is what joins the threads, so all leaves are already in
+        # flight before the first one is waited on.
+        result = concurrent_executor_traverse(transaction_plan, execute_transaction_message).call
+
+        cause = executor_find_error(result)
+        if cause
+          err = SolanaError.new(
+            SolanaError::INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN,
+            { cause: cause }
+          )
+          err.instance_variable_set(:@transaction_plan_result, result)
+          err.define_singleton_method(:transaction_plan_result) { result }
+          Kernel.raise err
+        end
+
+        result
+      }
+    end
+
     # ── Private helpers ────────────────────────────────────────────────────────
 
-    module_function
+    extend self
 
     sig { params(plan: T.untyped, execute_fn: T.untyped, state: T.untyped).returns(T.untyped) }
 
@@ -145,6 +196,58 @@ module Solana::Ruby::Kit
       returned
     end
 
+    # Returns a thunk that resolves to this plan's result. Leaf threads are started as the
+    # tree is walked, so the whole plan is in flight by the time the outermost thunk is called.
+    sig { params(plan: T.untyped, execute_fn: T.untyped).returns(T.untyped) }
+
+    def concurrent_executor_traverse(plan, execute_fn)
+      case plan.kind
+      when :single
+        thread = Thread.new { concurrent_executor_execute_single(plan, execute_fn) }
+        -> { thread.value }
+      when :sequential, :parallel
+        thunks = plan.plans.map { |sub| concurrent_executor_traverse(sub, execute_fn) }
+        Kernel.lambda do
+          results = thunks.map(&:call)
+          if plan.kind == :parallel
+            parallel_transaction_plan_result(results)
+          elsif plan.divisible
+            sequential_transaction_plan_result(results)
+          else
+            # Unlike the sequential executor, non-divisible plans are supported: nothing
+            # about running every leaf independently depends on the plan being divisible.
+            non_divisible_sequential_transaction_plan_result(results)
+          end
+        end
+      else
+        Kernel.raise SolanaError.new(
+          SolanaError::INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND,
+          { kind: plan.kind }
+        )
+      end
+    end
+
+    # Runs one leaf. Identical to +executor_traverse_single+ except that a failure is recorded
+    # and nothing else — there is no shared cancellation state for it to trip.
+    sig { params(plan: T.untyped, execute_fn: T.untyped).returns(T.untyped) }
+
+    def concurrent_executor_execute_single(plan, execute_fn)
+      context = {}
+
+      begin
+        returned = executor_invoke(execute_fn, context, plan.message)
+        successful_single_transaction_plan_result(plan.message, nil, context.merge(returned))
+      rescue SolanaError => e
+        failed_single_transaction_plan_result(plan.message, e, context)
+      rescue => e
+        wrapped = SolanaError.new(
+          SolanaError::INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN,
+          { cause: e }
+        )
+        failed_single_transaction_plan_result(plan.message, wrapped, context)
+      end
+    end
+
     sig { params(result: T.untyped).returns(T.untyped) }
 
     def executor_find_error(result)
@@ -164,5 +267,7 @@ module Solana::Ruby::Kit
     private_class_method :executor_traverse_single
     private_class_method :executor_invoke
     private_class_method :executor_find_error
+    private_class_method :concurrent_executor_traverse
+    private_class_method :concurrent_executor_execute_single
   end
 end

data/lib/solana/ruby/kit/instruction_plans/transaction_plan_result.rb

@@ -74,7 +74,7 @@ module Solana::Ruby::Kit
       def kind = :parallel
     end
 
-    module_function
+    extend self
 
     # ── Result factory helpers ────────────────────────────────────────────────
 

data/lib/solana/ruby/kit/instruction_plans/transaction_planner.rb

@@ -11,7 +11,7 @@ module Solana::Ruby::Kit
   module InstructionPlans
     extend T::Sig
 
-    module_function
+    extend self
 
     # Creates a TransactionPlanner — a callable that converts an InstructionPlan
     # into a TransactionPlan by packing instructions into transaction messages.
@@ -71,7 +71,7 @@ module Solana::Ruby::Kit
 
     # ── Private helpers ────────────────────────────────────────────────────────
 
-    module_function
+    extend self
 
     sig { params(plan: T.untyped, ctx: T.untyped).returns(T.untyped) }
 

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

@@ -19,7 +19,7 @@ module Solana::Ruby::Kit
 
     # AccountMeta subtypes — mirrors the four TypeScript convenience types.
 
-    module_function
+    extend self
 
     # Creates a read-only account reference.
     sig { params(address: Addresses::Address).returns(AccountMeta) }

data/lib/solana/ruby/kit/instructions/instruction.rb

@@ -18,7 +18,7 @@ module Solana::Ruby::Kit
       const :data,            T.nilable(String)  # binary String (Uint8Array equivalent)
     end
 
-    module_function
+    extend self
 
     # Returns true if the instruction targets the given program address.
     # Mirrors `isInstructionForProgram()`.

data/lib/solana/ruby/kit/instructions/roles.rb

@@ -19,7 +19,7 @@ module Solana::Ruby::Kit
 
       ALL = T.let([READONLY, WRITABLE, READONLY_SIGNER, WRITABLE_SIGNER].freeze, T::Array[Integer])
 
-      module_function
+      extend self
 
       # Returns true if the role requires the account to sign the transaction.
       sig { params(role: Integer).returns(T::Boolean) }

data/lib/solana/ruby/kit/keys/key_pair.rb

@@ -24,7 +24,7 @@ module Solana::Ruby::Kit
       const :verify_key,  T.untyped  # RbNaCl::VerifyKey
     end
 
-    module_function
+    extend self
 
     # Generates a fresh Ed25519 key pair using a cryptographically secure RNG.
     # Mirrors `generateKeyPair()` in TypeScript.

data/lib/solana/ruby/kit/keys/private_key.rb

@@ -7,7 +7,7 @@ require_relative '../errors'
 module Solana::Ruby::Kit
   module Keys
     extend T::Sig
-    module_function
+    extend self
 
     # Creates an Ed25519 signing key from a raw 32-byte private key seed.
     #

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

@@ -7,7 +7,7 @@ require_relative '../errors'
 module Solana::Ruby::Kit
   module Keys
     extend T::Sig
-    module_function
+    extend self
 
     # Derives the Ed25519 verification (public) key from a signing (private) key.
     #

data/lib/solana/ruby/kit/keys/signatures.rb

@@ -60,7 +60,7 @@ module Solana::Ruby::Kit
     SIGNATURE_MIN_STR_LEN = 64
     SIGNATURE_MAX_STR_LEN = 88
 
-    module_function
+    extend self
 
     # Returns true if the string is a valid base58-encoded Ed25519 signature.
     # Mirrors `isSignature()` in TypeScript.

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

@@ -15,7 +15,7 @@ module Solana::Ruby::Kit
 
       MAGIC = T.let("\xFF\xFF".b.freeze, String)
 
-      module_function
+      extend self
 
       # Serialize a Message to its canonical binary form.
       sig { params(msg: Message).returns(String) }

data/lib/solana/ruby/kit/offchain_messages/message_v1.rb

@@ -36,7 +36,7 @@ module Solana::Ruby::Kit
       def version = 1
     end
 
-    module_function
+    extend self
 
     # Asserts that a version 1 offchain message received from an untrusted source is the
     # message it was expected to be.

data/lib/solana/ruby/kit/options/option.rb

@@ -57,7 +57,7 @@ module Solana::Ruby::Kit
     #   accepts Option<T>, T, or nil — useful for codec input.
     OptionOrNullable = T.type_alias { T.untyped }
 
-    module_function
+    extend self
 
     # Wraps a value in Some.  Mirrors `some<T>(value)`.
     sig { params(value: T.untyped).returns(Solana::Ruby::Kit::Options::Some[T.untyped]) }

data/lib/solana/ruby/kit/plugin_core.rb

@@ -48,7 +48,7 @@ module Solana::Ruby::Kit
   module PluginCore
     extend T::Sig
 
-    module_function
+    extend self
 
     sig { returns(PluginClient) }
     def create_client

data/lib/solana/ruby/kit/programs/associated_token_account.rb

@@ -47,7 +47,7 @@ module Solana::Ruby::Kit
         Addresses::Address
       )
 
-      module_function
+      extend self
 
       # Derives the canonical Associated Token Account address (a PDA) for a
       # given wallet and mint.

data/lib/solana/ruby/kit/programs/stake_program.rb

@@ -40,7 +40,7 @@ module Solana::Ruby::Kit
       DISCRIMINATOR_INITIALIZE    = T.let(0, Integer)
       DISCRIMINATOR_DELEGATE      = T.let(2, Integer)
 
-      module_function
+      extend self
 
       # Builds the two instructions needed to create and initialise a new stake
       # account funded from +from+.

data/lib/solana/ruby/kit/programs/system_program.rb

@@ -27,7 +27,7 @@ module Solana::Ruby::Kit
       # Instruction discriminators (u32 little-endian).
       DISCRIMINATOR_TRANSFER = T.let(2, Integer)
 
-      module_function
+      extend self
 
       # Builds a System Program Transfer instruction that moves +lamports+ from
       # +sender+ to +recipient+.

data/lib/solana/ruby/kit/programs.rb

@@ -13,7 +13,7 @@ module Solana::Ruby::Kit
   module Programs
     extend T::Sig
 
-    module_function
+    extend self
 
     # Returns true when +err+ is a custom program error, optionally matching
     # a specific error code.

data/lib/solana/ruby/kit/promises.rb

@@ -10,7 +10,7 @@ module Solana::Ruby::Kit
   module Promises
     extend T::Sig
 
-    module_function
+    extend self
 
     # Run each callable in a dedicated thread and return the first result.
     # All losing threads are killed to avoid memory leaks — analogous to the

data/lib/solana/ruby/kit/resource_limit_estimation.rb

@@ -19,7 +19,7 @@ module Solana::Ruby::Kit
 
     PROVISORY_LIMIT = T.let(0, Integer)
 
-    module_function
+    extend self
 
     # Returns a callable that estimates the resource limits required by a transaction message
     # by simulating it with maximum limits set, then reading back the actual consumption.