solana-ruby-kit 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dddb792ac729b3981104e68f18131191f6775d864e785d25cd47ad5d169e94cc
-  data.tar.gz: 4fd955c2fb214186034906194a530ad62461ee7d3169b7e0718233de4331d4a8
+  metadata.gz: f96f7c22b28fbf9bec4186e3bf92ec52483d532b7e398da89bf143473b267878
+  data.tar.gz: 4a2e915aba2620726be4b5c89880c49fd7d54acf950618d4002ce19b54ac7884
 SHA512:
-  metadata.gz: 9341acdd7f36e55078fa7a21989ec8e29aa00a351e52e3caa05a2f2b14ccee3fbe443f6b35d9914ccb4e53192e215e12659c4c7f83090bc2c027c9ff4fa52f87
-  data.tar.gz: 0dc330cd1fc6f3177d283eb6b251e0ad187c92f482c328aae1c72a9881bf338206ff2a9fadf7ab3c0a9f4744ce798244bac7368cb8517beee3cb89252abcea75
+  metadata.gz: 8a7fef4cd3632770e3e7d67f5b4722585f66f2ad45c601687d6664fc38433a85d39de7f4d582062e6396be7df29ea3cf089ca77184a7d8c28c3cf2b3d37015ae
+  data.tar.gz: '0967fe5ea552384a656b22f5f03d08674e4066c373e0ee83cc31bd45598573aacade37f4295a0c24341eb0e31b7d543720be99cf347aba0ab626429f5c629085'

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

@@ -116,6 +116,16 @@ module Solana::Ruby::Kit
     INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN               = :SOLANA_ERROR__INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN
     INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN   = :SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN
 
+    # ── Wallet Standard ───────────────────────────────────────────────────────
+    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
@@ -227,6 +237,16 @@ 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}',
+
         # Invariant violations
         INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_STATE_MISSING => 'Subscription iterator state is missing (internal error)',
         INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE => 'Subscription iterator must not poll before resolving existing message (internal error)',

data/lib/solana/ruby/kit/programs/stake_program.rb

@@ -23,7 +23,7 @@ module Solana::Ruby::Kit
 
       # The Stake Program address.
       PROGRAM_ID = T.let(
-        Addresses::Address.new('Stake11111111111111111111111111111111111111111'),
+        Addresses::Address.new('Stake11111111111111111111111111111111111111'),
         Addresses::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.6'
+      VERSION = '0.1.8'
     end
   end
 end

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

@@ -0,0 +1,254 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'base64'
+require 'rbnacl'
+require_relative 'addresses/address'
+require_relative 'keys/signatures'
+require_relative 'transactions/transaction'
+require_relative 'errors'
+
+module Solana::Ruby::Kit
+  # Server-side Ruby port of the @solana/wallet-standard signTransaction interface.
+  #
+  # When a browser wallet (Phantom, Backpack, Solflare, …) calls
+  #   wallet.features['solana:signTransaction'].signTransaction(transaction)
+  # the signed transaction is returned as serialised wire bytes.  Rails receives
+  # those bytes (typically base64-encoded in a JSON request body) and uses this
+  # module to:
+  #
+  #   1. Decode the wire bytes back into a +Transactions::Transaction+ struct.
+  #   2. Verify every present Ed25519 signature against the message bytes.
+  #   3. Confirm that a specific wallet address (or all required addresses) signed.
+  #   4. Optionally broadcast the verified transaction via +Rpc+.
+  #
+  # Solana addresses ARE Ed25519 public keys (32-byte base58), so signature
+  # verification requires no external key lookup — the verify key is derived
+  # directly from the signer's address string.
+  #
+  # Typical Rails controller usage:
+  #
+  #   wire_bytes = Base64.strict_decode64(params[:signed_transaction])
+  #   tx = Solana::Ruby::Kit::WalletStandard.verify_signed_transaction!(wire_bytes)
+  #   Solana::Ruby::Kit::Transactions.assert_fully_signed_transaction!(tx)
+  #   # tx is now safe to inspect or forward to the RPC node
+  #
+  # Mirrors @solana/wallet-standard (anza-xyz/kit) and @wallet-standard/features.
+  module WalletStandard
+    extend T::Sig
+
+    # ── Wallet Standard feature identifiers ──────────────────────────────────
+    # String constants that identify which signing capabilities a browser wallet
+    # supports.  Client-side JavaScript reads wallet.features to detect these;
+    # the constants are documented here so Rails code can reference them by name
+    # when building feature-negotiation metadata for the frontend.
+
+    # The wallet can sign transactions without broadcasting them.
+    SIGN_TRANSACTION          = T.let('solana:signTransaction',        String)
+    # The wallet can sign and broadcast in a single round-trip.
+    SIGN_AND_SEND_TRANSACTION = T.let('solana:signAndSendTransaction', String)
+    # The wallet can sign arbitrary off-chain messages.
+    SIGN_MESSAGE              = T.let('solana:signMessage',            String)
+    # Base Wallet Standard lifecycle features.
+    CONNECT                   = T.let('standard:connect',              String)
+    DISCONNECT                = T.let('standard:disconnect',           String)
+    EVENTS                    = T.let('standard:events',               String)
+
+    module_function
+
+    # ── Wire-format decoder ───────────────────────────────────────────────────
+
+    # Decodes a Solana wire-encoded transaction into a +Transactions::Transaction+.
+    #
+    # Accepts the binary output of a wallet's +signTransaction+ call.  Binary
+    # (ASCII_8BIT) strings are used as-is; any other encoding is treated as
+    # standard base64 and decoded automatically.
+    #
+    # Solana wire format (legacy; v0 versioned transactions add a one-byte
+    # version prefix to the message section):
+    #
+    #   [compact-u16]       num_signatures
+    #   [64 bytes × n]      signature slots (all-zero slot means unfilled)
+    #   [message bytes …]
+    #
+    # The returned Transaction carries:
+    #   +message_bytes+  — raw bytes that were (or will be) signed
+    #   +signatures+     — ordered Hash of signer_address → raw_sig_bytes or nil
+    #
+    # Raises +SolanaError::WALLET_STANDARD__INVALID_WIRE_FORMAT+ for malformed input.
+    #
+    # Mirrors +getTransactionDecoder()+ from @solana/transactions.
+    sig { params(wire_bytes: String).returns(Transactions::Transaction) }
+    def decode_wire_transaction(wire_bytes)
+      bytes  = coerce_to_binary(wire_bytes)
+      offset = 0
+
+      # 1. Signature count (compact-u16)
+      sig_count, offset = decode_compact_u16(bytes, offset)
+      if sig_count > 19
+        Kernel.raise SolanaError.new(
+          SolanaError::WALLET_STANDARD__INVALID_WIRE_FORMAT,
+          reason: "signature count #{sig_count} exceeds the maximum of 19"
+        )
+      end
+
+      # 2. Signature slots — 64 bytes each; all-zero means the slot is unfilled.
+      zero64   = ("\x00" * 64).b
+      raw_sigs = T.let([], T::Array[T.nilable(String)])
+      sig_count.times do
+        slot = bytes[offset, 64]
+        if slot.nil? || slot.bytesize != 64
+          Kernel.raise SolanaError.new(
+            SolanaError::WALLET_STANDARD__INVALID_WIRE_FORMAT,
+            reason: 'truncated signature slot'
+          )
+        end
+        raw_sigs << (slot.b == zero64 ? nil : slot.b)
+        offset += 64
+      end
+
+      # 3. Everything after the signatures section is the message.
+      msg_slice = bytes[offset..]
+      if msg_slice.nil? || msg_slice.empty?
+        Kernel.raise SolanaError.new(
+          SolanaError::WALLET_STANDARD__INVALID_WIRE_FORMAT,
+          reason: 'message section is missing'
+        )
+      end
+      message_bytes = T.must(msg_slice).b
+
+      # 4. Determine version and locate the message header.
+      #    Legacy transactions:   first byte = num_required_signatures (0..127)
+      #    Versioned (v0) trans.: first byte = 0x80 | version  (≥ 128); skip it.
+      msg_pos    = 0
+      first_byte = message_bytes.getbyte(msg_pos).to_i
+      msg_pos   += 1 if (first_byte & 0x80) != 0
+
+      num_required_sigs = message_bytes.getbyte(msg_pos).to_i
+      msg_pos += 1
+      msg_pos += 2  # skip num_readonly_signed + num_readonly_unsigned
+
+      # 5. Parse the account list to recover signer addresses.
+      num_accounts, msg_pos = decode_compact_u16(message_bytes, msg_pos)
+      if msg_pos + (num_accounts * 32) > message_bytes.bytesize
+        Kernel.raise SolanaError.new(
+          SolanaError::WALLET_STANDARD__INVALID_WIRE_FORMAT,
+          reason: 'account table truncated'
+        )
+      end
+
+      account_addrs = T.let([], T::Array[String])
+      num_accounts.times do
+        account_addrs << Addresses.encode_address(message_bytes[msg_pos, 32].b)
+        msg_pos += 32
+      end
+
+      # 6. Build the signatures map.
+      #    The first +num_required_sigs+ accounts in the account table are the
+      #    signers; their raw_sigs slots are positionally aligned.
+      signer_addrs = account_addrs[0, num_required_sigs]
+      signatures   = T.let({}, T::Hash[String, T.nilable(String)])
+      signer_addrs.each_with_index { |addr, i| signatures[addr] = raw_sigs[i] }
+
+      Transactions::Transaction.new(message_bytes: message_bytes, signatures: signatures)
+    end
+
+    # ── Signature verification ────────────────────────────────────────────────
+
+    # Verifies every filled (non-nil) signature in +transaction.signatures+.
+    #
+    # For each signed slot the signer's Ed25519 public key is reconstructed
+    # directly from their address (Solana addresses are base58-encoded 32-byte
+    # Ed25519 public keys), so no external key lookup is required.
+    #
+    # Raises +SolanaError::WALLET_STANDARD__SIGNATURE_VERIFICATION_FAILED+ if
+    # any signature does not verify.  Nil (unfilled) slots are skipped silently;
+    # use +Transactions.assert_fully_signed_transaction!+ to enforce that all
+    # required signers have signed.
+    sig { params(transaction: Transactions::Transaction).void }
+    def verify_transaction_signatures!(transaction)
+      transaction.signatures.each do |addr_str, sig_raw|
+        next if sig_raw.nil?
+
+        verify_key = RbNaCl::VerifyKey.new(Addresses.decode_address(Addresses::Address.new(addr_str)))
+        sig_bytes  = Keys::SignatureBytes.new(sig_raw)
+
+        unless Keys.verify_signature(verify_key, sig_bytes, transaction.message_bytes)
+          Kernel.raise SolanaError.new(
+            SolanaError::WALLET_STANDARD__SIGNATURE_VERIFICATION_FAILED,
+            address: addr_str
+          )
+        end
+      end
+    end
+
+    # Convenience method for Rails controllers: decode wire bytes received from a
+    # browser wallet and verify all present signatures in one call.
+    #
+    # Returns the decoded +Transaction+ on success.
+    # Raises +SolanaError+ for malformed wire bytes or any invalid signature.
+    # Does NOT require the transaction to be fully signed; follow up with
+    # +Transactions.assert_fully_signed_transaction!+ when broadcasting.
+    #
+    # Accepts binary or base64-encoded input (see +decode_wire_transaction+).
+    sig { params(wire_bytes: String).returns(Transactions::Transaction) }
+    def verify_signed_transaction!(wire_bytes)
+      tx = decode_wire_transaction(wire_bytes)
+      verify_transaction_signatures!(tx)
+      tx
+    end
+
+    # Returns +true+ if +address+ has provided a cryptographically valid
+    # signature for +transaction+; +false+ if the slot is absent, nil, or the
+    # signature does not verify against +transaction.message_bytes+.
+    sig { params(transaction: Transactions::Transaction, address: Addresses::Address).returns(T::Boolean) }
+    def signed_by?(transaction, address)
+      sig_raw = transaction.signatures[address.value]
+      return false if sig_raw.nil?
+
+      verify_key = RbNaCl::VerifyKey.new(Addresses.decode_address(address))
+      sig_bytes  = Keys::SignatureBytes.new(sig_raw)
+      Keys.verify_signature(verify_key, sig_bytes, transaction.message_bytes)
+    end
+
+    # ── Private helpers ───────────────────────────────────────────────────────
+
+    # Forces +input+ to a binary (ASCII_8BIT) String.
+    # ASCII_8BIT input is returned as-is; anything else is treated as base64.
+    sig { params(input: String).returns(String) }
+    def coerce_to_binary(input)
+      return input.b if input.encoding == ::Encoding::ASCII_8BIT
+
+      stripped = input.strip
+      begin
+        Base64.strict_decode64(stripped).b
+      rescue ArgumentError
+        Base64.decode64(stripped).b
+      end
+    end
+    private_class_method :coerce_to_binary
+
+    # 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
+      loop do
+        byte = bytes.getbyte(offset)
+        if byte.nil?
+          Kernel.raise SolanaError.new(
+            SolanaError::WALLET_STANDARD__INVALID_WIRE_FORMAT,
+            reason: 'compact-u16 read past end of buffer'
+          )
+        end
+        offset += 1
+        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.rb

@@ -41,6 +41,9 @@ require_relative 'kit/rpc_subscriptions'
 # ── Plugin system ─────────────────────────────────────────────────────────────
 require_relative 'kit/plugin_core'
 
+# ── Wallet Standard (server-side signature verification) ──────────────────────
+require_relative 'kit/wallet_standard'
+
 # ── Higher-level helpers ──────────────────────────────────────────────────────
 require_relative 'kit/offchain_messages'
 require_relative 'kit/programs'
@@ -75,6 +78,7 @@ require_relative 'kit/instruction_plans'
 #   Solana::Ruby::Kit::Sysvars               — sysvar fetch/decode      (@solana/sysvars)
 #   Solana::Ruby::Kit::TransactionConfirmation — confirmation polling   (@solana/transaction-confirmation)
 #   Solana::Ruby::Kit::InstructionPlans      — multi-tx planning        (@solana/instruction-plans)
+#   Solana::Ruby::Kit::WalletStandard        — server-side sig verify   (@solana/wallet-standard)
 
 module Solana::Ruby::Kit
   extend T::Sig

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solana-ruby-kit
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  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
@@ -296,6 +302,7 @@ files:
 - lib/solana/ruby/kit/transactions/compiler.rb
 - lib/solana/ruby/kit/transactions/transaction.rb
 - lib/solana/ruby/kit/version.rb
+- lib/solana/ruby/kit/wallet_standard.rb
 - solana-ruby-kit.gemspec
 licenses:
 - MIT