solana-ruby-kit 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f96f7c22b28fbf9bec4186e3bf92ec52483d532b7e398da89bf143473b267878
-  data.tar.gz: 4a2e915aba2620726be4b5c89880c49fd7d54acf950618d4002ce19b54ac7884
+  metadata.gz: 1d26df33c1471059cde38ac46ec2604e0c26ffc8d64c580de4171396516530fd
+  data.tar.gz: dba1b05e818b10e8fa7692f6ae4af89c3946bcd19707be52cfdfd1c503e81b63
 SHA512:
-  metadata.gz: 8a7fef4cd3632770e3e7d67f5b4722585f66f2ad45c601687d6664fc38433a85d39de7f4d582062e6396be7df29ea3cf089ca77184a7d8c28c3cf2b3d37015ae
-  data.tar.gz: '0967fe5ea552384a656b22f5f03d08674e4066c373e0ee83cc31bd45598573aacade37f4295a0c24341eb0e31b7d543720be99cf347aba0ab626429f5c629085'
+  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
@@ -172,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',
@@ -217,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',

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_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

@@ -23,6 +23,7 @@ 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
@@ -62,6 +63,7 @@ module Solana::Ruby::Kit
       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/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.8'
+      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.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Paul Zupan, Idhra Inc.
@@ -235,6 +235,7 @@ 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
@@ -248,6 +249,7 @@ files:
 - 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
@@ -297,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