solana-ruby-kit 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a6261831e387559dd450f4da24966c5fb21a3d6d079eca64bc1c19577f1517c
-  data.tar.gz: bb79df5d4217eb20f8fc07b9ae89e6ce070fbcb38f193b4e775d38b1cfe72998
+  metadata.gz: f96f7c22b28fbf9bec4186e3bf92ec52483d532b7e398da89bf143473b267878
+  data.tar.gz: 4a2e915aba2620726be4b5c89880c49fd7d54acf950618d4002ce19b54ac7884
 SHA512:
-  metadata.gz: 6259e78a36520927779d1912d3cd2190690b207fdb538473ed2eabc47e153f9e16380570043087ff94aba46019ef66c5be25383f237f82ad21949cccdb6200c9
-  data.tar.gz: 9155affe61d202d5e9847b9df5da10958ee85089410cf0bd2f856b77087710d38b3318c3c178057fa9112cfee16d5bb85f51b3d9ae36bfcfce1c01b351f04a00
+  metadata.gz: 8a7fef4cd3632770e3e7d67f5b4722585f66f2ad45c601687d6664fc38433a85d39de7f4d582062e6396be7df29ea3cf089ca77184a7d8c28c3cf2b3d37015ae
+  data.tar.gz: '0967fe5ea552384a656b22f5f03d08674e4066c373e0ee83cc31bd45598573aacade37f4295a0c24341eb0e31b7d543720be99cf347aba0ab626429f5c629085'

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

@@ -120,6 +120,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
@@ -231,6 +237,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/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/client.rb

@@ -20,6 +20,9 @@ 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'
 
 module Solana::Ruby::Kit
   module Rpc
@@ -56,6 +59,9 @@ module Solana::Ruby::Kit
       include Api::GetEpochInfo
       include Api::GetVoteAccounts
       include Api::SimulateTransaction
+      include Api::GetBlockTime
+      include Api::GetEpochSchedule
+      include Api::GetInflationReward
 
       sig { returns(Transport) }
       attr_reader :transport

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

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

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.8
 platform: ruby
 authors:
 - Paul Zupan, Idhra Inc.
@@ -239,7 +239,10 @@ files:
 - 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
@@ -278,11 +281,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