solana-ruby-kit 0.1.7 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a6261831e387559dd450f4da24966c5fb21a3d6d079eca64bc1c19577f1517c
-  data.tar.gz: bb79df5d4217eb20f8fc07b9ae89e6ce070fbcb38f193b4e775d38b1cfe72998
+  metadata.gz: 1d26df33c1471059cde38ac46ec2604e0c26ffc8d64c580de4171396516530fd
+  data.tar.gz: dba1b05e818b10e8fa7692f6ae4af89c3946bcd19707be52cfdfd1c503e81b63
 SHA512:
-  metadata.gz: 6259e78a36520927779d1912d3cd2190690b207fdb538473ed2eabc47e153f9e16380570043087ff94aba46019ef66c5be25383f237f82ad21949cccdb6200c9
-  data.tar.gz: 9155affe61d202d5e9847b9df5da10958ee85089410cf0bd2f856b77087710d38b3318c3c178057fa9112cfee16d5bb85f51b3d9ae36bfcfce1c01b351f04a00
+  metadata.gz: 56674f680f3059cd3247591fe2a14f303853b8806e251f4c147de90fb4ff7ebcea498394a2650aab40089d3cb5e52b10686cd3c5797e171c230a21ef05602eb3
+  data.tar.gz: b57dd91be86b034b1a207c809a04c38ca045700f608e4481ac125536d546f21f68e796f01930259a5054ea5ecf72f020f9260d4b63f6661dd177525c32ab924d

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

@@ -46,6 +46,10 @@ module Solana::Ruby::Kit
 
     # ── Transactions ──────────────────────────────────────────────────────────
     TRANSACTIONS__TRANSACTION_NOT_SIGNABLE               = :SOLANA_ERROR__TRANSACTIONS__TRANSACTION_NOT_SIGNABLE
+    TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT        = :SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT
+    TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT = :SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT
+    TRANSACTION__FAILED_TO_ESTIMATE_LOADED_ACCOUNTS_DATA_SIZE_LIMIT = :SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_LOADED_ACCOUNTS_DATA_SIZE_LIMIT
+    TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_RESOURCE_LIMITS = :SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_RESOURCE_LIMITS
     TRANSACTIONS__EXCEEDS_SIZE_LIMIT                     = :SOLANA_ERROR__TRANSACTION__EXCEEDS_SIZE_LIMIT
     TRANSACTIONS__MISSING_SIGNER                         = :SOLANA_ERROR__TRANSACTIONS__MISSING_SIGNER
     TRANSACTIONS__VERSION_NUMBER_OUT_OF_RANGE            = :SOLANA_ERROR__TRANSACTIONS__VERSION_NUMBER_OUT_OF_RANGE
@@ -88,13 +92,12 @@ module Solana::Ruby::Kit
     RPC__INTEGER_OVERFLOW_WHILE_SERIALIZING_LARGE_INTEGER = :SOLANA_ERROR__RPC__INTEGER_OVERFLOW_WHILE_SERIALIZING_LARGE_INTEGER
     RPC__INTEGER_OVERFLOW_WHILE_DESERIALIZING_LARGE_INTEGER = :SOLANA_ERROR__RPC__INTEGER_OVERFLOW_WHILE_DESERIALIZING_LARGE_INTEGER
     RPC__TRANSPORT_HTTP_ERROR                             = :SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR
-    # JSON-RPC server errors (-32017..-32019); context keys mirror TypeScript SolanaErrorContext:
-    #   EPOCH_REWARDS_PERIOD_ACTIVE: { slot:, current_block_height:, rewards_complete_block_height: }
-    #   SLOT_NOT_EPOCH_BOUNDARY:     { slot: }
-    #   LONG_TERM_STORAGE_UNREACHABLE: (no context)
+    # JSON-RPC server errors (see https://github.com/anza-xyz/kit/blob/main/packages/errors/src/codes.ts)
     JSON_RPC__SERVER_ERROR_EPOCH_REWARDS_PERIOD_ACTIVE    = :SOLANA_ERROR__JSON_RPC__SERVER_ERROR_EPOCH_REWARDS_PERIOD_ACTIVE
     JSON_RPC__SERVER_ERROR_SLOT_NOT_EPOCH_BOUNDARY        = :SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SLOT_NOT_EPOCH_BOUNDARY
     JSON_RPC__SERVER_ERROR_LONG_TERM_STORAGE_UNREACHABLE  = :SOLANA_ERROR__JSON_RPC__SERVER_ERROR_LONG_TERM_STORAGE_UNREACHABLE
+    JSON_RPC__SERVER_ERROR_NO_SLOT_HISTORY                = :SOLANA_ERROR__JSON_RPC__SERVER_ERROR_NO_SLOT_HISTORY
+    JSON_RPC__SERVER_ERROR_FILTER_TRANSACTION_NOT_FOUND   = :SOLANA_ERROR__JSON_RPC__SERVER_ERROR_FILTER_TRANSACTION_NOT_FOUND
     RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_REQUEST = :SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_REQUEST
     RPC_SUBSCRIPTIONS__EXPECTED_SERVER_SUBSCRIPTION_ID   = :SOLANA_ERROR__RPC_SUBSCRIPTIONS__EXPECTED_SERVER_SUBSCRIPTION_ID
     RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED = :SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED
@@ -120,6 +123,12 @@ module Solana::Ruby::Kit
     WALLET_STANDARD__INVALID_WIRE_FORMAT             = :SOLANA_ERROR__WALLET_STANDARD__INVALID_WIRE_FORMAT
     WALLET_STANDARD__SIGNATURE_VERIFICATION_FAILED   = :SOLANA_ERROR__WALLET_STANDARD__SIGNATURE_VERIFICATION_FAILED
 
+    # ── Subscribable ──────────────────────────────────────────────────────────
+    SUBSCRIBABLE__RETRY_NOT_SUPPORTED                     = :SOLANA_ERROR__SUBSCRIBABLE__RETRY_NOT_SUPPORTED
+
+    # ── Fixed-points ──────────────────────────────────────────────────────────
+    FIXED_POINTS__STRICT_MODE_PRECISION_LOSS              = :SOLANA_ERROR__FIXED_POINTS__STRICT_MODE_PRECISION_LOSS
+
     # ── Invariant violations (internal) ──────────────────────────────────────
     INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_STATE_MISSING = :SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_STATE_MISSING
     INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE = :SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE
@@ -166,6 +175,10 @@ module Solana::Ruby::Kit
 
         # Transactions
         TRANSACTIONS__TRANSACTION_NOT_SIGNABLE           => 'Transaction is not signable (missing fee payer or lifetime constraint)',
+        TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT    => 'Failed to estimate the compute unit consumption for this transaction message. This is likely because simulating the transaction failed.',
+        TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT => 'Transaction failed when it was simulated in order to estimate the compute unit consumption.',
+        TRANSACTION__FAILED_TO_ESTIMATE_LOADED_ACCOUNTS_DATA_SIZE_LIMIT => 'Failed to estimate the loaded accounts data size for this transaction message. The RPC did not return a loadedAccountsDataSize value from simulation. This value is required for version 1 transactions.',
+        TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_RESOURCE_LIMITS => 'Transaction failed when it was simulated in order to estimate its resource limits.',
         TRANSACTIONS__EXCEEDS_SIZE_LIMIT                 => 'Transaction wire size (%{actual_size} bytes) exceeds the limit of %{limit} bytes',
         TRANSACTIONS__MISSING_SIGNER                     => 'Transaction is missing a required signer: %{address}',
         TRANSACTIONS__VERSION_NUMBER_OUT_OF_RANGE        => 'Transaction version %{version} is out of range',
@@ -211,6 +224,8 @@ module Solana::Ruby::Kit
         JSON_RPC__SERVER_ERROR_EPOCH_REWARDS_PERIOD_ACTIVE      => 'Epoch rewards period still active at slot %{slot}',
         JSON_RPC__SERVER_ERROR_SLOT_NOT_EPOCH_BOUNDARY          => "Rewards cannot be found because slot %{slot} is not the epoch boundary. This may be due to gap in the queried node's local ledger or long-term storage",
         JSON_RPC__SERVER_ERROR_LONG_TERM_STORAGE_UNREACHABLE    => 'Failed to query long-term storage; please try again',
+        JSON_RPC__SERVER_ERROR_NO_SLOT_HISTORY                  => 'No slot history',
+        JSON_RPC__SERVER_ERROR_FILTER_TRANSACTION_NOT_FOUND     => 'Filter transaction not found',
         RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_REQUEST  => 'Cannot create subscription request',
         RPC_SUBSCRIPTIONS__EXPECTED_SERVER_SUBSCRIPTION_ID     => 'Expected server to return a subscription ID',
         RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED => 'WebSocket channel closed before message could be buffered',
@@ -231,6 +246,12 @@ module Solana::Ruby::Kit
         INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN             => 'Instruction plan is empty and produced no transaction messages',
         INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN => 'Failed to execute transaction plan',
 
+        # Subscribable
+        SUBSCRIBABLE__RETRY_NOT_SUPPORTED              => 'This reactive store does not support retry(); use create_reactive_store_from_data_publisher_factory for a retryable store',
+
+        # Fixed-points
+        FIXED_POINTS__STRICT_MODE_PRECISION_LOSS       => 'Value has more than 9 fractional digits and cannot be represented exactly as a Sol amount',
+
         # Wallet Standard
         WALLET_STANDARD__INVALID_WIRE_FORMAT           => 'Invalid transaction wire format: %{reason}',
         WALLET_STANDARD__SIGNATURE_VERIFICATION_FAILED => 'Signature verification failed for signer %{address}',

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

@@ -0,0 +1,156 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'base64'
+require_relative 'errors'
+require_relative 'functional'
+require_relative 'transaction_messages'
+require_relative 'transaction_messages/compute_budget'
+require_relative 'transactions'
+
+module Solana::Ruby::Kit
+  # Utilities for estimating and setting transaction resource limits (compute units and
+  # loaded accounts data size) via simulation.
+  #
+  # Mirrors `estimateResourceLimitsFactory`, `estimateAndSetResourceLimitsFactory`,
+  # and `fillTransactionMessageProvisoryResourceLimits` from @solana/kit.
+  module ResourceLimitEstimation
+    extend T::Sig
+
+    PROVISORY_LIMIT = T.let(0, Integer)
+
+    module_function
+
+    # 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.
+    #
+    # The returned callable accepts a TransactionMessage and optional keyword args:
+    #   commitment:        Symbol (nil uses RPC default)
+    #   min_context_slot:  Integer
+    #
+    # Returns a Hash with:
+    #   :compute_unit_limit              Integer (always present)
+    #   :loaded_accounts_data_size_limit Integer (present when the RPC returns it)
+    #
+    # Raises SolanaError with TRANSACTION__FAILED_TO_ESTIMATE_LOADED_ACCOUNTS_DATA_SIZE_LIMIT
+    # if the message is version 1 but the RPC does not return loadedAccountsDataSize.
+    # Raises SolanaError with TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_RESOURCE_LIMITS
+    # if the simulated transaction itself fails.
+    # Raises SolanaError with TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT for any other error.
+    #
+    # Mirrors `estimateResourceLimitsFactory({ rpc })` from @solana/kit.
+    sig { params(rpc: T.untyped).returns(T.untyped) }
+    def estimate_resource_limits_factory(rpc:)
+      ->(transaction_message, commitment: nil, min_context_slot: nil) do
+        replace_recent_blockhash = !TransactionMessages.durable_nonce_lifetime?(transaction_message)
+        is_v1 = transaction_message.version == 1
+
+        tx_for_sim = Functional.pipe(
+          transaction_message,
+          ->(m) { TransactionMessages.set_transaction_message_compute_unit_limit(TransactionMessages::MAX_COMPUTE_UNIT_LIMIT, m) },
+          ->(m) { is_v1 ? TransactionMessages.set_transaction_message_loaded_accounts_data_size_limit(TransactionMessages::MAX_LOADED_ACCOUNTS_DATA_SIZE_LIMIT, m) : m }
+        )
+
+        transaction = Transactions.compile_transaction_message(tx_for_sim)
+        wire_bytes  = Transactions.wire_encode_transaction(transaction)
+        encoded     = Base64.strict_encode64(wire_bytes)
+
+        sim_opts = { replace_recent_blockhash: replace_recent_blockhash }
+        sim_opts[:commitment]       = commitment       if commitment
+        sim_opts[:min_context_slot] = min_context_slot if min_context_slot
+
+        begin
+          sim_value = rpc.simulate_transaction(encoded, **sim_opts).value
+
+          transaction_error         = sim_value['err']
+          units_consumed            = sim_value['unitsConsumed']
+          loaded_accounts_data_size = sim_value['loadedAccountsDataSize']
+
+          if is_v1 && loaded_accounts_data_size.nil?
+            Kernel.raise SolanaError.new(SolanaError::TRANSACTION__FAILED_TO_ESTIMATE_LOADED_ACCOUNTS_DATA_SIZE_LIMIT)
+          end
+
+          if transaction_error
+            Kernel.raise SolanaError.new(
+              SolanaError::TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_RESOURCE_LIMITS
+            )
+          end
+
+          compute_unit_limit = [units_consumed.to_i, 4_294_967_295].min
+
+          estimate = { compute_unit_limit: compute_unit_limit }
+          estimate[:loaded_accounts_data_size_limit] = loaded_accounts_data_size.to_i unless loaded_accounts_data_size.nil?
+          estimate
+        rescue SolanaError => e
+          known = [
+            SolanaError::TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_RESOURCE_LIMITS,
+            SolanaError::TRANSACTION__FAILED_TO_ESTIMATE_LOADED_ACCOUNTS_DATA_SIZE_LIMIT
+          ]
+          Kernel.raise if known.include?(e.code)
+          Kernel.raise SolanaError.new(SolanaError::TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT)
+        rescue StandardError
+          Kernel.raise SolanaError.new(SolanaError::TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT)
+        end
+      end
+    end
+
+    # Returns a callable that estimates resource limits for a transaction message and
+    # sets them on the message, unless they are already explicitly configured.
+    #
+    # A limit of 0 (the provisory value) or the maximum (1,400,000 for CU) is treated
+    # as non-explicit and will be replaced with the estimate.
+    #
+    # Mirrors `estimateAndSetResourceLimitsFactory(estimator)` from @solana/kit.
+    sig { params(estimate_resource_limits: T.untyped).returns(T.untyped) }
+    def estimate_and_set_resource_limits_factory(estimate_resource_limits)
+      ->(transaction_message, **opts) do
+        existing_cu = TransactionMessages.get_transaction_message_compute_unit_limit(transaction_message)
+        cu_explicit = !existing_cu.nil? &&
+                      existing_cu != PROVISORY_LIMIT &&
+                      existing_cu != TransactionMessages::MAX_COMPUTE_UNIT_LIMIT
+
+        is_v1 = transaction_message.version == 1
+        loaded_explicit = true
+        if is_v1
+          existing_loaded = TransactionMessages.get_transaction_message_loaded_accounts_data_size_limit(transaction_message)
+          loaded_explicit = !existing_loaded.nil? && existing_loaded != PROVISORY_LIMIT
+        end
+
+        return transaction_message if cu_explicit && loaded_explicit
+
+        estimate = estimate_resource_limits.call(transaction_message, **opts)
+
+        result = transaction_message
+        unless cu_explicit
+          result = TransactionMessages.set_transaction_message_compute_unit_limit(estimate[:compute_unit_limit], result)
+        end
+        if is_v1 && !loaded_explicit && estimate.key?(:loaded_accounts_data_size_limit)
+          result = TransactionMessages.set_transaction_message_loaded_accounts_data_size_limit(estimate[:loaded_accounts_data_size_limit], result)
+        end
+        result
+      end
+    end
+
+    # Sets compute unit limit (and, for V1, loaded accounts data size limit) to the
+    # provisory value of 0 on the message, unless a limit is already present.
+    #
+    # Use this during message construction to reserve space for limits that will later
+    # be replaced with actual estimates via `estimate_and_set_resource_limits_factory`.
+    #
+    # Mirrors `fillTransactionMessageProvisoryResourceLimits` from @solana/kit.
+    sig do
+      params(message: TransactionMessages::TransactionMessage)
+        .returns(TransactionMessages::TransactionMessage)
+    end
+    def fill_transaction_message_provisory_resource_limits(message)
+      result = message
+      if TransactionMessages.get_transaction_message_compute_unit_limit(result).nil?
+        result = TransactionMessages.set_transaction_message_compute_unit_limit(PROVISORY_LIMIT, result)
+      end
+      if result.version == 1 && TransactionMessages.get_transaction_message_loaded_accounts_data_size_limit(result).nil?
+        result = TransactionMessages.set_transaction_message_loaded_accounts_data_size_limit(PROVISORY_LIMIT, result)
+      end
+      result
+    end
+  end
+end

data/lib/solana/ruby/kit/rpc/api/get_block_time.rb

@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Solana::Ruby::Kit
+  module Rpc
+    module Api
+      # Returns the estimated production time of a block.
+      # Mirrors TypeScript's GetBlockTimeApi.getBlockTime.
+      module GetBlockTime
+        extend T::Sig
+
+        sig { params(slot: Integer).returns(T.nilable(Integer)) }
+        def get_block_time(slot)
+          raw = transport.request('getBlockTime', [slot])
+          raw.nil? ? nil : Kernel.Integer(raw)
+        end
+      end
+    end
+  end
+end

data/lib/solana/ruby/kit/rpc/api/get_epoch_schedule.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Solana::Ruby::Kit
+  module Rpc
+    module Api
+      # Struct returned by get_epoch_schedule.
+      EpochSchedule = T.let(
+        Struct.new(
+          :first_normal_epoch,        # Integer — first full-length epoch after warmup
+          :first_normal_slot,         # Integer — first slot after warmup period
+          :leader_schedule_slot_offset, # Integer — slots before epoch to compute leader schedule
+          :slots_per_epoch,           # Integer — max slots per epoch
+          :warmup,                    # Boolean — whether epochs start short and grow
+          keyword_init: true
+        ),
+        T.untyped
+      )
+
+      # Returns the epoch schedule from the cluster's genesis config.
+      # Mirrors TypeScript's GetEpochScheduleApi.getEpochSchedule.
+      module GetEpochSchedule
+        extend T::Sig
+
+        sig { returns(T.untyped) }
+        def get_epoch_schedule
+          raw = transport.request('getEpochSchedule', [])
+
+          EpochSchedule.new(
+            first_normal_epoch:           Kernel.Integer(raw['firstNormalEpoch']),
+            first_normal_slot:            Kernel.Integer(raw['firstNormalSlot']),
+            leader_schedule_slot_offset:  Kernel.Integer(raw['leaderScheduleSlotOffset']),
+            slots_per_epoch:              Kernel.Integer(raw['slotsPerEpoch']),
+            warmup:                       raw['warmup'] == true
+          )
+        end
+      end
+    end
+  end
+end

data/lib/solana/ruby/kit/rpc/api/get_inflation_reward.rb

@@ -0,0 +1,59 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Solana::Ruby::Kit
+  module Rpc
+    module Api
+      # Struct for a single entry in the getInflationReward response.
+      # nil entries indicate the address was not found or had no reward.
+      InflationReward = T.let(
+        Struct.new(
+          :amount,         # Integer (Lamports) — reward credited
+          :commission,     # Integer — vote account commission at reward time
+          :effective_slot, # Integer — slot in which rewards were delivered
+          :epoch,          # Integer — epoch for which reward occurred
+          :post_balance,   # Integer (Lamports) — post-reward account balance
+          keyword_init: true
+        ),
+        T.untyped
+      )
+
+      # Returns the inflation/staking reward for a list of addresses for an epoch.
+      # Mirrors TypeScript's GetInflationRewardApi.getInflationReward.
+      module GetInflationReward
+        extend T::Sig
+
+        sig do
+          params(
+            addresses:        T::Array[T.untyped],
+            commitment:       T.nilable(Symbol),
+            epoch:            T.nilable(Integer),
+            min_context_slot: T.nilable(Integer)
+          ).returns(T::Array[T.nilable(T.untyped)])
+        end
+        def get_inflation_reward(addresses, commitment: nil, epoch: nil, min_context_slot: nil)
+          addr_strings = addresses.map { |a| a.respond_to?(:value) ? a.value : a.to_s }
+          config = {}
+          config['commitment']      = commitment.to_s if commitment
+          config['epoch']           = epoch           if epoch
+          config['minContextSlot']  = min_context_slot if min_context_slot
+
+          params = config.empty? ? [addr_strings] : [addr_strings, config]
+          raw_list = transport.request('getInflationReward', params)
+
+          raw_list.map do |entry|
+            next nil if entry.nil?
+
+            InflationReward.new(
+              amount:         Kernel.Integer(entry['amount']),
+              commission:     Kernel.Integer(entry['commission']),
+              effective_slot: Kernel.Integer(entry['effectiveSlot']),
+              epoch:          Kernel.Integer(entry['epoch']),
+              post_balance:   Kernel.Integer(entry['postBalance'])
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solana/ruby/kit/rpc/api/get_signatures_for_address.rb

@@ -0,0 +1,72 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Solana::Ruby::Kit
+  module Rpc
+    module Api
+      # Struct representing one transaction signature entry returned by getSignaturesForAddress.
+      # Mirrors TypeScript's GetSignaturesForAddressTransaction.
+      SignatureInfo = T.let(
+        Struct.new(
+          :block_time,         # Integer | nil — Unix timestamp of block production, nil if unavailable
+          :confirmation_status, # Symbol | nil — :processed, :confirmed, or :finalized
+          :err,                # Hash | nil — transaction error, nil if succeeded
+          :memo,               # String | nil — memo associated with the transaction
+          :signature,          # String — base-58 encoded transaction signature
+          :slot,               # Integer — slot containing the transaction
+          :transaction_index,  # Integer | nil — 0-based index within block (Agave 4.0+)
+          keyword_init: true
+        ),
+        T.untyped
+      )
+
+      # Returns confirmed transaction signatures that reference the given address.
+      # Mirrors TypeScript's GetSignaturesForAddressApi.getSignaturesForAddress.
+      # See https://solana.com/docs/rpc/http/getsignaturesforaddress
+      module GetSignaturesForAddress
+        extend T::Sig
+
+        sig do
+          params(
+            address:          String,
+            before:           T.nilable(String),
+            until_sig:        T.nilable(String),
+            limit:            T.nilable(Integer),
+            commitment:       T.nilable(Symbol),
+            min_context_slot: T.nilable(Integer)
+          ).returns(T::Array[T.untyped])
+        end
+        def get_signatures_for_address(
+          address,
+          before:           nil,
+          until_sig:        nil,
+          limit:            nil,
+          commitment:       nil,
+          min_context_slot: nil
+        )
+          config = {}
+          config['before']           = before if before
+          config['until']            = until_sig if until_sig
+          config['limit']            = limit if limit
+          config['commitment']       = commitment.to_s if commitment
+          config['minContextSlot']   = min_context_slot if min_context_slot
+
+          params = config.empty? ? [address] : [address, config]
+          result = transport.request('getSignaturesForAddress', params)
+
+          result.map do |tx|
+            SignatureInfo.new(
+              block_time:          tx['blockTime'],
+              confirmation_status: tx['confirmationStatus']&.to_sym,
+              err:                 tx['err'],
+              memo:                tx['memo'],
+              signature:           tx['signature'],
+              slot:                Kernel.Integer(tx['slot']),
+              transaction_index:   tx['transactionIndex']
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solana/ruby/kit/rpc/client.rb

@@ -20,6 +20,10 @@ require_relative 'api/get_token_accounts_by_owner'
 require_relative 'api/get_epoch_info'
 require_relative 'api/get_vote_accounts'
 require_relative 'api/simulate_transaction'
+require_relative 'api/get_block_time'
+require_relative 'api/get_epoch_schedule'
+require_relative 'api/get_inflation_reward'
+require_relative 'api/get_signatures_for_address'
 
 module Solana::Ruby::Kit
   module Rpc
@@ -56,6 +60,10 @@ module Solana::Ruby::Kit
       include Api::GetEpochInfo
       include Api::GetVoteAccounts
       include Api::SimulateTransaction
+      include Api::GetBlockTime
+      include Api::GetEpochSchedule
+      include Api::GetInflationReward
+      include Api::GetSignaturesForAddress
 
       sig { returns(Transport) }
       attr_reader :transport

data/lib/solana/ruby/kit/rpc/transport.rb

@@ -117,10 +117,9 @@ module Solana::Ruby::Kit
         http.open_timeout = @open_timeout
 
         req = Net::HTTP::Post.new(T.cast(@uri, URI::HTTP).request_uri)
-        req['Content-Type']   = 'application/json; charset=utf-8'
-        req['Accept']         = 'application/json'
-        req['Content-Length'] = body.bytesize.to_s
-        req['solana-client']  = 'ruby-kit'
+        req['Content-Type']  = 'application/json; charset=utf-8'
+        req['Accept']        = 'application/json'
+        req['solana-client'] = 'ruby-kit'
         @headers.each { |k, v| req[k] = v }
         req.body = body
 

data/lib/solana/ruby/kit/rpc_types/sol.rb

@@ -0,0 +1,102 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require_relative '../errors'
+require_relative 'lamports'
+
+module Solana::Ruby::Kit
+  module RpcTypes
+    # SOL amounts expressed as a decimal fixed-point value with 9 decimal places.
+    # 1 SOL == 1_000_000_000 lamports, so Sol#raw is the exact Lamports count.
+    #
+    # Mirrors TypeScript's Sol (DecimalFixedPoint<'unsigned', 64, 9>).
+    class Sol
+      extend T::Sig
+
+      # The Lamports count as an unsigned integer (u64 range).
+      sig { returns(Integer) }
+      attr_reader :raw
+
+      sig { params(raw: Integer).void }
+      def initialize(raw)
+        @raw = T.let(raw, Integer)
+        freeze
+      end
+
+      # Returns the decimal string representation (e.g. "1.5", "0.000000001").
+      sig { returns(String) }
+      def to_s
+        whole    = @raw / 10**9
+        fraction = @raw % 10**9
+        return whole.to_s if fraction.zero?
+
+        frac_str = fraction.to_s.rjust(9, '0').sub(/0+\z/, '')
+        "#{whole}.#{frac_str}"
+      end
+
+      sig { returns(String) }
+      def inspect = "#<#{self.class} #{self}>"
+
+      sig { params(other: T.untyped).returns(T::Boolean) }
+      def ==(other)
+        other.is_a?(Sol) && @raw == other.raw
+      end
+
+      sig { returns(Integer) }
+      def hash = @raw.hash
+
+      alias eql? ==
+    end
+
+    SOL_DECIMALS    = T.let(9,         Integer)
+    SOL_SCALE       = T.let(10**9,     Integer)
+    SOL_RAW_MAX     = T.let(2**64 - 1, Integer)
+
+    module_function
+
+    # Parses a decimal string and returns a Sol value.
+    # Raises FIXED_POINTS__STRICT_MODE_PRECISION_LOSS if the string has more
+    # than 9 fractional digits (mirrors TypeScript's default 'strict' mode).
+    #
+    # Examples:
+    #   sol('1.5')           # => Sol(raw: 1_500_000_000)
+    #   sol('0.000000001')   # => Sol(raw: 1) — one lamport
+    #
+    # Mirrors TypeScript's sol(value, rounding?).
+    sig { params(value: String).returns(Sol) }
+    def sol(value)
+      bd = BigDecimal(value)
+      Kernel.raise SolanaError.new(SolanaError::FIXED_POINTS__STRICT_MODE_PRECISION_LOSS) if bd < 0
+
+      scaled = bd * SOL_SCALE
+      raw    = scaled.to_i
+
+      unless scaled == BigDecimal(raw.to_s)
+        Kernel.raise SolanaError.new(SolanaError::FIXED_POINTS__STRICT_MODE_PRECISION_LOSS)
+      end
+
+      Kernel.raise SolanaError.new(SolanaError::SOLANA_ERROR__LAMPORTS_OUT_OF_RANGE) if raw > SOL_RAW_MAX
+
+      Sol.new(raw)
+    end
+
+    # Converts a Sol value to its equivalent Lamports integer.
+    # The conversion is exact — Sol#raw is the Lamports count.
+    #
+    # Mirrors TypeScript's solToLamports(value).
+    sig { params(value: Sol).returns(Lamports) }
+    def sol_to_lamports(value)
+      value.raw
+    end
+
+    # Converts a Lamports integer to its equivalent Sol value.
+    # The conversion is exact.
+    #
+    # Mirrors TypeScript's lamportsToSol(value).
+    sig { params(value: Lamports).returns(Sol) }
+    def lamports_to_sol(value)
+      Sol.new(value)
+    end
+  end
+end

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

@@ -4,5 +4,6 @@
 # Core RPC type definitions — mirrors @solana/rpc-types.
 require_relative 'rpc_types/commitment'
 require_relative 'rpc_types/lamports'
+require_relative 'rpc_types/sol'
 require_relative 'rpc_types/cluster_url'
 require_relative 'rpc_types/account_info'

data/lib/solana/ruby/kit/subscribable/reactive_action_store.rb

@@ -0,0 +1,207 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Solana::Ruby::Kit
+  module Subscribable
+    extend T::Sig
+
+    # Lifecycle status of a ReactiveActionStore.
+    # Mirrors TypeScript's ReactiveActionStatus.
+    ReactiveActionStatus = T.type_alias { String } # 'idle' | 'running' | 'success' | 'error'
+
+    # Lifecycle snapshot of a ReactiveActionStore.
+    # `data` persists across running/error states so callers can render stale
+    # content while a retry is in flight; only reset() clears it.
+    #
+    # Mirrors TypeScript's ReactiveActionState<TResult>.
+    class ReactiveActionState
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :status
+
+      sig { returns(T.untyped) }
+      attr_reader :data
+
+      sig { returns(T.untyped) }
+      attr_reader :error
+
+      sig { params(status: String, data: T.untyped, error: T.untyped).void }
+      def initialize(status:, data: nil, error: nil)
+        @status = T.let(status, String)
+        @data   = T.let(data,   T.untyped)
+        @error  = T.let(error,  T.untyped)
+        freeze
+      end
+
+      sig { params(other: T.untyped).returns(T::Boolean) }
+      def ==(other)
+        other.is_a?(ReactiveActionState) &&
+          @status == other.status &&
+          @data.equal?(other.data) &&
+          @error.equal?(other.error)
+      end
+    end
+
+    REACTIVE_ACTION_IDLE_STATE = T.let(
+      ReactiveActionState.new(status: 'idle').freeze,
+      ReactiveActionState
+    )
+
+    # A thread-safe state machine wrapping a callable. Exposes
+    #   dispatch / dispatch_async / get_state / subscribe / reset
+    # so that observers can react to in-flight, succeeded, or failed calls.
+    #
+    # dispatch     — fire-and-forget; runs the callable in a background thread.
+    # dispatch_async — blocking; runs the callable in the current thread and
+    #                 returns the result (or raises on failure / supersession).
+    #
+    # Only the most recent dispatch can mutate state — superseded calls silently
+    # drop their result via a generation counter.
+    #
+    # Mirrors TypeScript's ReactiveActionStore<TArgs, TResult>.
+    class ReactiveActionStore
+      extend T::Sig
+
+      sig { params(fn: T.proc.params(args: T.untyped).returns(T.untyped)).void }
+      def initialize(fn)
+        @fn          = T.let(fn,   T.proc.params(args: T.untyped).returns(T.untyped))
+        @state       = T.let(REACTIVE_ACTION_IDLE_STATE, ReactiveActionState)
+        @listeners   = T.let([], T::Array[T.proc.void])
+        @mutex       = T.let(Mutex.new, Mutex)
+        @current_gen = T.let(0, Integer)
+      end
+
+      # Returns the current lifecycle snapshot.
+      sig { returns(ReactiveActionState) }
+      def get_state
+        @mutex.synchronize { @state }
+      end
+
+      # Fire-and-forget dispatch. Runs fn in a background thread. Only the
+      # most recent call's result updates state; superseded threads are ignored.
+      sig { params(args: T.untyped).void }
+      def dispatch(*args)
+        gen        = nil
+        prev_data  = nil
+        @mutex.synchronize do
+          @current_gen += 1
+          gen       = @current_gen
+          prev_data = @state.data
+          @state    = ReactiveActionState.new(status: 'running', data: prev_data)
+        end
+        _notify
+
+        Thread.new do
+          begin
+            result  = @fn.call(*args)
+            active  = @mutex.synchronize do
+              if @current_gen == gen
+                @state = ReactiveActionState.new(status: 'success', data: result)
+                true
+              else
+                false
+              end
+            end
+            _notify if active
+          rescue => e
+            active = @mutex.synchronize do
+              if @current_gen == gen
+                @state = ReactiveActionState.new(status: 'error', data: prev_data, error: e)
+                true
+              else
+                false
+              end
+            end
+            _notify if active
+          end
+        end
+
+        nil
+      end
+
+      # Blocking dispatch. Runs fn in the current thread. Returns the result on
+      # success. Raises the error on failure. Raises RuntimeError if superseded
+      # by a concurrent dispatch or reset().
+      sig { params(args: T.untyped).returns(T.untyped) }
+      def dispatch_async(*args)
+        gen        = nil
+        prev_data  = nil
+        @mutex.synchronize do
+          @current_gen += 1
+          gen       = @current_gen
+          prev_data = @state.data
+          @state    = ReactiveActionState.new(status: 'running', data: prev_data)
+        end
+        _notify
+
+        result = @fn.call(*args)
+
+        active = @mutex.synchronize do
+          if @current_gen == gen
+            @state = ReactiveActionState.new(status: 'success', data: result)
+            true
+          else
+            false
+          end
+        end
+        _notify if active
+        Kernel.raise 'ReactiveActionStore: call was superseded' unless active
+        result
+      rescue RuntimeError
+        Kernel.raise
+      rescue => e
+        active = @mutex.synchronize do
+          if @current_gen == gen
+            @state = ReactiveActionState.new(status: 'error', data: prev_data, error: e)
+            true
+          else
+            false
+          end
+        end
+        _notify if active
+        Kernel.raise e
+      end
+
+      # Aborts any in-flight background dispatch (by incrementing generation)
+      # and resets state to idle.
+      sig { void }
+      def reset
+        @mutex.synchronize do
+          @current_gen += 1
+          @state = REACTIVE_ACTION_IDLE_STATE
+        end
+        _notify
+      end
+
+      # Registers a listener called on every state change.
+      # Returns an unsubscribe lambda.
+      sig { params(listener: T.proc.void).returns(T.proc.void) }
+      def subscribe(&listener)
+        @mutex.synchronize { @listeners << listener }
+        lambda { @mutex.synchronize { @listeners.delete(listener) } }
+      end
+
+      private
+
+      sig { void }
+      def _notify
+        subs = @mutex.synchronize { @listeners.dup }
+        subs.each(&:call)
+      end
+    end
+
+    module_function
+
+    # Wraps a callable in a ReactiveActionStore.
+    # fn receives the arguments passed to dispatch/dispatch_async.
+    #
+    # Mirrors TypeScript's createReactiveActionStore.
+    sig do
+      params(fn: T.proc.params(args: T.untyped).returns(T.untyped)).returns(ReactiveActionStore)
+    end
+    def create_reactive_action_store(&fn)
+      ReactiveActionStore.new(T.let(fn, T.proc.params(args: T.untyped).returns(T.untyped)))
+    end
+  end
+end

data/lib/solana/ruby/kit/subscribable/reactive_stream_store.rb

@@ -0,0 +1,255 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative '../errors'
+require_relative 'data_publisher'
+
+module Solana::Ruby::Kit
+  module Subscribable
+    extend T::Sig
+
+    # Lifecycle snapshot of a ReactiveStreamStore — a single frozen value
+    # capturing status, last-known data, and any error.
+    #
+    # status values:
+    #   'loading'  — waiting for first value; data is nil
+    #   'loaded'   — value has arrived, no active error
+    #   'error'    — stream failed; data is last known value (may be nil)
+    #   'retrying' — retry in progress after error; data preserved
+    #
+    # Mirrors TypeScript's ReactiveState<T>.
+    class ReactiveState
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :status
+
+      sig { returns(T.untyped) }
+      attr_reader :data
+
+      sig { returns(T.untyped) }
+      attr_reader :error
+
+      sig { params(status: String, data: T.untyped, error: T.untyped).void }
+      def initialize(status:, data: nil, error: nil)
+        @status = T.let(status, String)
+        @data   = T.let(data,   T.untyped)
+        @error  = T.let(error,  T.untyped)
+        freeze
+      end
+
+      sig { params(other: T.untyped).returns(T::Boolean) }
+      def ==(other)
+        other.is_a?(ReactiveState) &&
+          @status == other.status &&
+          @data.equal?(other.data) &&
+          @error.equal?(other.error)
+      end
+    end
+
+    REACTIVE_LOADING_STATE = T.let(
+      ReactiveState.new(status: 'loading').freeze,
+      ReactiveState
+    )
+
+    # Thread-safe store that tracks the latest value published to a data channel
+    # and notifies subscribers on every state change.
+    #
+    # Compatible with any observer pattern that expects a
+    #   { subscribe, get_unified_state } contract.
+    #
+    # Mirrors TypeScript's ReactiveStreamStore<T>.
+    class ReactiveStreamStore
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        @state       = T.let(REACTIVE_LOADING_STATE, ReactiveState)
+        @subscribers = T.let([], T::Array[T.proc.void])
+        @mutex       = T.let(Mutex.new, Mutex)
+      end
+
+      # Returns the current lifecycle snapshot.
+      sig { returns(ReactiveState) }
+      def get_unified_state
+        @mutex.synchronize { @state }
+      end
+
+      # Returns the most recent data value, or nil if no value has arrived yet.
+      # @deprecated Use get_unified_state instead.
+      sig { returns(T.untyped) }
+      def get_state
+        @mutex.synchronize { @state.data }
+      end
+
+      # Returns the current error, or nil if no error has occurred.
+      # @deprecated Use get_unified_state instead.
+      sig { returns(T.untyped) }
+      def get_error
+        @mutex.synchronize { @state.error }
+      end
+
+      # Re-opens the stream after an error. Raises RETRY_NOT_SUPPORTED on
+      # DataPublisher-backed stores — use create_reactive_store_from_data_publisher_factory
+      # for a retryable store.
+      sig { void }
+      def retry
+        Kernel.raise SolanaError.new(SolanaError::SUBSCRIBABLE__RETRY_NOT_SUPPORTED)
+      end
+
+      # Registers a callback invoked on every state change.
+      # Returns an unsubscribe lambda.
+      sig { params(callback: T.proc.void).returns(T.proc.void) }
+      def subscribe(&callback)
+        @mutex.synchronize { @subscribers << callback }
+        lambda { @mutex.synchronize { @subscribers.delete(callback) } }
+      end
+
+      # Internal: transition state and notify all subscribers.
+      sig { params(new_state: ReactiveState).void }
+      def _set_state(new_state)
+        subs = nil
+        @mutex.synchronize do
+          return if @state.equal?(new_state)
+          @state = new_state
+          subs = @subscribers.dup
+        end
+        subs&.each(&:call)
+      end
+    end
+
+    # Deprecated alias — use ReactiveStreamStore.
+    ReactiveStore = ReactiveStreamStore
+
+    # A ReactiveStreamStore that supports retry() by re-invoking a factory proc
+    # to get a fresh DataPublisher on each connection attempt.
+    # Mirrors TypeScript's createReactiveStoreFromDataPublisherFactory result.
+    class RetryableReactiveStreamStore < ReactiveStreamStore
+      extend T::Sig
+
+      sig do
+        params(
+          data_channel:     T.untyped,
+          error_channel:    T.untyped,
+          create_publisher: T.proc.returns(DataPublisher),
+          signal:           T.nilable(T.proc.void)
+        ).void
+      end
+      def initialize(data_channel:, error_channel:, create_publisher:, signal: nil)
+        super()
+        @data_channel     = T.let(data_channel,     T.untyped)
+        @error_channel    = T.let(error_channel,    T.untyped)
+        @outer_signal     = T.let(signal,            T.nilable(T.proc.void))
+        @create_publisher = T.let(create_publisher,  T.proc.returns(DataPublisher))
+        @stopped          = T.let(false,             T::Boolean)
+        # Per-connection active flag shared with subscriber lambdas via closure.
+        @conn_active      = T.let([false],            T::Array[T::Boolean])
+        _connect
+      end
+
+      sig { override.void }
+      def retry
+        stopped = @mutex.synchronize { @stopped }
+        return if stopped
+        return unless get_unified_state.status == 'error'
+
+        stale_data = get_unified_state.data
+        # Deactivate old connection's subscribers
+        @mutex.synchronize { @conn_active[0] = false }
+        _set_state(ReactiveState.new(status: 'retrying', data: stale_data))
+        _connect
+      end
+
+      private
+
+      sig { void }
+      def _connect
+        return if @mutex.synchronize { @stopped }
+
+        # Fresh active flag for this connection window
+        active = [true]
+        @mutex.synchronize { @conn_active = active }
+
+        # inner_signal fires (raises) once this connection is superseded or errors out,
+        # which causes DataPublisher to prune those subscribers automatically.
+        inner_signal = lambda do
+          @outer_signal&.call
+          Kernel.raise 'connection_inactive' unless active[0]
+        end
+
+        begin
+          publisher = @create_publisher.call
+        rescue => e
+          active[0] = false
+          stale_data = get_unified_state.data
+          _set_state(ReactiveState.new(status: 'error', data: stale_data, error: e))
+          return
+        end
+
+        publisher.on(@data_channel, signal: inner_signal) do |data|
+          _set_state(ReactiveState.new(status: 'loaded', data: data))
+        end
+
+        publisher.on(@error_channel, signal: inner_signal) do |err|
+          next unless active[0] && get_unified_state.status != 'error'
+          active[0] = false
+          stale_data = get_unified_state.data
+          _set_state(ReactiveState.new(status: 'error', data: stale_data, error: err))
+        end
+      end
+    end
+
+    module_function
+
+    # Creates a ReactiveStreamStore backed by a ready-made DataPublisher.
+    # retry() is not supported — see create_reactive_store_from_data_publisher_factory.
+    #
+    # Mirrors TypeScript's createReactiveStoreFromDataPublisher (deprecated in TS).
+    sig do
+      params(
+        publisher:     DataPublisher,
+        data_channel:  T.untyped,
+        error_channel: T.untyped,
+        signal:        T.nilable(T.proc.void)
+      ).returns(ReactiveStreamStore)
+    end
+    def create_reactive_store_from_data_publisher(publisher, data_channel:, error_channel:, signal: nil)
+      store = ReactiveStreamStore.new
+
+      publisher.on(data_channel, signal: signal) do |data|
+        store._set_state(ReactiveState.new(status: 'loaded', data: data))
+      end
+
+      publisher.on(error_channel, signal: signal) do |err|
+        unified = store.get_unified_state
+        next if unified.status == 'error'
+        store._set_state(ReactiveState.new(status: 'error', data: unified.data, error: err))
+      end
+
+      store
+    end
+
+    # Creates a retryable ReactiveStreamStore from a DataPublisher factory proc.
+    # The factory is called once immediately and again on each retry().
+    #
+    # Mirrors TypeScript's createReactiveStoreFromDataPublisherFactory.
+    sig do
+      params(
+        data_channel:  T.untyped,
+        error_channel: T.untyped,
+        signal:        T.nilable(T.proc.void),
+        blk:           T.proc.returns(DataPublisher)
+      ).returns(ReactiveStreamStore)
+    end
+    def create_reactive_store_from_data_publisher_factory(
+      data_channel:, error_channel:, signal: nil, &blk
+    )
+      RetryableReactiveStreamStore.new(
+        data_channel:     data_channel,
+        error_channel:    error_channel,
+        create_publisher: T.let(blk, T.proc.returns(DataPublisher)),
+        signal:           signal
+      )
+    end
+  end
+end

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

@@ -6,6 +6,8 @@ require 'timeout'
 # Mirrors @solana/subscribable.
 require_relative 'subscribable/data_publisher'
 require_relative 'subscribable/async_iterable'
+require_relative 'subscribable/reactive_stream_store'
+require_relative 'subscribable/reactive_action_store'
 
 module Solana::Ruby::Kit
   module Subscribable

data/lib/solana/ruby/kit/transaction_messages/compute_budget.rb

@@ -0,0 +1,145 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative '../addresses/address'
+require_relative '../instructions/instruction'
+require_relative 'transaction_message'
+
+module Solana::Ruby::Kit
+  module TransactionMessages
+    # Address of the Compute Budget program.
+    COMPUTE_BUDGET_PROGRAM_ADDRESS = T.let(
+      Addresses::Address.new('ComputeBudget111111111111111111111111111111'),
+      Addresses::Address
+    )
+
+    # Maximum compute unit limit per transaction (from Agave execution_budget.rs).
+    MAX_COMPUTE_UNIT_LIMIT = T.let(1_400_000, Integer)
+
+    # Maximum loaded accounts data size limit per transaction (64 MiB, from Agave).
+    MAX_LOADED_ACCOUNTS_DATA_SIZE_LIMIT = T.let(64 * 1024 * 1024, Integer)
+
+    SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR             = T.let(2, Integer)
+    SET_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_DISCRIMINATOR = T.let(4, Integer)
+
+    module_function
+
+    # ---------------------------------------------------------------------------
+    # SetComputeUnitLimit instruction helpers
+    # ---------------------------------------------------------------------------
+
+    sig { params(units: Integer).returns(Instructions::Instruction) }
+    def get_set_compute_unit_limit_instruction(units)
+      data = ([SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR].pack('C') + [units].pack('V')).b
+      Instructions::Instruction.new(
+        program_address: COMPUTE_BUDGET_PROGRAM_ADDRESS,
+        accounts:        nil,
+        data:            data
+      )
+    end
+
+    sig { params(instruction: Instructions::Instruction).returns(T::Boolean) }
+    def set_compute_unit_limit_instruction?(instruction)
+      instruction.program_address == COMPUTE_BUDGET_PROGRAM_ADDRESS &&
+        !instruction.data.nil? &&
+        T.must(instruction.data).bytesize == 5 &&
+        T.must(instruction.data).getbyte(0) == SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR
+    end
+
+    sig { params(data: String).returns(Integer) }
+    def compute_unit_limit_from_instruction_data(data)
+      T.must(data[1, 4]).unpack1('V')
+    end
+
+    # Returns the compute unit limit set on a transaction message, or nil if none is set.
+    # Mirrors `getTransactionMessageComputeUnitLimit` from @solana/transaction-messages.
+    sig { params(message: TransactionMessage).returns(T.nilable(Integer)) }
+    def get_transaction_message_compute_unit_limit(message)
+      ix = message.instructions.find { |i| set_compute_unit_limit_instruction?(i) }
+      ix ? compute_unit_limit_from_instruction_data(T.must(ix.data)) : nil
+    end
+
+    # Sets the compute unit limit on a transaction message, appending or replacing the
+    # SetComputeUnitLimit instruction. Mirrors `setTransactionMessageComputeUnitLimit`.
+    sig { params(limit: Integer, message: TransactionMessage).returns(TransactionMessage) }
+    def set_transaction_message_compute_unit_limit(limit, message)
+      existing_idx = message.instructions.index { |i| set_compute_unit_limit_instruction?(i) }
+      new_ix = get_set_compute_unit_limit_instruction(limit)
+
+      if existing_idx.nil?
+        append_instructions(message, [new_ix])
+      elsif compute_unit_limit_from_instruction_data(T.must(message.instructions[existing_idx].data)) == limit
+        message
+      else
+        new_instructions = message.instructions.dup
+        new_instructions[T.must(existing_idx)] = new_ix
+        TransactionMessage.new(
+          version:               message.version,
+          instructions:          new_instructions,
+          fee_payer:             message.fee_payer,
+          lifetime_constraint:   message.lifetime_constraint,
+          address_table_lookups: message.address_table_lookups
+        )
+      end
+    end
+
+    # ---------------------------------------------------------------------------
+    # SetLoadedAccountsDataSizeLimit instruction helpers
+    # ---------------------------------------------------------------------------
+
+    sig { params(limit: Integer).returns(Instructions::Instruction) }
+    def get_set_loaded_accounts_data_size_limit_instruction(limit)
+      data = ([SET_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_DISCRIMINATOR].pack('C') + [limit].pack('V')).b
+      Instructions::Instruction.new(
+        program_address: COMPUTE_BUDGET_PROGRAM_ADDRESS,
+        accounts:        nil,
+        data:            data
+      )
+    end
+
+    sig { params(instruction: Instructions::Instruction).returns(T::Boolean) }
+    def set_loaded_accounts_data_size_limit_instruction?(instruction)
+      instruction.program_address == COMPUTE_BUDGET_PROGRAM_ADDRESS &&
+        !instruction.data.nil? &&
+        T.must(instruction.data).bytesize == 5 &&
+        T.must(instruction.data).getbyte(0) == SET_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_DISCRIMINATOR
+    end
+
+    sig { params(data: String).returns(Integer) }
+    def loaded_accounts_data_size_limit_from_instruction_data(data)
+      T.must(data[1, 4]).unpack1('V')
+    end
+
+    # Returns the loaded accounts data size limit set on a transaction message, or nil.
+    # Mirrors `getTransactionMessageLoadedAccountsDataSizeLimit`.
+    sig { params(message: TransactionMessage).returns(T.nilable(Integer)) }
+    def get_transaction_message_loaded_accounts_data_size_limit(message)
+      ix = message.instructions.find { |i| set_loaded_accounts_data_size_limit_instruction?(i) }
+      ix ? loaded_accounts_data_size_limit_from_instruction_data(T.must(ix.data)) : nil
+    end
+
+    # Sets the loaded accounts data size limit on a transaction message.
+    # Mirrors `setTransactionMessageLoadedAccountsDataSizeLimit`.
+    sig { params(limit: Integer, message: TransactionMessage).returns(TransactionMessage) }
+    def set_transaction_message_loaded_accounts_data_size_limit(limit, message)
+      existing_idx = message.instructions.index { |i| set_loaded_accounts_data_size_limit_instruction?(i) }
+      new_ix = get_set_loaded_accounts_data_size_limit_instruction(limit)
+
+      if existing_idx.nil?
+        append_instructions(message, [new_ix])
+      elsif loaded_accounts_data_size_limit_from_instruction_data(T.must(message.instructions[existing_idx].data)) == limit
+        message
+      else
+        new_instructions = message.instructions.dup
+        new_instructions[T.must(existing_idx)] = new_ix
+        TransactionMessage.new(
+          version:               message.version,
+          instructions:          new_instructions,
+          fee_payer:             message.fee_payer,
+          lifetime_constraint:   message.lifetime_constraint,
+          address_table_lookups: message.address_table_lookups
+        )
+      end
+    end
+  end
+end

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

@@ -3,3 +3,4 @@
 
 # Transaction message construction utilities — mirrors @solana/transaction-messages.
 require_relative 'transaction_messages/transaction_message'
+require_relative 'transaction_messages/compute_budget'

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

@@ -4,7 +4,7 @@
 module Solana
   module Ruby
     module Kit
-      VERSION = '0.1.7'
+      VERSION = '0.1.9'
     end
   end
 end

data/lib/solana/ruby/kit.rb

@@ -50,6 +50,7 @@ require_relative 'kit/programs'
 require_relative 'kit/sysvars'
 require_relative 'kit/transaction_confirmation'
 require_relative 'kit/instruction_plans'
+require_relative 'kit/resource_limit_estimation'
 
 # Solana::Ruby::Kit is a Ruby translation of @anza-xyz/kit — the JavaScript SDK for
 # building Solana apps — into idiomatic Ruby with Sorbet static types.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solana-ruby-kit
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.9
 platform: ruby
 authors:
 - Paul Zupan, Idhra Inc.
@@ -235,16 +235,21 @@ files:
 - lib/solana/ruby/kit/programs/system_program.rb
 - lib/solana/ruby/kit/promises.rb
 - lib/solana/ruby/kit/railtie.rb
+- lib/solana/ruby/kit/resource_limit_estimation.rb
 - lib/solana/ruby/kit/rpc.rb
 - lib/solana/ruby/kit/rpc/api/get_account_info.rb
 - lib/solana/ruby/kit/rpc/api/get_balance.rb
 - lib/solana/ruby/kit/rpc/api/get_block_height.rb
+- lib/solana/ruby/kit/rpc/api/get_block_time.rb
 - lib/solana/ruby/kit/rpc/api/get_epoch_info.rb
+- lib/solana/ruby/kit/rpc/api/get_epoch_schedule.rb
+- lib/solana/ruby/kit/rpc/api/get_inflation_reward.rb
 - lib/solana/ruby/kit/rpc/api/get_latest_blockhash.rb
 - lib/solana/ruby/kit/rpc/api/get_minimum_balance_for_rent_exemption.rb
 - lib/solana/ruby/kit/rpc/api/get_multiple_accounts.rb
 - lib/solana/ruby/kit/rpc/api/get_program_accounts.rb
 - lib/solana/ruby/kit/rpc/api/get_signature_statuses.rb
+- lib/solana/ruby/kit/rpc/api/get_signatures_for_address.rb
 - lib/solana/ruby/kit/rpc/api/get_slot.rb
 - lib/solana/ruby/kit/rpc/api/get_token_account_balance.rb
 - lib/solana/ruby/kit/rpc/api/get_token_accounts_by_owner.rb
@@ -278,11 +283,14 @@ files:
 - lib/solana/ruby/kit/rpc_types/cluster_url.rb
 - lib/solana/ruby/kit/rpc_types/commitment.rb
 - lib/solana/ruby/kit/rpc_types/lamports.rb
+- lib/solana/ruby/kit/rpc_types/sol.rb
 - lib/solana/ruby/kit/signers.rb
 - lib/solana/ruby/kit/signers/keypair_signer.rb
 - lib/solana/ruby/kit/subscribable.rb
 - lib/solana/ruby/kit/subscribable/async_iterable.rb
 - lib/solana/ruby/kit/subscribable/data_publisher.rb
+- lib/solana/ruby/kit/subscribable/reactive_action_store.rb
+- lib/solana/ruby/kit/subscribable/reactive_stream_store.rb
 - lib/solana/ruby/kit/sysvars.rb
 - lib/solana/ruby/kit/sysvars/addresses.rb
 - lib/solana/ruby/kit/sysvars/clock.rb
@@ -291,6 +299,7 @@ files:
 - lib/solana/ruby/kit/sysvars/rent.rb
 - lib/solana/ruby/kit/transaction_confirmation.rb
 - lib/solana/ruby/kit/transaction_messages.rb
+- lib/solana/ruby/kit/transaction_messages/compute_budget.rb
 - lib/solana/ruby/kit/transaction_messages/transaction_message.rb
 - lib/solana/ruby/kit/transactions.rb
 - lib/solana/ruby/kit/transactions/compiler.rb