solana-ruby-kit 0.1.9 → 7.0.0.1

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/compiled_transaction_message.rb

@@ -0,0 +1,168 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative '../addresses/address'
+require_relative '../errors'
+
+module Solana::Ruby::Kit
+  module TransactionIntrospection
+    extend T::Sig
+
+    # The signer/readonly account counts from a compiled transaction message.
+    # Mirrors the `header` field of TypeScript's `CompiledTransactionMessage`.
+    class CompiledTransactionMessageHeader < T::Struct
+      const :num_signer_accounts,               Integer
+      const :num_readonly_signer_accounts,      Integer
+      const :num_readonly_non_signer_accounts,  Integer
+    end
+
+    # A single instruction inside a compiled transaction message, with account
+    # indices and data still unresolved (see GetInstructions for resolution).
+    class CompiledInstruction < T::Struct
+      const :program_address_index, Integer
+      const :account_indices,       T::Array[Integer]
+      const :data,                  String  # binary; may be empty
+    end
+
+    # A decoded transaction message: the account roles, static account list,
+    # instructions, and lifetime token (recent blockhash or durable nonce value).
+    #
+    # Mirrors TypeScript's `CompiledTransactionMessage & CompiledTransactionMessageWithLifetime`.
+    # Ruby normalizes legacy/v0/v1 instruction representations into a single
+    # `instructions` array (TypeScript keeps v1's headers/payloads split) since
+    # nothing downstream needs the raw per-version shape.
+    class CompiledTransactionMessage < T::Struct
+      const :version,         T.untyped  # :legacy or Integer (0 or 1)
+      const :header,          CompiledTransactionMessageHeader
+      const :static_accounts, T::Array[Addresses::Address]
+      const :instructions,    T::Array[CompiledInstruction]
+      const :lifetime_token,  String  # base58-encoded blockhash or nonce value
+    end
+
+    module_function
+
+    # Decodes legacy or v0 compiled transaction message bytes (the
+    # `message_bytes` of a `Transactions::Transaction`) into a
+    # CompiledTransactionMessage.
+    #
+    # v1 messages use a different (message-first) wire envelope and are not
+    # decoded here — Ruby's wire compiler (`Transactions.compile_transaction_message`)
+    # does not yet produce v1 transactions either, so there is nothing to
+    # round-trip. Raises SolanaError::TRANSACTION__VERSION_NUMBER_NOT_SUPPORTED
+    # for any version this decoder cannot handle.
+    #
+    # Mirrors `getCompiledTransactionMessageDecoder()` from @solana/transaction-messages.
+    sig { params(message_bytes: String).returns(CompiledTransactionMessage) }
+    def decode_compiled_transaction_message(message_bytes)
+      bytes  = message_bytes.b
+      offset = 0
+
+      first_byte = bytes.getbyte(0).to_i
+      if (first_byte & 0x80) != 0
+        version = first_byte & 0x7f
+        unless version == 0
+          Kernel.raise SolanaError.new(
+            SolanaError::TRANSACTION__VERSION_NUMBER_NOT_SUPPORTED,
+            { unsupported_version: version }
+          )
+        end
+        offset += 1
+      else
+        version = :legacy
+      end
+
+      num_signer_accounts, offset              = read_byte(bytes, offset)
+      num_readonly_signer_accounts, offset     = read_byte(bytes, offset)
+      num_readonly_non_signer_accounts, offset = read_byte(bytes, offset)
+
+      num_accounts, offset = decode_compact_u16(bytes, offset)
+      static_accounts = T.let([], T::Array[Addresses::Address])
+      num_accounts.times do
+        static_accounts << Addresses.address(Addresses.encode_address(read_bytes(bytes, offset, 32)))
+        offset += 32
+      end
+
+      lifetime_token = Addresses.encode_address(read_bytes(bytes, offset, 32))
+      offset += 32
+
+      num_instructions, offset = decode_compact_u16(bytes, offset)
+      instructions = T.let([], T::Array[CompiledInstruction])
+      num_instructions.times do
+        program_address_index, offset = read_byte(bytes, offset)
+
+        num_ix_accounts, offset = decode_compact_u16(bytes, offset)
+        account_indices = T.let([], T::Array[Integer])
+        num_ix_accounts.times do
+          index, offset = read_byte(bytes, offset)
+          account_indices << index
+        end
+
+        data_length, offset = decode_compact_u16(bytes, offset)
+        data = read_bytes(bytes, offset, data_length)
+        offset += data_length
+
+        instructions << CompiledInstruction.new(
+          program_address_index: program_address_index,
+          account_indices:       account_indices,
+          data:                  data
+        )
+      end
+
+      CompiledTransactionMessage.new(
+        version:         version,
+        header:          CompiledTransactionMessageHeader.new(
+          num_signer_accounts:              num_signer_accounts,
+          num_readonly_signer_accounts:     num_readonly_signer_accounts,
+          num_readonly_non_signer_accounts: num_readonly_non_signer_accounts
+        ),
+        static_accounts: static_accounts,
+        instructions:    instructions,
+        lifetime_token:  lifetime_token
+      )
+    end
+
+    # ── Private helpers ────────────────────────────────────────────────────────
+
+    sig { params(bytes: String, offset: Integer, length: Integer).returns(String) }
+    def read_bytes(bytes, offset, length)
+      slice = bytes[offset, length]
+      if slice.nil? || slice.bytesize != length
+        Kernel.raise SolanaError.new(
+          SolanaError::TRANSACTION_INTROSPECTION__MALFORMED_COMPILED_MESSAGE,
+          { needed_bytes: offset + length }
+        )
+      end
+      slice.b
+    end
+    private_class_method :read_bytes
+
+    sig { params(bytes: String, offset: Integer).returns([Integer, Integer]) }
+    def read_byte(bytes, offset)
+      byte = bytes.getbyte(offset)
+      if byte.nil?
+        Kernel.raise SolanaError.new(
+          SolanaError::TRANSACTION_INTROSPECTION__MALFORMED_COMPILED_MESSAGE,
+          { needed_bytes: offset + 1 }
+        )
+      end
+      [byte, offset + 1]
+    end
+    private_class_method :read_byte
+
+    # Reads a Solana compact-u16 from +bytes+ starting at +offset+.
+    # Returns [decoded_integer, next_offset].
+    sig { params(bytes: String, offset: Integer).returns([Integer, Integer]) }
+    def decode_compact_u16(bytes, offset)
+      value = 0
+      shift = 0
+      Kernel.loop do
+        byte, offset = read_byte(bytes, offset)
+        value |= (byte & 0x7f) << shift
+        shift += 7
+        break unless (byte & 0x80) != 0
+      end
+      [value, offset]
+    end
+    private_class_method :decode_compact_u16
+  end
+end

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

@@ -0,0 +1,176 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'base64'
+require_relative '../addresses'
+require_relative '../encoding/base58'
+require_relative '../errors'
+require_relative '../transactions/transaction'
+require_relative '../wallet_standard'
+require_relative 'compiled_transaction_message'
+require_relative 'loaded_addresses'
+
+module Solana::Ruby::Kit
+  module TransactionIntrospection
+    extend T::Sig
+
+    # 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.
+    #
+    # `transaction` is nil for `encoding: 'json'` responses: the server has
+    # already decompiled the wire format, so there are no message bytes to
+    # round-trip. Fetch with `encoding: 'base64'` if you need a re-encodable
+    # Transaction.
+    #
+    # Mirrors `DecodedRpcTransaction` from @solana/transaction-introspection.
+    class DecodedRpcTransaction < T::Struct
+      const :compiled_message, CompiledTransactionMessage
+      const :loaded_addresses, LoadedAddresses
+      const :transaction,      T.nilable(Transactions::Transaction)
+    end
+
+    module_function
+
+    # 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 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
+    # a `'jsonParsed'` response raises
+    # SolanaError::TRANSACTION_INTROSPECTION__CANNOT_DECODE_JSON_PARSED_TRANSACTION;
+    # any other unrecognized input raises
+    # SolanaError::TRANSACTION_INTROSPECTION__UNRECOGNIZED_GET_TRANSACTION_RESPONSE.
+    #
+    # A transaction version this decoder cannot handle (anything but legacy
+    # or v0) raises SolanaError::TRANSACTION__VERSION_NUMBER_NOT_SUPPORTED —
+    # Ruby's wire compiler does not produce v1 transactions either, so there
+    # is nothing to decompile for that version yet.
+    #
+    # Mirrors `decodeTransactionFromRpcResponse()`.
+    sig { params(rpc_tx: T::Hash[String, T.untyped]).returns(DecodedRpcTransaction) }
+    def decode_transaction_from_rpc_response(rpc_tx)
+      tx_field = rpc_tx['transaction']
+
+      if tx_field.is_a?(Array)
+        encoding = tx_field[1]
+        return decode_from_base64(rpc_tx) if encoding == 'base64'
+        return decode_from_base58(rpc_tx) if encoding == 'base58'
+      elsif tx_field.is_a?(Hash) && tx_field['message'].is_a?(Hash)
+        # An `encoding: 'json'` message carries the compiled-message `header`
+        # (signer/readonly counts). A `jsonParsed` message has no `header` —
+        # the server has already resolved account roles onto `accountKeys` —
+        # so checking for it distinguishes the two encodings.
+        return decode_from_json(rpc_tx) if tx_field['message']['header'].is_a?(Hash)
+
+        Kernel.raise SolanaError.new(SolanaError::TRANSACTION_INTROSPECTION__CANNOT_DECODE_JSON_PARSED_TRANSACTION)
+      end
+
+      Kernel.raise SolanaError.new(SolanaError::TRANSACTION_INTROSPECTION__UNRECOGNIZED_GET_TRANSACTION_RESPONSE)
+    end
+
+    # ── Private helpers ────────────────────────────────────────────────────────
+
+    sig { params(meta: T.untyped).returns(LoadedAddresses) }
+    def get_loaded_addresses(meta)
+      loaded = meta.is_a?(Hash) ? meta['loadedAddresses'] : nil
+      return EMPTY_LOADED_ADDRESSES unless loaded.is_a?(Hash)
+
+      LoadedAddresses.new(
+        readonly: (loaded['readonly'] || []).map { |a| Addresses.address(a) },
+        writable: (loaded['writable'] || []).map { |a| Addresses.address(a) }
+      )
+    end
+    private_class_method :get_loaded_addresses
+
+    sig { params(rpc_tx: T::Hash[String, T.untyped]).returns(DecodedRpcTransaction) }
+    def decode_from_base64(rpc_tx)
+      b64         = rpc_tx['transaction'][0]
+      transaction = WalletStandard.decode_wire_transaction(b64)
+      DecodedRpcTransaction.new(
+        compiled_message: decode_compiled_transaction_message(transaction.message_bytes),
+        loaded_addresses: get_loaded_addresses(rpc_tx['meta']),
+        transaction:      transaction
+      )
+    end
+    private_class_method :decode_from_base64
+
+    sig { params(rpc_tx: T::Hash[String, T.untyped]).returns(DecodedRpcTransaction) }
+    def decode_from_base58(rpc_tx)
+      b58         = rpc_tx['transaction'][0]
+      transaction = WalletStandard.decode_wire_transaction(Encoding::Base58.decode(b58))
+      DecodedRpcTransaction.new(
+        compiled_message: decode_compiled_transaction_message(transaction.message_bytes),
+        loaded_addresses: get_loaded_addresses(rpc_tx['meta']),
+        transaction:      transaction
+      )
+    end
+    private_class_method :decode_from_base58
+
+    sig { params(rpc_tx: T::Hash[String, T.untyped]).returns(DecodedRpcTransaction) }
+    def decode_from_json(rpc_tx)
+      message = rpc_tx['transaction']['message']
+
+      header = CompiledTransactionMessageHeader.new(
+        num_signer_accounts:              message['header']['numRequiredSignatures'],
+        num_readonly_signer_accounts:      message['header']['numReadonlySignedAccounts'],
+        num_readonly_non_signer_accounts:  message['header']['numReadonlyUnsignedAccounts']
+      )
+
+      instructions = message['instructions'].map do |ix|
+        data_b58 = ix['data']
+        CompiledInstruction.new(
+          program_address_index: ix['programIdIndex'],
+          account_indices:       ix['accounts'] || [],
+          data:                  data_b58.nil? || data_b58.empty? ? ''.b : Encoding::Base58.decode(data_b58)
+        )
+      end
+
+      # The envelope only carries `version` when `maxSupportedTransactionVersion`
+      # was set on the request; otherwise the response is necessarily 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(
+        version:         version,
+        header:          header,
+        static_accounts: message['accountKeys'].map { |a| Addresses.address(a) },
+        instructions:    instructions,
+        # For durable-nonce transactions, `recentBlockhash` is the nonce value, not a
+        # blockhash — either way it is the message's lifetime token.
+        lifetime_token:  message['recentBlockhash']
+      )
+
+      DecodedRpcTransaction.new(
+        compiled_message: compiled_message,
+        loaded_addresses: get_loaded_addresses(rpc_tx['meta']),
+        transaction:      nil
+      )
+    end
+    private_class_method :decode_from_json
+  end
+end

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

@@ -0,0 +1,88 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative '../encoding/base58'
+require_relative '../errors'
+require_relative '../instructions/instruction'
+require_relative 'types'
+
+module Solana::Ruby::Kit
+  module TransactionIntrospection
+    extend T::Sig
+
+    module_function
+
+    # Returns the inner instructions in a transaction `meta` as
+    # TracedInstructions.
+    #
+    # The RPC returns inner instructions in a different shape from the wire
+    # format: indices reference the same flat account list as the outer
+    # instructions, but `data` is a base58-encoded string. This decodes the
+    # 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 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.
+    #
+    # Mirrors `getInnerInstructionsFromMeta()`.
+    sig do
+      params(
+        meta:          T.nilable(T::Hash[String, T.untyped]),
+        account_metas: T::Array[Instructions::AccountMeta]
+      ).returns(T::Array[TracedInstruction])
+    end
+    def get_inner_instructions_from_meta(meta, account_metas)
+      groups = meta && meta['innerInstructions']
+      return [] unless groups
+
+      result = T.let([], T::Array[TracedInstruction])
+
+      groups.each do |group|
+        outer_index = group['index']
+
+        group['instructions'].each_with_index do |ix, inner_index|
+          program_meta = account_metas[ix['programIdIndex']]
+          if program_meta.nil?
+            Kernel.raise SolanaError.new(
+              SolanaError::TRANSACTIONS__FAILED_TO_DECOMPILE_INSTRUCTION_PROGRAM_ADDRESS_NOT_FOUND,
+              { index: ix['programIdIndex'] }
+            )
+          end
+
+          accounts = (ix['accounts'] || []).map do |i|
+            account_meta = account_metas[i]
+            if account_meta.nil?
+              Kernel.raise SolanaError.new(
+                SolanaError::TRANSACTION__FAILED_TO_DECOMPILE_INSTRUCTION_ACCOUNT_INDEX_OUT_OF_RANGE,
+                { index: i }
+              )
+            end
+            account_meta
+          end
+
+          data_b58 = ix['data']
+          data     = data_b58.nil? || data_b58.empty? ? nil : Encoding::Base58.decode(data_b58)
+
+          trace = { kind: :inner, outer_index: outer_index, inner_index: inner_index }
+          trace[:stack_height] = ix['stackHeight'] unless ix['stackHeight'].nil?
+
+          result << TracedInstruction.new(
+            instruction: Instructions::Instruction.new(
+              program_address: program_meta.address,
+              accounts:        accounts.empty? ? nil : accounts,
+              data:            data
+            ),
+            trace: trace
+          )
+        end
+      end
+
+      result
+    end
+  end
+end