solana-ruby-wallet-adapter

gem "solana_ruby_wallet_adapter"

# config/initializers/solana_wallet_adapter.rb
SolanaWalletAdapter::WalletRegistry.register(
  SolanaWalletAdapter::Wallets::PhantomWalletAdapter,
  SolanaWalletAdapter::Wallets::SolflareWalletAdapter,
  SolanaWalletAdapter::Wallets::LedgerWalletAdapter,
  SolanaWalletAdapter::Wallets::CoinbaseWalletAdapter,
  SolanaWalletAdapter::Wallets::WalletConnectWalletAdapter,
)

# config/routes.rb
get "/wallets", to: "wallets#index"

# app/controllers/wallets_controller.rb
class WalletsController < ApplicationController
  def index
    render json: SolanaWalletAdapter::WalletRegistry.to_json_array
  end
end

# app/controllers/wallet_sessions_controller.rb
class WalletSessionsController < ApplicationController
  # GET /wallet_sessions/new
  # Returns a nonce for the client to include in the message it signs.
  def new
    session[:wallet_nonce] = SecureRandom.hex(16)
    render json: { nonce: session[:wallet_nonce] }
  end

  # POST /wallet_sessions
  # Body: { public_key: "...", message: "...", signature: "..." }
  def create
    expected_message = "Sign in to MyApp\nNonce: #{session[:wallet_nonce]}"

    unless params[:message] == expected_message
      return render json: { error: "Message mismatch" }, status: :unprocessable_entity
    end

    verify_wallet_signature!(
      public_key_b58: params.require(:public_key),
      message:        params.require(:message),
      signature_b64:  params.require(:signature),   # Base64-encoded 64-byte signature
    )

    session[:wallet_public_key] = params[:public_key]
    session.delete(:wallet_nonce)

    render json: { ok: true, public_key: params[:public_key] }

  rescue SolanaWalletAdapter::WalletSignMessageError => e
    render json: { error: "Invalid signature: #{e.message}" }, status: :unauthorized
  end

  # DELETE /wallet_sessions
  def destroy
    session.delete(:wallet_public_key)
    head :no_content
  end
end

# GET /siws/challenge
# Returns the SIWS message string and the input fields needed to verify later.
def challenge
  input = SolanaWalletAdapter::SignInInput.new(
    domain:    request.host,
    address:   params.require(:address),   # wallet public key (Base58)
    statement: "Sign in to #{Rails.application.class.module_parent_name}",
    uri:       root_url,
    version:   "1",
    nonce:     SecureRandom.hex(16),
    issued_at: Time.now.utc.iso8601,
    expiration_time: 10.minutes.from_now.utc.iso8601,
  )

  # Store the input in the session so the verify step can reconstruct it.
  session[:siws_input] = {
    domain:          input.domain,
    address:         input.address,
    statement:       input.statement,
    uri:             input.uri,
    version:         input.version,
    nonce:           input.nonce,
    issued_at:       input.issued_at,
    expiration_time: input.expiration_time,
  }

  render json: { message: input.to_message, input: session[:siws_input] }
end

# POST /siws/verify
# Body: { output: { address:, signed_message:, signature: } }
def verify
  stored_input = session[:siws_input]
  return render json: { error: "No active SIWS challenge" }, status: :bad_request if stored_input.nil?

  verify_sign_in!(
    input_params:  stored_input,
    output_params: params.require(:output).to_unsafe_h,
    # output must contain:
    #   address:        the signer's Base58 public key
    #   signed_message: the exact SIWS message that was signed (UTF-8 string)
    #   signature:      Base64-encoded 64-byte Ed25519 signature
  )

  session[:wallet_public_key] = params.dig(:output, :address)
  session.delete(:siws_input)

  render json: { ok: true }

rescue SolanaWalletAdapter::WalletSignInError => e
  render json: { error: e.message }, status: :unauthorized
end

# POST /transactions
# Body: { signed_tx: "<Base64-encoded serialised transaction>" }
def submit
  raw_bytes = Base64.strict_decode64(params.require(:signed_tx))
  tx        = SolanaWalletAdapter::Transaction.new(raw_bytes)

  rpc_url   = SolanaWalletAdapter::Network::MainnetBeta.rpc_url
  options   = SolanaWalletAdapter::SendTransactionOptions.new(
    skip_preflight:       false,
    preflight_commitment: "confirmed",
  )

  # BaseSignerWalletAdapter#send_raw_transaction posts the bytes to the RPC.
  # Since the tx is already signed, instantiate a pass-through adapter helper:
  signature = SolanaWalletAdapter::RpcClient.new(rpc_url).send_raw_transaction(raw_bytes, options)

  render json: { signature: signature }
rescue SolanaWalletAdapter::WalletSendTransactionError => e
  render json: { error: e.message }, status: :unprocessable_entity
end

adapter = SolanaWalletAdapter::Wallets::PhantomWalletAdapter.new
# (internal method, exposed here for illustration)
signature = adapter.send(:send_raw_transaction, raw_bytes, rpc_url, options)

# config/initializers/solana_ruby_kit.rb
Solana::Ruby::Kit.configure do |config|
  if Rails.env.production?
    config.rpc_url = "https://mainnet.helius-rpc.com/?api-key=#{ENV.fetch('HELIUS_API_KEY')}"
    config.ws_url  = "wss://mainnet.helius-rpc.com/?api-key=#{ENV.fetch('HELIUS_API_KEY')}"
  else
    config.rpc_url = "https://devnet.helius-rpc.com/?api-key=#{ENV.fetch('HELIUS_API_KEY')}"
    config.ws_url  = "wss://devnet.helius-rpc.com/?api-key=#{ENV.fetch('HELIUS_API_KEY')}"
  end
  config.commitment = :confirmed
  config.timeout    = 30
end

# config/initializers/solana_wallet_adapter.rb
SolanaWalletAdapter::WalletRegistry.register(
  SolanaWalletAdapter::Wallets::PhantomWalletAdapter,
  SolanaWalletAdapter::Wallets::SolflareWalletAdapter,
  SolanaWalletAdapter::Wallets::LedgerWalletAdapter,
  SolanaWalletAdapter::Wallets::CoinbaseWalletAdapter,
  SolanaWalletAdapter::Wallets::WalletConnectWalletAdapter,
)

# app/controllers/staking_controller.rb
require 'base64'

class StakingController < ApplicationController
  VOTE_ACCOUNT = '26RGqX3mezgYDxJnGh94gnMM4L2k9grH1eWcTSCHnaxR'

  # POST /staking/prepare
  # Builds and partially signs a stake transaction server-side.
  # Returns a base64-encoded wire transaction ready for the user's wallet to sign.
  def prepare
    public_key = params.require(:public_key)
    lamports   = (params.require(:sol).to_f * 1_000_000_000).to_i

    rpc              = Solana::Ruby::Kit.rpc_client
    blockhash_result = rpc.get_latest_blockhash
    blockhash        = blockhash_result.value.blockhash
    last_valid       = blockhash_result.value.last_valid_block_height

    owner         = Solana::Ruby::Kit::Addresses::Address.new(public_key)
    stake_kp      = Solana::Ruby::Kit::Keys.generate_key_pair
    stake_address = Solana::Ruby::Kit::Addresses::Address.new(
      Solana::Ruby::Kit::Addresses.encode_address(stake_kp.verify_key.to_bytes)
    )

    create_ixs = Solana::Ruby::Kit::Programs::StakeProgram.create_account_instructions(
      from:          owner,
      stake_account: stake_address,
      authorized:    owner,
      lamports:      lamports
    )

    delegate_ix = Solana::Ruby::Kit::Programs::StakeProgram.delegate_instruction(
      stake_account: stake_address,
      vote_account:  Solana::Ruby::Kit::Addresses::Address.new(VOTE_ACCOUNT),
      authorized:    owner
    )

    message = Solana::Ruby::Kit::TransactionMessages::TransactionMessage.new(
      version:             :legacy,
      instructions:        create_ixs + [delegate_ix],
      fee_payer:           owner,
      lifetime_constraint: Solana::Ruby::Kit::TransactionMessages::BlockhashLifetimeConstraint.new(
        blockhash:               blockhash,
        last_valid_block_height: last_valid
      )
    )

    tx = Solana::Ruby::Kit::Transactions.compile_transaction_message(message)
    tx = Solana::Ruby::Kit::Transactions.partially_sign_transaction([stake_kp.signing_key], tx)

    wire_bytes = Solana::Ruby::Kit::Transactions.wire_encode_transaction(tx)
    render json: { transaction: Base64.strict_encode64(wire_bytes) }
  rescue => e
    render json: { error: e.message }, status: :unprocessable_entity
  end

  # POST /staking/submit
  # Receives a wallet-signed transaction (base64 wire bytes), verifies every
  # Ed25519 signature server-side via WalletStandard, then broadcasts to the
  # cluster and returns the transaction signature.
  def submit
    signed_b64 = params.require(:signed_transaction)
    wire_bytes = Base64.strict_decode64(signed_b64)

    tx = Solana::Ruby::Kit::WalletStandard.verify_signed_transaction!(wire_bytes)
    Solana::Ruby::Kit::Transactions.assert_fully_signed_transaction!(tx)

    rpc = Solana::Ruby::Kit.rpc_client
    sig = rpc.send_transaction(signed_b64)

    render json: { signature: sig.value }
  rescue => e
    render json: { error: e.message }, status: :unprocessable_entity
  end
end

# config/routes.rb
post '/staking/prepare', to: 'staking#prepare'
post '/staking/submit',  to: 'staking#submit'

# From a Base58 string (most common – what wallets return)
pk = SolanaWalletAdapter::PublicKey.new("9noXzpXnLTia8oBHFMza9tqPuFvPpRCtAfJmZeoBc7x2")
pk.to_base58   # => "9noXzpXnLTia8oBHFMza9tqPuFvPpRCtAfJmZeoBc7x2"
pk.to_bytes    # => [138, 12, ...]   Array of 32 integers
pk.bytes       # => "\x8a\x0c..."   raw 32-byte binary String

# From a raw binary string (e.g. decoded from a transaction)
pk = SolanaWalletAdapter::PublicKey.new("\x00" * 32)

# From a Uint8Array-style Integer array
pk = SolanaWalletAdapter::PublicKey.new([0] * 32)

# Equality
pk1 = SolanaWalletAdapter::PublicKey.new("11111111111111111111111111111111")
pk2 = SolanaWalletAdapter::PublicKey.new([0] * 32)
pk1 == pk2   # => true  (System Program address)

net = SolanaWalletAdapter::Network::MainnetBeta
net.serialize   # => "mainnet-beta"
net.rpc_url     # => "https://api.mainnet-beta.solana.com"

SolanaWalletAdapter::Network::Devnet.rpc_url
# => "https://api.devnet.solana.com"

SolanaWalletAdapter::Network::Testnet.rpc_url
# => "https://api.testnet.solana.com"

# typed: strict
# app/solana/my_custom_wallet_adapter.rb

class MyCustomWalletAdapter < SolanaWalletAdapter::BaseMessageSignerWalletAdapter
  extend T::Sig

  sig { override.returns(String) }
  def name = "MyWallet"

  sig { override.returns(String) }
  def url = "https://mywallet.example.com"

  sig { override.returns(String) }
  def icon = "data:image/svg+xml;base64,PHN2Zy..."

  sig { override.returns(SolanaWalletAdapter::WalletReadyState) }
  def ready_state = SolanaWalletAdapter::WalletReadyState::Unsupported

  sig { override.returns(T.nilable(SolanaWalletAdapter::PublicKey)) }
  def public_key = nil

  sig { override.returns(T::Boolean) }
  def connecting? = false

  sig { override.returns(SolanaWalletAdapter::SupportedTransactionVersions) }
  def supported_transaction_versions
    Set[
      SolanaWalletAdapter::TransactionVersion::Legacy,
      SolanaWalletAdapter::TransactionVersion::Version0,
    ].freeze
  end

  sig { override.void }
  def connect
    raise SolanaWalletAdapter::WalletNotReadyError,
          "#{name} connection is initiated in the browser"
  end

  sig { override.void }
  def disconnect; end

  sig do
    override
      .params(
        transaction: SolanaWalletAdapter::Transaction,
        rpc_url:     String,
        options:     SolanaWalletAdapter::SendTransactionOptions,
      )
      .returns(String)
  end
  def send_transaction(transaction, rpc_url, options = SolanaWalletAdapter::SendTransactionOptions.new)
    raise SolanaWalletAdapter::WalletNotConnectedError
  end

  sig { override.params(transaction: SolanaWalletAdapter::Transaction).returns(SolanaWalletAdapter::Transaction) }
  def sign_transaction(transaction)
    raise SolanaWalletAdapter::WalletNotConnectedError
  end

  sig { override.params(transactions: T::Array[SolanaWalletAdapter::Transaction]).returns(T::Array[SolanaWalletAdapter::Transaction]) }
  def sign_all_transactions(transactions)
    raise SolanaWalletAdapter::WalletNotConnectedError
  end

  sig { override.params(message: String).returns(String) }
  def sign_message(message)
    raise SolanaWalletAdapter::WalletNotConnectedError
  end
end

# config/initializers/solana_wallet_adapter.rb
SolanaWalletAdapter::WalletRegistry.register(MyCustomWalletAdapter)

raise SolanaWalletAdapter::WalletConnectionError.new("Could not connect", original_exception)

WalletRegistry.register(*adapter_classes)   # register one or more adapter classes
WalletRegistry.all                          # => Array of adapter classes
WalletRegistry.find("Phantom")              # => PhantomWalletAdapter class or nil
WalletRegistry.to_json_array               # => Array<Hash> ready for JSON serialisation
WalletRegistry.reset!                       # clear all (useful in tests)

verifier = SolanaWalletAdapter::SignatureVerifier.new

# Returns true/false
verifier.verify(public_key: pk, message: msg, signature: sig)

# Raises WalletSignMessageError on failure
verifier.verify!(public_key: pk, message: msg, signature: sig)

# Raises WalletSignInError on failure
verifier.verify_sign_in!(input: sign_in_input, output: sign_in_output)

input = SolanaWalletAdapter::SignInInput.new(
  domain:          "example.com",          # required
  address:         "9noX...",              # required – Base58 public key
  statement:       "Sign in to MyApp",     # optional
  uri:             "https://example.com/", # optional
  version:         "1",                    # default "1"
  nonce:           "abc123",               # optional but recommended
  issued_at:       Time.now.utc.iso8601,   # optional
  expiration_time: 10.minutes.from_now.utc.iso8601, # optional
  not_before:      nil,                    # optional
  request_id:      nil,                    # optional
  resources:       [],                     # optional Array<String>
)

input.to_message   # => canonical SIWS message string to sign

SolanaWalletAdapter::PublicKey.new(base58_string)
SolanaWalletAdapter::PublicKey.new(binary_string)   # 32-byte binary
SolanaWalletAdapter::PublicKey.new(integer_array)   # 32-element Array<Integer>

pk.to_base58   # => String
pk.to_bytes    # => Array<Integer>
pk.bytes       # => String (binary)
pk == other_pk # => Boolean

SolanaWalletAdapter::Transaction.new(wire_bytes, version: nil)

tx.versioned?   # => true for Version0, false for Legacy/nil
tx.serialize    # => wire_bytes
tx.version      # => TransactionVersion or nil

SolanaWalletAdapter::SendTransactionOptions.new(
  signers:               [],          # Array<String> additional signer keypairs
  preflight_commitment:  "confirmed", # String or nil
  skip_preflight:        false,
  max_retries:           nil,
  min_context_slot:      nil,
)