solana_ruby_wallet_adapter 0.1.1

data/lib/solana_wallet_adapter/signer_adapter.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+# typed: strict
+
+module SolanaWalletAdapter
+  # Mixin for adapters that can sign transactions locally (without sending).
+  # Mirrors SignerWalletAdapterProps from @solana/wallet-adapter-base.
+  module SignerWalletAdapter
+    extend T::Sig
+    extend T::Helpers
+
+    requires_ancestor { BaseWalletAdapter }
+
+    # Sign a single transaction and return the signed bytes.
+    sig do
+      abstract
+        .params(transaction: Transaction)
+        .returns(Transaction)
+    end
+    def sign_transaction(transaction); end
+
+    # Sign multiple transactions and return them in the same order.
+    sig do
+      abstract
+        .params(transactions: T::Array[Transaction])
+        .returns(T::Array[Transaction])
+    end
+    def sign_all_transactions(transactions); end
+  end
+
+  # Abstract base class that combines BaseWalletAdapter with signing.
+  # Mirrors BaseSignerWalletAdapter from @solana/wallet-adapter-base.
+  class BaseSignerWalletAdapter < BaseWalletAdapter
+    extend  T::Sig
+    extend  T::Helpers
+    include SignerWalletAdapter
+
+    abstract!
+
+    # send_transaction default implementation: sign then forward raw bytes
+    # to the Solana RPC via Net::HTTP.  Subclasses may override.
+    sig do
+      override
+        .params(
+          transaction: Transaction,
+          rpc_url:     String,
+          options:     SendTransactionOptions
+        )
+        .returns(String)
+    end
+    def send_transaction(transaction, rpc_url, options = SendTransactionOptions.new)
+      raise WalletNotConnectedError unless connected?
+
+      if transaction.versioned?
+        unless supported_transaction_versions
+          raise WalletSendTransactionError,
+                "Sending versioned transactions isn't supported by this wallet"
+        end
+        unless T.must(supported_transaction_versions).include?(T.must(transaction.version))
+          raise WalletSendTransactionError,
+                "Sending transaction version #{transaction.version&.serialize} isn't supported by this wallet"
+        end
+      end
+
+      signed = begin
+        sign_transaction(transaction)
+      rescue WalletSignTransactionError
+        raise
+      rescue => e
+        raise WalletSendTransactionError.new(e.message, e)
+      end
+
+      send_raw_transaction(signed.serialize, rpc_url, options)
+    rescue WalletError => e
+      emit(:error, e)
+      raise
+    end
+
+    private
+
+    # Submits serialised transaction bytes to the RPC endpoint and returns
+    # the transaction signature string.
+    sig { params(raw_bytes: String, rpc_url: String, options: SendTransactionOptions).returns(String) }
+    def send_raw_transaction(raw_bytes, rpc_url, options)
+      require "net/http"
+      require "json"
+      require "base64"
+
+      encoded = Base64.strict_encode64(raw_bytes)
+
+      config = [encoded, { encoding: "base64" }]
+      config[1]["skipPreflight"]         = options.skip_preflight if options.skip_preflight
+      config[1]["preflightCommitment"]   = options.preflight_commitment if options.preflight_commitment
+      config[1]["maxRetries"]            = options.max_retries if options.max_retries
+      config[1]["minContextSlot"]        = options.min_context_slot if options.min_context_slot
+
+      body = JSON.generate({
+        jsonrpc: "2.0",
+        id:      1,
+        method:  "sendTransaction",
+        params:  config,
+      })
+
+      uri      = URI(rpc_url)
+      response = Net::HTTP.post(uri, body, "Content-Type" => "application/json")
+      result   = JSON.parse(response.body)
+
+      if (err = result["error"])
+        raise WalletSendTransactionError, err["message"] || err.inspect
+      end
+
+      result.dig("result") || raise(WalletSendTransactionError, "Unexpected RPC response: #{result.inspect}")
+    end
+  end
+end

data/lib/solana_wallet_adapter/transaction.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# typed: strict
+
+module SolanaWalletAdapter
+  # Mirrors the TransactionVersion type in @solana/web3.js.
+  # Solana supports "legacy" transactions and versioned transactions (0+).
+  class TransactionVersion < T::Enum
+    enums do
+      Legacy     = new("legacy")
+      Version0   = new(0)
+    end
+  end
+
+  # Mirrors SupportedTransactionVersions – a frozen set of accepted versions.
+  # nil means "all versions supported" (equivalent to null/undefined in TS).
+  SupportedTransactionVersions = T.type_alias { T.nilable(T::Set[TransactionVersion]) }
+
+  # Lightweight wrapper around raw serialised Solana transaction bytes.
+  # The gem does not attempt to parse the transaction wire format; that
+  # responsibility belongs to a dedicated Solana RPC client gem.
+  class Transaction
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :wire_bytes
+
+    sig { returns(T.nilable(TransactionVersion)) }
+    attr_reader :version
+
+    sig { params(wire_bytes: String, version: T.nilable(TransactionVersion)).void }
+    def initialize(wire_bytes, version: nil)
+      @wire_bytes = T.let(wire_bytes, String)
+      @version    = T.let(version, T.nilable(TransactionVersion))
+    end
+
+    sig { returns(T::Boolean) }
+    def versioned?
+      !version.nil? && version != TransactionVersion::Legacy
+    end
+
+    sig { returns(String) }
+    def serialize
+      wire_bytes
+    end
+  end
+
+  # Options forwarded to the RPC sendTransaction call.
+  class SendTransactionOptions < T::Struct
+    extend T::Sig
+
+    # Additional signers that should co-sign the transaction before sending.
+    const :signers,               T::Array[String],       default: []
+
+    # Preflight commitment level.  Maps to Solana's Commitment type.
+    const :preflight_commitment,  T.nilable(String),      default: nil
+
+    # Whether to skip preflight simulation.
+    const :skip_preflight,        T::Boolean,             default: false
+
+    # Maximum number of retries.
+    const :max_retries,           T.nilable(Integer),     default: nil
+
+    # Minimum context slot for the transaction.
+    const :min_context_slot,      T.nilable(Integer),     default: nil
+  end
+end

data/lib/solana_wallet_adapter/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+# typed: strict
+
+module SolanaWalletAdapter
+  VERSION = "0.1.1"
+end

data/lib/solana_wallet_adapter/view_helpers.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+# typed: strict
+
+module SolanaWalletAdapter
+  # Helpers mixed into ActionView::Base when the Railtie loads.
+  module ViewHelpers
+    extend T::Sig
+
+    # Returns a JSON array of all registered wallet adapter metadata.
+    # Useful for seeding a JS wallet picker component.
+    #
+    # Example (in an ERB layout):
+    #   <script>
+    #     window.__SOLANA_WALLETS__ = <%= solana_wallets_json %>;
+    #   </script>
+    sig { returns(String) }
+    def solana_wallets_json
+      require "json"
+      JSON.generate(WalletRegistry.to_json_array)
+    end
+  end
+end

data/lib/solana_wallet_adapter/wallet_ready_state.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+# typed: strict
+
+module SolanaWalletAdapter
+  # Mirrors the WalletReadyState enum from @solana/wallet-adapter-base.
+  #
+  # +Installed+    – The wallet browser extension / app was detected.
+  # +NotDetected+  – No wallet detected in the current environment.
+  # +Loadable+     – The wallet is always available (e.g. iOS deep-link redirect).
+  # +Unsupported+  – The platform cannot support this wallet (server-side, etc.).
+  class WalletReadyState < T::Enum
+    enums do
+      Installed    = new("Installed")
+      NotDetected  = new("NotDetected")
+      Loadable     = new("Loadable")
+      Unsupported  = new("Unsupported")
+    end
+  end
+end

data/lib/solana_wallet_adapter/wallet_registry.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+# typed: strict
+
+module SolanaWalletAdapter
+  # A registry that maps wallet names to their adapter classes.
+  # Provides a single place to look up all known wallet adapters and to
+  # filter them by ready-state for use in frontend JSON serialisation.
+  #
+  # Usage:
+  #   # Register your adapters (typically in an initializer)
+  #   SolanaWalletAdapter::WalletRegistry.register(
+  #     SolanaWalletAdapter::Wallets::PhantomWalletAdapter,
+  #     SolanaWalletAdapter::Wallets::SolflareWalletAdapter,
+  #   )
+  #
+  #   # Query
+  #   WalletRegistry.all          # => [PhantomWalletAdapter, ...]
+  #   WalletRegistry.find("Phantom") # => PhantomWalletAdapter
+  class WalletRegistry
+    extend T::Sig
+
+    @adapters = T.let(
+      {},
+      T::Hash[String, T.class_of(BaseWalletAdapter)]
+    )
+
+    class << self
+      extend T::Sig
+
+      # Register one or more adapter classes.
+      sig { params(adapter_classes: T::Array[T.class_of(BaseWalletAdapter)]).void }
+      def register(*adapter_classes)
+        adapter_classes.each do |klass|
+          instance = klass.new
+          @adapters[instance.name] = klass
+        end
+      end
+
+      # Return all registered adapter classes in registration order.
+      sig { returns(T::Array[T.class_of(BaseWalletAdapter)]) }
+      def all
+        @adapters.values
+      end
+
+      # Find an adapter class by wallet name.
+      sig { params(name: String).returns(T.nilable(T.class_of(BaseWalletAdapter))) }
+      def find(name)
+        @adapters[name]
+      end
+
+      # Serialise all adapters to an array of hashes suitable for JSON.
+      # Instantiates each adapter once to read metadata.
+      sig { returns(T::Array[T::Hash[String, T.untyped]]) }
+      def to_json_array
+        @adapters.values.map { |klass| klass.new.to_h }
+      end
+
+      # Remove all registered adapters.  Useful in tests.
+      sig { void }
+      def reset!
+        @adapters.clear
+      end
+    end
+  end
+end

data/lib/solana_wallet_adapter/wallets/coinbase.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+# typed: strict
+
+module SolanaWalletAdapter
+  module Wallets
+    class CoinbaseWalletAdapter < BaseMessageSignerWalletAdapter
+      extend T::Sig
+
+      COINBASE_ICON = T.let(
+        "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAyNCIgaGVpZ2h0PSIxMDI0IiB2aWV3Qm94PSIwIDAgMTAyNCAxMDI0IiBm" \
+        "aWxsPSJub25lIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgo8Y2lyY2xlIGN4PSI1MTIiIGN5" \
+        "PSI1MTIiIHI9IjUxMiIgZmlsbD0iIzAwNTJGRiIvPgo8cGF0aCBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGNsaXAtcnVs" \
+        "ZT0iZXZlbm9kZCIgZD0iTTE1MiA1MTJDMTUyIDcxMC44MjMgMzEzLjE3NyA4NzIgNTEyIDg3MkM3MTAuODIzIDg3" \
+        "MiA4NzIgNzEwLjgyMyA4NzIgNTEyQzg3MiAzMTMuMTc3IDcxMC44MjMgMTUyIDUxMiAxNTJDMzEzLjE3NyAxNTIg" \
+        "MTUyIDMxMy4xNzcgMTUyIDUxMlpNNDIwIDM5NkM0MDYuNzQ1IDM5NiAzOTYgNDA2Ljc0NSAzOTYgNDIwVjYwNEMz" \
+        "OTYgNjE3LjI1NSA0MDYuNzQ1IDYyOCA0MjAgNjI4SDYwNEM2MTcuMjU1IDYyOCA2MjggNjE3LjI1NSA2MjggNjA0" \
+        "VjQyMEM2MjggNDA2Ljc0NSA2MTcuMjU1IDM5NiA2MDQgMzk2SDQyMFoiIGZpbGw9IndoaXRlIi8+Cjwvc3ZnPgo=",
+        String
+      )
+
+      sig { override.returns(String) }
+      def name = "Coinbase Wallet"
+
+      sig { override.returns(String) }
+      def url = "https://chrome.google.com/webstore/detail/coinbase-wallet-extension/hnfanknocfeofbddgcijnmhnfnkdnaad"
+
+      sig { override.returns(String) }
+      def icon = COINBASE_ICON
+
+      sig { override.returns(WalletReadyState) }
+      def ready_state = WalletReadyState::Unsupported
+
+      sig { override.returns(T.nilable(PublicKey)) }
+      def public_key = nil
+
+      sig { override.returns(T::Boolean) }
+      def connecting? = false
+
+      sig { override.returns(SupportedTransactionVersions) }
+      def supported_transaction_versions
+        Set[TransactionVersion::Legacy, TransactionVersion::Version0].freeze
+      end
+
+      sig { override.void }
+      def connect
+        raise WalletNotReadyError, "#{name} connection is initiated in the browser"
+      end
+
+      sig { override.void }
+      def disconnect; end
+
+      sig do
+        override
+          .params(transaction: Transaction, rpc_url: String, options: SendTransactionOptions)
+          .returns(String)
+      end
+      def send_transaction(transaction, rpc_url, options = SendTransactionOptions.new)
+        raise WalletNotConnectedError, "send_transaction must use a pre-signed transaction server-side"
+      end
+
+      sig { override.params(transaction: Transaction).returns(Transaction) }
+      def sign_transaction(transaction)
+        raise WalletNotConnectedError, "sign_transaction must be performed client-side"
+      end
+
+      sig { override.params(transactions: T::Array[Transaction]).returns(T::Array[Transaction]) }
+      def sign_all_transactions(transactions)
+        raise WalletNotConnectedError, "sign_all_transactions must be performed client-side"
+      end
+
+      sig { override.params(message: String).returns(String) }
+      def sign_message(message)
+        raise WalletNotConnectedError, "sign_message must be performed client-side"
+      end
+    end
+  end
+end

data/lib/solana_wallet_adapter/wallets/ledger.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+# typed: strict
+
+module SolanaWalletAdapter
+  module Wallets
+    class LedgerWalletAdapter < BaseSignerWalletAdapter
+      extend T::Sig
+
+      LEDGER_ICON = T.let(
+        "data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMzUgMzUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Zy" \
+        "I+PGcgZmlsbD0iI2ZmZiI+PHBhdGggZD0ibTIzLjU4OCAweC0xNnYyMS41ODNoMjEuNnYtMTZhNS41ODUgNS41OD" \
+        "UgMCAwIDAgLTUuNi01LjU4M3oiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDUuNzM5KSIvPjxwYXRoIGQ9Im04LjM0Mi" \
+        "AwaC0yLjc1N2E1LjU4NSA1LjU4NSAwIDAgMCAtNS41ODUgNS41ODV2Mi43NTdoOC4zNDJ6Ii8+PHBhdGggZD0ibTAg" \
+        "Ny41OWg4LjM0MnY4LjM0MmgtOC4zNDJ6IiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgwIDUuNzM5KSIvPjxwYXRoIGQ9" \
+        "Im0xNS4xOCAyMy40NTFoMi43NTdhNS41ODUgNS41ODUgMCAwIDAgNS41ODUtNS42di0yLjY3MWgtOC4zNDJ6IiB0" \
+        "cmFuc2Zvcm09InRyYW5zbGF0ZSgxMS40NzggMTEuNDc4KSIvPjxwYXRoIGQ9Im03LjU5IDE1LjE4aDguMzQydjgu" \
+        "MzQyaC04LjM0MnoiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDUuNzM5IDExLjQ3OCkiLz48cGF0aCBkPSJtMCAxNS4x" \
+        "OHYyLjc1N2E1LjU4NSA1LjU4NSAwIDAgMCA1LjU4NSA1LjU4NWgyLjc1N3YtOC4zNDJ6IiB0cmFuc2Zvcm09InRy" \
+        "YW5zbGF0ZSgwIDExLjQ3OCkiLz48L2c+PC9zdmc+",
+        String
+      )
+
+      sig { override.returns(String) }
+      def name = "Ledger"
+
+      sig { override.returns(String) }
+      def url = "https://ledger.com"
+
+      sig { override.returns(String) }
+      def icon = LEDGER_ICON
+
+      sig { override.returns(WalletReadyState) }
+      def ready_state = WalletReadyState::Unsupported
+
+      sig { override.returns(T.nilable(PublicKey)) }
+      def public_key = nil
+
+      sig { override.returns(T::Boolean) }
+      def connecting? = false
+
+      sig { override.returns(SupportedTransactionVersions) }
+      def supported_transaction_versions
+        Set[TransactionVersion::Legacy, TransactionVersion::Version0].freeze
+      end
+
+      sig { override.void }
+      def connect
+        raise WalletNotReadyError, "#{name} connection is initiated in the browser via USB/Bluetooth"
+      end
+
+      sig { override.void }
+      def disconnect; end
+
+      sig do
+        override
+          .params(transaction: Transaction, rpc_url: String, options: SendTransactionOptions)
+          .returns(String)
+      end
+      def send_transaction(transaction, rpc_url, options = SendTransactionOptions.new)
+        raise WalletNotConnectedError, "send_transaction must use a pre-signed transaction server-side"
+      end
+
+      sig { override.params(transaction: Transaction).returns(Transaction) }
+      def sign_transaction(transaction)
+        raise WalletNotConnectedError, "sign_transaction must be performed client-side by the Ledger device"
+      end
+
+      sig { override.params(transactions: T::Array[Transaction]).returns(T::Array[Transaction]) }
+      def sign_all_transactions(transactions)
+        raise WalletNotConnectedError, "sign_all_transactions must be performed client-side"
+      end
+    end
+  end
+end

data/lib/solana_wallet_adapter/wallets/phantom.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+# typed: strict
+
+module SolanaWalletAdapter
+  module Wallets
+    # Server-side metadata adapter for the Phantom wallet.
+    #
+    # In a Rails app the "connecting" lifecycle is handled in the browser by
+    # the Phantom extension / app.  This class provides:
+    #   - Wallet metadata (name, icon, url) for frontend consumption.
+    #   - A stub implementation of the abstract interface so instances can be
+    #     registered in WalletRegistry and serialised to JSON.
+    #   - Optional override points for custom server-side send_transaction /
+    #     sign_message if you choose to proxy those calls through the server.
+    #
+    # For a full round-trip flow:
+    #   1. Render wallet metadata to the frontend via WalletRegistry.to_json_array.
+    #   2. The browser connects to Phantom and obtains a public key + signature.
+    #   3. POST both to a Rails controller.
+    #   4. Verify server-side with SignatureVerifier.
+    class PhantomWalletAdapter < BaseMessageSignerWalletAdapter
+      extend T::Sig
+
+      PHANTOM_ICON = T.let(
+        "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMDgi" \
+        "IGhlaWdodD0iMTA4IiB2aWV3Qm94PSIwIDAgMTA4IDEwOCIgZmlsbD0ibm9uZSI+CjxyZWN0IHdpZHRoPSIxMDgi" \
+        "IGhlaWdodD0iMTA4IiByeD0iMjYiIGZpbGw9IiNBQjlGRjIiLz4KPHBhdGggZmlsbC1ydWxlPSJldmVub2RkIiBj" \
+        "bGlwLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik00Ni41MjY3IDY5LjkyMjlDNDIuMDA1NCA3Ni44NTA5IDM0LjQyOTIgODUu" \
+        "NjE4MiAyNC4zNDggODUuNjE4MkMxOS41ODI0IDg1LjYxODIgMTUgODMuNjU2MyAxNSA3NS4xMzQyQzE1IDUzLjQz" \
+        "MDUgNDQuNjMyNiAxOS44MzI3IDcyLjEyNjggMTkuODMyN0M4Ny43NjggMTkuODMyNyA5NCAzMC42ODQ2IDk0IDQz" \
+        "LjAwNzlDOTQgNTguODI1OCA4My43MzU1IDc2LjkxMjIgNzMuNTMyMSA3Ni45MTIyQzcwLjI5MzkgNzYuOTEyMiA2" \
+        "OC43MDUzIDc1LjEzNDIgNjguNzA1MyA3Mi4zMTRDNjguNzA1MyA3MS41NzgzIDY4LjgyNzUgNzAuNzgxMiA2OS4w" \
+        "NzE5IDY5LjkyMjlDNjUuNTg5MyA3NS44Njk5IDU4Ljg2ODUgODEuMzg3OCA1Mi41NzU0IDgxLjM4NzhDNDcuOTkz" \
+        "IDgxLjM4NzggNDUuNjcxMyA3OC41MDYzIDQ1LjY3MTMgNzQuNDU5OEM0NS42NzEzIDcyLjk4ODQgNDUuOTc2OCA3" \
+        "MS40NTU2IDQ2LjUyNjcgNjkuOTIyOVpNODMuNjc2MSA0Mi41Nzk0QzgzLjY3NjEgNDYuMTcwNCA4MS41NTc1IDQ3" \
+        "Ljk2NTggNzkuMTg3NSA0Ny45NjU4Qzc2Ljc4MTYgNDcuOTY1OCA3NC42OTg5IDQ2LjE3MDQgNzQuNjk4OSA0Mi41" \
+        "Nzk0Qzc0LjY5ODkgMzguOTg4NSA3Ni43ODE2IDM3LjE5MzEgNzkuMTg3NSAzNy4xOTMxQzgxLjU1NzUgMzcuMTkz" \
+        "MSA4My42NzYxIDM4Ljk4ODUgODMuNjc2MSA0Mi41Nzk0Wk03MC4yMTAzIDQyLjU3OTVDNzAuMjEwMyA0Ni4xNzA0" \
+        "IDY4LjA5MTYgNDcuOTY1OCA2NS43MjE2IDQ3Ljk2NThDNjMuMzE1NyA0Ny45NjU4IDYxLjIzMyA0Ni4xNzA0IDYx" \
+        "LjIzMyA0Mi41Nzk1QzYxLjIzMyAzOC45ODg1IDYzLjMxNTcgMzcuMTkzMSA2NS43MjE2IDM3LjE5MzFDNjguMDkx" \
+        "NiAzNy4xOTMxIDcwLjIxMDMgMzguOTg4NSA3MC4yMTAzIDQyLjU3OTVaIiBmaWxsPSIjRkZGREY4Ii8+Cjwvc3Zn" \
+        "Pg==",
+        String
+      )
+
+      sig { override.returns(String) }
+      def name = "Phantom"
+
+      sig { override.returns(String) }
+      def url = "https://phantom.app"
+
+      sig { override.returns(String) }
+      def icon = PHANTOM_ICON
+
+      sig { override.returns(WalletReadyState) }
+      def ready_state = WalletReadyState::Unsupported
+
+      sig { override.returns(T.nilable(PublicKey)) }
+      def public_key = nil
+
+      sig { override.returns(T::Boolean) }
+      def connecting? = false
+
+      sig { override.returns(SupportedTransactionVersions) }
+      def supported_transaction_versions
+        Set[TransactionVersion::Legacy, TransactionVersion::Version0].freeze
+      end
+
+      # Server-side adapters do not initiate connections directly.
+      sig { override.void }
+      def connect
+        raise WalletNotReadyError,
+              "PhantomWalletAdapter is a server-side adapter; connection is initiated in the browser"
+      end
+
+      sig { override.void }
+      def disconnect
+        # no-op on server side
+      end
+
+      # send_transaction is inherited from BaseSignerWalletAdapter and will
+      # forward raw bytes to the RPC endpoint. Override here if you need
+      # custom logic (e.g. a different commitment level for Phantom).
+      sig do
+        override
+          .params(
+            transaction: Transaction,
+            rpc_url:     String,
+            options:     SendTransactionOptions
+          )
+          .returns(String)
+      end
+      def send_transaction(transaction, rpc_url, options = SendTransactionOptions.new)
+        raise WalletNotConnectedError,
+              "send_transaction must be called with a pre-signed transaction on the server side"
+      end
+
+      # Server-side adapters cannot sign – signing is done in the browser.
+      sig { override.params(transaction: Transaction).returns(Transaction) }
+      def sign_transaction(transaction)
+        raise WalletNotConnectedError,
+              "sign_transaction must be performed client-side by the Phantom extension"
+      end
+
+      sig { override.params(transactions: T::Array[Transaction]).returns(T::Array[Transaction]) }
+      def sign_all_transactions(transactions)
+        raise WalletNotConnectedError,
+              "sign_all_transactions must be performed client-side by the Phantom extension"
+      end
+
+      sig { override.params(message: String).returns(String) }
+      def sign_message(message)
+        raise WalletNotConnectedError,
+              "sign_message must be performed client-side by the Phantom extension"
+      end
+    end
+  end
+end

data/lib/solana_wallet_adapter/wallets/solflare.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+# typed: strict
+
+module SolanaWalletAdapter
+  module Wallets
+    class SolflareWalletAdapter < BaseMessageSignerWalletAdapter
+      extend T::Sig
+
+      SOLFLARE_ICON = T.let(
+        "data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz48c3ZnIGlkPSJTIiB4bWxucz0i" \
+        "aHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA1MCA1MCI+PGRlZnM+PHN0eWxlPi5jbHMt" \
+        "MXtmaWxsOiMwMjA1MGE7c3Ryb2tlOiNmZmVmNDY7c3Ryb2tlLW1pdGVybGltaXQ6MTA7c3Ryb2tlLXdpZHRoOi41" \
+        "cHg7fS5jbHMtMntmaWxsOiNmZmVmNDY7fTwvc3R5bGU+PC9kZWZzPjxyZWN0IGNsYXNzPSJjbHMtMiIgeD0iMCIg" \
+        "d2lkdGg9IjUwIiBoZWlnaHQ9IjUwIiByeD0iMTIiIHJ5PSIxMiIvPjxwYXRoIGNsYXNzPSJjbHMtMSIgZD0iTTI0" \
+        "LjIzLDI2LjQybDIuNDYtMi4zOCw0LjU5LDEuNWMzLjAxLDEsNC41MSwyLjg0LDQuNTEsNS40MywwLDEuOTYtLjc1" \
+        "LDMuMjYtMi4yNSw0LjkzbC0uNDYuNS4xNy0xLjE3Yy42Ny00LjI2LS41OC02LjA5LTQuNzItNy40M2wtNC4zLTEu" \
+        "MzhoMFpNMTguMDUsMTEuODVsMTIuNTIsNC4xNy0yLjcxLDIuNTktNi41MS0yLjE3Yy0yLjI1LS43NS0zLjAxLTEu" \
+        "OTYtMy4zLTQuNTF2LS4wOGgwWk0xNy4zLDMzLjA2bDIuODQtMi43MSw1LjM0LDEuNzVjMi44LjkyLDMuNzYsMi4x" \
+        "MywzLjQ2LDUuMThsLTExLjY1LTQuMjJoMFpNMTMuNzEsMjAuOTVjMC0uNzkuNDItMS41NCwxLjEzLTIuMTcuNzUs" \
+        "MS4wOSwyLjA1LDIuMDUsNC4wOSwyLjcxbDQuNDIsMS40Ni0yLjQ2LDIuMzgtNC4zNC0xLjQyYy0yLS42Ny0yLjg0" \
+        "LTEuNjctMi44NC0yLjk2TTI2LjgyLDQyLjg3YzkuMTgtNi4wOSwxNC4xMS0xMC4yMywxNC4xMS0xNS4zMiwwLTMu" \
+        "MzgtMi01LjI2LTYuNDMtNi43MmwtMy4zNC0xLjEzLDkuMTQtOC43Ny0xLjg0LTEuOTYtMi43MSwyLjM4LTEyLjgx" \
+        "LTQuMjJjLTMuOTcsMS4yOS04Ljk3LDUuMDktOC45Nyw4Ljg5LDAsLjQyLjA0LjgzLjE3LDEuMjktMy4zLDEuODgt" \
+        "NC42MywzLjYzLTQuNjMsNS44LDAsMi4wNSwxLjA5LDQuMDksNC41NSw1LjIybDIuNzUuOTItOS41Miw5LjE0LDEu" \
+        "ODQsMS45NiwyLjk2LTIuNzEsMTQuNzMsNS4yMmgwWiIvPjwvc3ZnPg==",
+        String
+      )
+
+      sig { override.returns(String) }
+      def name = "Solflare"
+
+      sig { override.returns(String) }
+      def url = "https://solflare.com"
+
+      sig { override.returns(String) }
+      def icon = SOLFLARE_ICON
+
+      sig { override.returns(WalletReadyState) }
+      def ready_state = WalletReadyState::Unsupported
+
+      sig { override.returns(T.nilable(PublicKey)) }
+      def public_key = nil
+
+      sig { override.returns(T::Boolean) }
+      def connecting? = false
+
+      sig { override.returns(SupportedTransactionVersions) }
+      def supported_transaction_versions
+        Set[TransactionVersion::Legacy, TransactionVersion::Version0].freeze
+      end
+
+      sig { override.void }
+      def connect
+        raise WalletNotReadyError, "#{name} connection is initiated in the browser"
+      end
+
+      sig { override.void }
+      def disconnect; end
+
+      sig do
+        override
+          .params(transaction: Transaction, rpc_url: String, options: SendTransactionOptions)
+          .returns(String)
+      end
+      def send_transaction(transaction, rpc_url, options = SendTransactionOptions.new)
+        raise WalletNotConnectedError, "send_transaction must use a pre-signed transaction server-side"
+      end
+
+      sig { override.params(transaction: Transaction).returns(Transaction) }
+      def sign_transaction(transaction)
+        raise WalletNotConnectedError, "sign_transaction must be performed client-side"
+      end
+
+      sig { override.params(transactions: T::Array[Transaction]).returns(T::Array[Transaction]) }
+      def sign_all_transactions(transactions)
+        raise WalletNotConnectedError, "sign_all_transactions must be performed client-side"
+      end
+
+      sig { override.params(message: String).returns(String) }
+      def sign_message(message)
+        raise WalletNotConnectedError, "sign_message must be performed client-side"
+      end
+    end
+  end
+end