solana-ruby-kit 7.0.0 → 7.0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b2766067cfcd434e5c657e1fde1dab4b44b23880e0f514f924d28a94ea0ca4a
-  data.tar.gz: 32814612b342df38df079aaba08b8ea17c9128ac9f54279ab3abad622ba02492
+  metadata.gz: 950ad695ca0d9971314172207d974e747cf35c5dfec1210fb32882f0517306f8
+  data.tar.gz: ce0c4c171c78ca202a35bbacdd74630bb24afd3a438c7ebe7669b5cb56ee9a71
 SHA512:
-  metadata.gz: 3bcfbd20e6f610a47053cb385511931004590646ff04e0edf4587e5699df3db8bb148af2b706cf025e8399f26e4736ae9db35ebfd04d68be287df8302bc9f4de
-  data.tar.gz: d40b332b7cc427730b17b01a091c53815c596c0ac114bca93f52bed4d35775cd2b57ca5146893e2c94d46cebcbe0f51ccf98d2c6e2cad308cd51c2ff7b022d62
+  metadata.gz: 7d356ad614cfe6990a0df08121f6db68dcdf4e72b19979bd01a56233a1fccc699a16ee716c2e12d33b4de5c34792cc627fd0e273bfefce73a7144f70fff37ddf
+  data.tar.gz: b866ff957a09ba7dc4ab26708ea1311b2c8a283e992f972351c173187a47d905b6ba62483beefd0f5b2c9d46f9ecdd8574bba1f4491e96771abdc9c75417f7ee

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

@@ -139,6 +139,7 @@ module Solana::Ruby::Kit
 
     # ── Subscribable ──────────────────────────────────────────────────────────
     SUBSCRIBABLE__RETRY_NOT_SUPPORTED                     = :SOLANA_ERROR__SUBSCRIBABLE__RETRY_NOT_SUPPORTED
+    SUBSCRIBABLE__STREAM_CLOSED_WITHOUT_ERROR             = :SOLANA_ERROR__SUBSCRIBABLE__STREAM_CLOSED_WITHOUT_ERROR
 
     # ── Fixed-points ──────────────────────────────────────────────────────────
     FIXED_POINTS__STRICT_MODE_PRECISION_LOSS              = :SOLANA_ERROR__FIXED_POINTS__STRICT_MODE_PRECISION_LOSS
@@ -271,6 +272,7 @@ module Solana::Ruby::Kit
 
         # Subscribable
         SUBSCRIBABLE__RETRY_NOT_SUPPORTED              => 'This reactive store does not support retry(); use create_reactive_store_from_data_publisher_factory for a retryable store',
+        SUBSCRIBABLE__STREAM_CLOSED_WITHOUT_ERROR      => 'The stream store closed in an error state but did not report an error.',
 
         # Fixed-points
         FIXED_POINTS__STRICT_MODE_PRECISION_LOSS       => 'Value has more than 9 fractional digits and cannot be represented exactly as a Sol amount',

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

@@ -9,7 +9,9 @@ module Solana::Ruby::Kit
       InflationReward = T.let(
         Struct.new(
           :amount,         # Integer (Lamports) — reward credited
-          :commission,     # Integer — vote account commission at reward time
+          :commission,     # Integer, nilable — vote account commission at reward time;
+                           #   null once the vote account reports commission through
+                           #   getVoteAccounts' inflationRewardsCommissionBps instead
           :effective_slot, # Integer — slot in which rewards were delivered
           :epoch,          # Integer — epoch for which reward occurred
           :post_balance,   # Integer (Lamports) — post-reward account balance
@@ -46,7 +48,7 @@ module Solana::Ruby::Kit
 
             InflationReward.new(
               amount:         Kernel.Integer(entry['amount']),
-              commission:     Kernel.Integer(entry['commission']),
+              commission:     entry['commission'] ? Kernel.Integer(entry['commission']) : nil,
               effective_slot: Kernel.Integer(entry['effectiveSlot']),
               epoch:          Kernel.Integer(entry['epoch']),
               post_balance:   Kernel.Integer(entry['postBalance'])

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

@@ -0,0 +1,208 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Solana::Ruby::Kit
+  module Rpc
+    module Api
+      # One signature-level entry returned by getTransactionsForAddress when
+      # `transaction_details` is `:signatures`.
+      # Mirrors TypeScript's GetTransactionsForAddressSignature.
+      TransactionsForAddressSignature = 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 — 0-based index within the block
+          keyword_init: true
+        ),
+        T.untyped
+      )
+
+      # The result envelope shared by every mode of getTransactionsForAddress.
+      #
+      # `data` holds the matching transactions in the requested sort order. Its
+      # element type depends on `transaction_details`: TransactionsForAddressSignature
+      # structs for `:signatures`, and raw (String-keyed) response hashes for
+      # `:full` — the same shape `Rpc::Api::GetTransaction#get_transaction`
+      # returns, so each element can be handed straight to
+      # `TransactionIntrospection.decode_transaction_from_rpc_response`.
+      #
+      # `pagination_token` is the cursor to pass back as `pagination_token` on a
+      # subsequent call, or nil when there are no more results.
+      #
+      # Mirrors TypeScript's GetTransactionsForAddressApiResponse.
+      TransactionsForAddressPage = T.let(
+        Struct.new(
+          :data,             # Array<TransactionsForAddressSignature> | Array<Hash>
+          :pagination_token, # String | nil — cursor for the next page
+          keyword_init: true
+        ),
+        T.untyped
+      )
+
+      # Returns confirmed transactions that load the given address, with
+      # server-side filtering, sorting, and cursor-based pagination.
+      #
+      # This combines the discovery step of getSignaturesForAddress with
+      # filtering and pagination the server applies itself. Note: check your RPC
+      # provider for support for this method.
+      #
+      # Mirrors TypeScript's GetTransactionsForAddressApi.getTransactionsForAddress.
+      # See https://solana.com/docs/rpc/http/gettransactionsforaddress
+      module GetTransactionsForAddress
+        extend T::Sig
+
+        # Maps the snake_case keys of a Ruby +filters+ hash onto the wire names.
+        # Comparison operators (:eq, :gt, :gte, :lt, :lte) pass through as-is.
+        FILTER_KEYS = T.let(
+          {
+            block_time:     'blockTime',
+            signature:      'signature',
+            slot:           'slot',
+            status:         'status',
+            token_accounts: 'tokenAccounts'
+          }.freeze,
+          T::Hash[Symbol, String]
+        )
+
+        COMPARISON_KEYS = T.let(%i[eq gt gte lt lte].freeze, T::Array[Symbol])
+
+        # @param address [String] base-58 address to search for.
+        # @param transaction_details [Symbol] :signatures (default) or :full.
+        # @param encoding [String, nil] 'base58', 'base64', 'json' (server default),
+        #   or 'jsonParsed'. Only valid with `transaction_details: :full`.
+        # @param max_supported_transaction_version [Integer, nil] newest transaction
+        #   version to accept. Omit to receive only legacy transactions (in which
+        #   case no `version` is returned). Only valid with `transaction_details: :full`.
+        # @param commitment [Symbol, nil] :confirmed or :finalized. This method does
+        #   not support :processed.
+        # @param filters [Hash, nil] server-side filters, combined with AND. Supports
+        #   `block_time:` ({eq/gt/gte/lt/lte}), `signature:` ({gt/gte/lt/lte}),
+        #   `slot:` ({gt/gte/lt/lte}), `status:` (:any, :succeeded, :failed), and
+        #   `token_accounts:` (:none, :balance_changed, :all).
+        # @param limit [Integer, nil] max results. The server caps this at 1000 for
+        #   `:signatures` and 100 for `:full`.
+        # @param min_context_slot [Integer, nil] reject data older than this slot.
+        # @param pagination_token [String, nil] cursor from a previous response's
+        #   `pagination_token`, formatted "<slot>:<position>".
+        # @param sort_order [Symbol, nil] :desc (newest first, server default) or :asc.
+        # @return [TransactionsForAddressPage]
+        sig do
+          params(
+            address:                            String,
+            transaction_details:                Symbol,
+            encoding:                           T.nilable(String),
+            max_supported_transaction_version:  T.nilable(Integer),
+            commitment:                         T.nilable(Symbol),
+            filters:                            T.nilable(T::Hash[Symbol, T.untyped]),
+            limit:                              T.nilable(Integer),
+            min_context_slot:                   T.nilable(Integer),
+            pagination_token:                   T.nilable(String),
+            sort_order:                         T.nilable(Symbol)
+          ).returns(T.untyped)
+        end
+        def get_transactions_for_address(
+          address,
+          transaction_details:               :signatures,
+          encoding:                          nil,
+          max_supported_transaction_version: nil,
+          commitment:                        nil,
+          filters:                           nil,
+          limit:                             nil,
+          min_context_slot:                  nil,
+          pagination_token:                  nil,
+          sort_order:                        nil
+        )
+          unless %i[signatures full].include?(transaction_details)
+            Kernel.raise ArgumentError, "transaction_details must be :signatures or :full, got #{transaction_details.inspect}"
+          end
+
+          # The RPC rejects `processed` for this method; TypeScript encodes that
+          # as `Exclude<Commitment, 'processed'>`, so fail fast here too.
+          if commitment == :processed
+            Kernel.raise ArgumentError, 'getTransactionsForAddress does not support the :processed commitment'
+          end
+
+          if transaction_details == :signatures
+            if encoding
+              Kernel.raise ArgumentError, 'encoding is only valid with transaction_details: :full'
+            end
+            if max_supported_transaction_version
+              Kernel.raise ArgumentError, 'max_supported_transaction_version is only valid with transaction_details: :full'
+            end
+          end
+
+          config = { 'transactionDetails' => transaction_details.to_s }
+          config['encoding']                       = encoding if encoding
+          config['maxSupportedTransactionVersion'] = max_supported_transaction_version if max_supported_transaction_version
+          config['commitment']                     = commitment.to_s if commitment
+          config['limit']                          = limit if limit
+          config['minContextSlot']                 = min_context_slot if min_context_slot
+          config['paginationToken']                = pagination_token if pagination_token
+          config['sortOrder']                      = sort_order.to_s if sort_order
+          config['filters']                        = build_filters(filters) if filters && !filters.empty?
+
+          raw  = transport.request('getTransactionsForAddress', [address, config])
+          rows = raw['data'] || []
+
+          data = if transaction_details == :full
+                   # Returned verbatim so each element can be fed to
+                   # TransactionIntrospection.decode_transaction_from_rpc_response.
+                   rows
+                 else
+                   rows.map do |tx|
+                     TransactionsForAddressSignature.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'] && Kernel.Integer(tx['transactionIndex'])
+                     )
+                   end
+                 end
+
+          TransactionsForAddressPage.new(data: data, pagination_token: raw['paginationToken'])
+        end
+
+        # ── Private helpers ────────────────────────────────────────────────────
+
+        # Converts the snake_case +filters+ hash into its wire form. Symbol values
+        # (`status`, `token_accounts`) are lowerCamelCased so `:balance_changed`
+        # reaches the server as `"balanceChanged"`.
+        sig { params(filters: T::Hash[Symbol, T.untyped]).returns(T::Hash[String, T.untyped]) }
+        def build_filters(filters)
+          filters.each_with_object({}) do |(key, value), out|
+            wire_key = FILTER_KEYS[key]
+            Kernel.raise ArgumentError, "unknown filter #{key.inspect}" if wire_key.nil?
+
+            out[wire_key] = if value.is_a?(Hash)
+                              value.each_with_object({}) do |(op, operand), cmp|
+                                unless COMPARISON_KEYS.include?(op)
+                                  Kernel.raise ArgumentError, "unknown comparison #{op.inspect} in filter #{key.inspect}"
+                                end
+                                cmp[op.to_s] = operand
+                              end
+                            elsif value.is_a?(Symbol)
+                              camelize(value)
+                            else
+                              value
+                            end
+          end
+        end
+        private :build_filters
+
+        sig { params(value: Symbol).returns(String) }
+        def camelize(value)
+          head, *rest = value.to_s.split('_')
+          ([head] + rest.map(&:capitalize)).join
+        end
+        private :camelize
+      end
+    end
+  end
+end

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

@@ -24,6 +24,7 @@ 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'
+require_relative 'api/get_transactions_for_address'
 
 module Solana::Ruby::Kit
   module Rpc
@@ -64,6 +65,7 @@ module Solana::Ruby::Kit
       include Api::GetEpochSchedule
       include Api::GetInflationReward
       include Api::GetSignaturesForAddress
+      include Api::GetTransactionsForAddress
 
       sig { returns(Transport) }
       attr_reader :transport

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

@@ -0,0 +1,172 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative '../errors'
+require_relative 'reactive_stream_store'
+
+module Solana::Ruby::Kit
+  module Subscribable
+    extend T::Sig
+
+    module_function
+
+    # Adapts a ReactiveStreamStore into an Enumerator, so a *push*-based
+    # reactive store can be driven by *pull*-based code that consumes it with
+    # `#each`, `#next`, `#take`, or any other Enumerable method.
+    #
+    # The bridge only *observes* the store; it does not open or tear down the
+    # connection. The caller owns the store's lifecycle. The bridge subscribes,
+    # yields the store's current and subsequent values, and unsubscribes when
+    # iteration ends — however it ends (exhaustion, error, `break`, or abort).
+    # It does not reset the store; that is the caller's decision.
+    #
+    # This is the store-backed counterpart to AsyncIterable.from_publisher.
+    # That helper turns a raw DataPublisher into an Enumerator and queues every
+    # message so none are dropped. `bridge_store_to_async_iterable` instead sits
+    # on top of a ReactiveStreamStore, so it reflects the store's
+    # loading/loaded/error/retrying lifecycle — and, because a store only ever
+    # holds the *latest* snapshot, it is latest-wins rather than fully buffered.
+    #
+    # On iteration it seeds from the store's current snapshot, then yields its
+    # lifecycle:
+    # - 'loaded'   → yields the value (the one already present when iteration
+    #                begins, then each subsequent update), unless the optional
+    #                +should_yield+ predicate rejects it. Latest-wins: if several
+    #                notifications land between pulls, only the most recent
+    #                unconsumed value is yielded.
+    # - 'error'    → raises, so the consuming loop propagates it. Substitutes a
+    #                SolanaError::SUBSCRIBABLE__STREAM_CLOSED_WITHOUT_ERROR
+    #                sentinel when the store reports an error with a nil payload.
+    #                An error takes precedence over a buffered value: if a loaded
+    #                value is still pending when an error arrives, that value is
+    #                dropped and the error propagates.
+    # - 'loading' / 'retrying' → carry no new value and no error; nothing to yield.
+    #
+    # +signal+ follows the same convention as the rest of Subscribable: a lambda
+    # called to test for abort, which *raises* once aborted. When it raises,
+    # iteration ends cleanly (no error) — an abort is teardown, so the store's
+    # incidental abort-driven error state is not surfaced. Because a Ruby
+    # consumer parks in a blocking wait rather than on an event loop, the signal
+    # is re-tested every +poll_interval+ seconds while parked; it is checked
+    # immediately on every store change regardless. With no +signal+, the
+    # enumerator parks indefinitely between values — a subscription never
+    # completes on its own, so `break` out of the loop to stop.
+    #
+    # @param store [ReactiveStreamStore] a store to observe. Connect it yourself.
+    # @param signal [Proc, nil] raises once aborted; ends iteration cleanly.
+    # @param should_yield [Proc, nil] gate run against each loaded value before
+    #   it is yielded. Return false to drop the value.
+    # @param poll_interval [Float] seconds between signal re-tests while parked.
+    # @return [Enumerator]
+    #
+    # @example
+    #   store = Subscribable.create_reactive_store_from_data_publisher(
+    #     publisher, data_channel: :slotNotification, error_channel: :error
+    #   )
+    #   Subscribable.bridge_store_to_async_iterable(store).each do |notification|
+    #     puts "Latest slot: #{notification['slot']}"
+    #   end
+    #
+    # Mirrors bridgeStoreToAsyncIterable from @solana/subscribable.
+    sig do
+      params(
+        store:         ReactiveStreamStore,
+        signal:        T.nilable(T.proc.void),
+        should_yield:  T.nilable(T.proc.params(value: T.untyped).returns(T::Boolean)),
+        poll_interval: Float
+      ).returns(T::Enumerator[T.untyped])
+    end
+    def bridge_store_to_async_iterable(store, signal: nil, should_yield: nil, poll_interval: 0.05)
+      Enumerator.new do |yielder|
+        mutex = Mutex.new
+        cond  = ConditionVariable.new
+        # Latest-wins single-slot buffer. Both are one-element arrays used as
+        # "present or nil" boxes so a legitimately-nil value is distinguishable
+        # from "nothing buffered".
+        latest  = T.let(nil, T.nilable(T::Array[T.untyped]))
+        failure = T.let(nil, T.nilable(T::Array[T.untyped]))
+
+        on_change = Kernel.lambda do
+          state = store.get_unified_state
+          case state.status
+          when 'loaded'
+            # Drop a value the gate rejects; park again rather than yielding it.
+            next if should_yield && !should_yield.call(state.data)
+            mutex.synchronize do
+              latest = [state.data]
+              cond.broadcast
+            end
+          when 'error'
+            # A nil error would otherwise surface as a value-less success;
+            # substitute a sentinel so the failure propagates.
+            err = state.error || SolanaError.new(SolanaError::SUBSCRIBABLE__STREAM_CLOSED_WITHOUT_ERROR)
+            mutex.synchronize do
+              failure = [err]
+              cond.broadcast
+            end
+          end
+        end
+
+        aborted = Kernel.lambda do
+          next false if signal.nil?
+
+          begin
+            signal.call
+            false
+          rescue StandardError
+            true
+          end
+        end
+
+        unsubscribe = store.subscribe(&on_change)
+        # Seed from the store's current snapshot: the caller may already have
+        # connected (and a value or error may already be present) before
+        # iteration began. The bridge never connects the store itself.
+        on_change.call
+
+        begin
+          Kernel.loop do
+            # Abort wins over everything: end cleanly without raising.
+            break if aborted.call
+
+            action  = T.let(:park, Symbol)
+            payload = T.let(nil, T.untyped)
+
+            mutex.synchronize do
+              if failure
+                action  = :raise
+                payload = failure[0]
+              elsif latest
+                action  = :yield
+                payload = latest[0]
+                latest  = nil
+              else
+                cond.wait(mutex, signal ? poll_interval : nil)
+              end
+            end
+
+            case action
+            when :yield then yielder.yield(payload)
+            when :raise then Kernel.raise(coerce_error(payload))
+            end
+          end
+        ensure
+          unsubscribe.call
+        end
+      end
+    end
+
+    # The store's error channel carries whatever the publisher emitted, which
+    # need not be an Exception. Ruby can only raise exceptions, so wrap anything
+    # else rather than losing the failure.
+    sig { params(error: T.untyped).returns(Exception) }
+    def coerce_error(error)
+      case error
+      when Exception then error
+      when String    then RuntimeError.new(error)
+      else                RuntimeError.new(error.inspect)
+      end
+    end
+    private_class_method :coerce_error
+  end
+end

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

@@ -8,6 +8,7 @@ require_relative 'subscribable/data_publisher'
 require_relative 'subscribable/async_iterable'
 require_relative 'subscribable/reactive_stream_store'
 require_relative 'subscribable/reactive_action_store'
+require_relative 'subscribable/bridge_store_to_async_iterable'
 
 module Solana::Ruby::Kit
   module Subscribable

data/lib/solana/ruby/kit/transaction_introspection/decode_rpc_transaction.rb

@@ -14,7 +14,7 @@ module Solana::Ruby::Kit
   module TransactionIntrospection
     extend T::Sig
 
-    # The result of decoding a `getTransaction` response: the
+    # The result of decoding a confirmed-transaction RPC response: the
     # CompiledTransactionMessage, the loaded ALT addresses pulled from `meta`
     # (if any), and — for `'base64'` and `'base58'` responses — the
     # re-encodable wire-format Transactions::Transaction.
@@ -33,14 +33,28 @@ module Solana::Ruby::Kit
 
     module_function
 
-    # Decodes a `getTransaction` response (any of `encoding: 'base64'`,
+    # Decodes a confirmed-transaction RPC response (any of `encoding: 'base64'`,
     # `'base58'`, or `'json'`) into a CompiledTransactionMessage plus, for
     # `'base64'` and `'base58'`, a re-encodable Transactions::Transaction.
     # The JSON path does not produce a Transaction: the server has already
     # decompiled the wire format, so there are no message bytes to carry.
     #
-    # +rpc_tx+ is the raw (String-keyed) JSON hash returned by
-    # `Rpc::Api::GetTransaction#get_transaction`.
+    # +rpc_tx+ is a raw (String-keyed) JSON hash. Only the `transaction` /
+    # `meta` / `version` envelope is read — not a method-specific response
+    # shape — so results from any method that returns confirmed transactions in
+    # these encodings work, and extra fields (`slot`, `blockTime`,
+    # `transactionIndex`, …) are ignored:
+    #
+    #   # getTransaction — a single response hash
+    #   rpc_tx = rpc.get_transaction(signature, encoding: 'base64')
+    #   TransactionIntrospection.decode_transaction_from_rpc_response(rpc_tx)
+    #
+    #   # getTransactionsForAddress — one hash per element of `data`
+    #   page = rpc.get_transactions_for_address(
+    #     address, transaction_details: :full, encoding: 'base64',
+    #     max_supported_transaction_version: 0
+    #   )
+    #   page.data.map { |tx| TransactionIntrospection.decode_transaction_from_rpc_response(tx) }
     #
     # `'jsonParsed'` is not supported — its instructions arrive pre-parsed by
     # the server and lack raw bytes, so they cannot be round-tripped. Passing
@@ -135,7 +149,10 @@ module Solana::Ruby::Kit
 
       # The envelope only carries `version` when `maxSupportedTransactionVersion`
       # was set on the request; otherwise the response is necessarily legacy.
-      version = rpc_tx.key?('version') ? rpc_tx['version'] : :legacy
+      # A `version` key that is present but null counts as absent — some methods
+      # include the key unconditionally. Ruby's `||` is safe here where
+      # TypeScript needs `??`: 0 (v0) is truthy in Ruby, so a real v0 survives.
+      version = rpc_tx['version'] || :legacy
       version = :legacy if version == 'legacy'
 
       compiled_message = CompiledTransactionMessage.new(

data/lib/solana/ruby/kit/transaction_introspection/get_inner_instructions.rb

@@ -12,7 +12,7 @@ module Solana::Ruby::Kit
 
     module_function
 
-    # Returns the inner instructions in a `getTransaction` response as
+    # Returns the inner instructions in a transaction `meta` as
     # TracedInstructions.
     #
     # The RPC returns inner instructions in a different shape from the wire
@@ -21,8 +21,10 @@ module Solana::Ruby::Kit
     # data, resolves the indices against the supplied AccountMeta list, and
     # tags each instruction with an `inner` trace.
     #
-    # +meta+ is the raw (String-keyed) `meta` hash from a `getTransaction`
-    # response. Returns an empty array if it carries no `innerInstructions`.
+    # +meta+ is the raw (String-keyed) `meta` hash from any method that returns
+    # transaction metadata without `jsonParsed` encoding — `getTransaction`,
+    # `getTransactionsForAddress`, or `getBlock`. Returns an empty array if it
+    # carries no `innerInstructions`.
     #
     # Raises if any `programIdIndex` or account index falls outside the
     # supplied `account_metas` list.

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

@@ -4,7 +4,7 @@
 module Solana
   module Ruby
     module Kit
-      VERSION = '7.0.0'
+      VERSION = '7.0.0.1'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solana-ruby-kit
 version: !ruby/object:Gem::Version
-  version: 7.0.0
+  version: 7.0.0.1
 platform: ruby
 authors:
 - Paul Zupan, Idhra Inc.
@@ -255,6 +255,7 @@ files:
 - lib/solana/ruby/kit/rpc/api/get_token_account_balance.rb
 - lib/solana/ruby/kit/rpc/api/get_token_accounts_by_owner.rb
 - lib/solana/ruby/kit/rpc/api/get_transaction.rb
+- lib/solana/ruby/kit/rpc/api/get_transactions_for_address.rb
 - lib/solana/ruby/kit/rpc/api/get_vote_accounts.rb
 - lib/solana/ruby/kit/rpc/api/is_blockhash_valid.rb
 - lib/solana/ruby/kit/rpc/api/request_airdrop.rb
@@ -289,6 +290,7 @@ files:
 - 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/bridge_store_to_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