solana_ruby_wallet_adapter 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a0e9caf19e2a18ea8c6c910d69b21a97391c7f52ad77997a069ef8dd8665c4c
-  data.tar.gz: cf3ec248114950685f094a702eb0a9b4a89eea60086f8d5547a78d71c4a24514
+  metadata.gz: 51811ed20a2a99f1c970eb5fefbaef2d8186355df44758ea919964df3ac561af
+  data.tar.gz: 8c8b14961ddcf9838ebfdaea5a73f42cff8a683ee76bd4603a69eeaa630f4f13
 SHA512:
-  metadata.gz: 76a89389d97d4708aa3257bce24933e8d439651efc6aa7be58a02f39276e10baadcec6e1c5a69faecae3fea1428aae106bf48b6231fa4fa4dc5311cf2a77e520
-  data.tar.gz: 2e963b0f4e6c5aa70033d1563cccecfefca59bd6dbffc576d07bb16be1bf16cbfa0a8183fde81ee66be3bdce5d10223163d8b02b2f7bad2874ccc8346c394705
+  metadata.gz: 3de9b50d9b861222d103dcaf7f06616a26f8447bed66bf4d433afbce15e2326732f52a29a91c4bbc740e832f56a9d0546c9f44983aa14ef3c3d6a3521e406741
+  data.tar.gz: 8d2d223f9be47268939f5c4b99d3d20cca149f22a9ebd771c036191167277e7da466837a6576dda773708a664ee781dd5840a0656363d9bc03707f635ef2df47

data/README.md

@@ -21,8 +21,9 @@ Provides:
    - [Simple message signing](#2-simple-message-signing-authentication)
    - [Sign-In-With-Solana (SIWS)](#3-sign-in-with-solana-siws)
    - [Send a pre-signed transaction](#4-send-a-pre-signed-transaction)
-   - [Working with public keys](#5-working-with-public-keys)
-   - [Networks](#6-networks)
+   - [Server-built stake transaction (React-free Rails + Stimulus)](#5-server-built-stake-transaction-react-free-rails--stimulus)
+   - [Working with public keys](#6-working-with-public-keys)
+   - [Networks](#7-networks)
 4. [Writing a custom adapter](#writing-a-custom-adapter)
 5. [Error reference](#error-reference)
 6. [API reference](#api-reference)
@@ -349,7 +350,313 @@ signature = adapter.send(:send_raw_transaction, raw_bytes, rpc_url, options)
 
 ---
 
-### 5. Working with public keys
+### 5. Server-built stake transaction (React-free Rails + Stimulus)
+
+This example shows how to build a Solana staking UI without React.
+The transaction is constructed and partially signed on the server using
+[solana-ruby-kit](https://github.com/pzupan/solana-ruby-kit), then sent to
+the browser for the user's wallet signature.  This gem seeds the wallet
+picker and handles any server-side signature work.
+
+**Flow:**
+1. Rails layout seeds registered wallet metadata into `window.__SOLANA_WALLETS__`.
+2. A Stimulus controller detects the wallet, connects, and collects the SOL amount.
+3. The browser POSTs `{ public_key, sol }` to `/staking/prepare`.
+4. The Rails controller builds a `createAccount + delegate` transaction,
+   partially signs it with the generated stake-account keypair, and returns
+   the wire bytes as Base64.
+5. The Stimulus controller passes the bytes to the wallet for the user's signature.
+6. The signed wire bytes are POSTed to `/staking/submit`.
+7. Rails verifies every Ed25519 signature via `WalletStandard`, then broadcasts
+   to the cluster and returns the transaction signature.
+
+#### Environment — RPC credentials
+
+Store your RPC API key in `.env` (already gitignored by Rails):
+
+```
+# .env
+HELIUS_API_KEY=your-api-key-here
+```
+
+#### Initializer — configure solana-ruby-kit and register adapters
+
+```ruby
+# 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
+```
+
+```ruby
+# config/initializers/solana_wallet_adapter.rb
+SolanaWalletAdapter::WalletRegistry.register(
+  SolanaWalletAdapter::Wallets::PhantomWalletAdapter,
+  SolanaWalletAdapter::Wallets::SolflareWalletAdapter,
+  SolanaWalletAdapter::Wallets::LedgerWalletAdapter,
+  SolanaWalletAdapter::Wallets::CoinbaseWalletAdapter,
+  SolanaWalletAdapter::Wallets::WalletConnectWalletAdapter,
+)
+```
+
+#### Layout — seed wallet metadata
+
+```erb
+<%# app/views/layouts/application.html.erb %>
+<head>
+  <%# ... %>
+  <script>window.__SOLANA_WALLETS__ = <%= solana_wallets_json.html_safe %>;</script>
+</head>
+```
+
+#### Rails controller — build, verify, and broadcast
+
+`Solana::Ruby::Kit.rpc_client` picks up the URL configured in the initializer.
+`WalletStandard.verify_signed_transaction!` decodes the wire bytes returned by
+the browser wallet and verifies every Ed25519 signature before broadcasting.
+
+```ruby
+# 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
+```
+
+#### Routes
+
+```ruby
+# config/routes.rb
+post '/staking/prepare', to: 'staking#prepare'
+post '/staking/submit',  to: 'staking#submit'
+```
+
+#### ViewComponent — Stimulus markup
+
+```erb
+<%# app/components/stake_button/show_component.html.erb %>
+<div data-controller="stake">
+  <button
+    class="btn btn-outline-primary w-100 mb-3"
+    data-action="click->stake#connectWallet"
+    data-stake-target="connectButton">
+    Select Wallet
+  </button>
+
+  <input
+    type="number"
+    class="form-control mb-3"
+    data-stake-target="input"
+    disabled
+    value="1"
+    min="0.01"
+    step="0.01"
+  />
+
+  <button
+    class="btn btn-primary w-100"
+    data-action="click->stake#stake"
+    data-stake-target="stakeButton"
+    disabled>
+    Stake Now
+  </button>
+
+  <p class="mt-2 small text-muted" data-stake-target="status"></p>
+</div>
+```
+
+#### Stimulus controller — wallet connection and signing
+
+The signed transaction is POSTed back to Rails for server-side verification and
+broadcasting. No RPC credentials are needed in the browser.
+
+```js
+// app/javascript/controllers/stake_controller.js
+import { Controller } from "@hotwired/stimulus"
+import { Transaction } from "@solana/web3.js"
+
+export default class extends Controller {
+  static targets = ["connectButton", "input", "stakeButton", "status"]
+
+  connect() {
+    this.provider  = null
+    this.publicKey = null
+    this.detectWallet()
+  }
+
+  detectWallet() {
+    if (window.phantom?.solana?.isPhantom)  this.provider = window.phantom.solana
+    else if (window.solana?.isPhantom)      this.provider = window.solana
+    else if (window.solflare?.isSolflare)   this.provider = window.solflare
+  }
+
+  async connectWallet() {
+    if (!this.provider) this.detectWallet()
+    if (!this.provider) {
+      this.setStatus("No Solana wallet found. Please install Phantom or Solflare.")
+      return
+    }
+    try {
+      this.setStatus("Connecting…")
+      const resp     = await this.provider.connect()
+      this.publicKey = resp.publicKey.toString()
+      this.connectButtonTarget.textContent =
+        `${this.publicKey.slice(0, 6)}…${this.publicKey.slice(-4)}`
+      this.inputTarget.disabled       = false
+      this.stakeButtonTarget.disabled = false
+      this.setStatus("")
+    } catch (e) {
+      this.setStatus(`Connect failed: ${e.message}`)
+    }
+  }
+
+  async stake() {
+    if (!this.publicKey) return
+
+    const sol = parseFloat(this.inputTarget.value || "0")
+    if (sol <= 0) { this.setStatus("Enter a valid SOL amount."); return }
+
+    this.stakeButtonTarget.disabled = true
+    this.setStatus("Building transaction…")
+
+    try {
+      const csrfToken = document.querySelector("meta[name='csrf-token']").content
+      const resp = await fetch("/staking/prepare", {
+        method:  "POST",
+        headers: { "Content-Type": "application/json", "X-CSRF-Token": csrfToken },
+        body:    JSON.stringify({ public_key: this.publicKey, sol }),
+      })
+      const data = await resp.json()
+      if (data.error) throw new Error(data.error)
+
+      this.setStatus("Awaiting wallet signature…")
+      const txBytes  = Uint8Array.from(atob(data.transaction), c => c.charCodeAt(0))
+      const tx       = Transaction.from(txBytes)
+      const signedTx = await this.provider.signTransaction(tx)
+
+      this.setStatus("Broadcasting…")
+      const signedB64 = btoa(String.fromCharCode(...signedTx.serialize()))
+      const submitResp = await fetch("/staking/submit", {
+        method:  "POST",
+        headers: { "Content-Type": "application/json", "X-CSRF-Token": csrfToken },
+        body:    JSON.stringify({ signed_transaction: signedB64 }),
+      })
+      const submitData = await submitResp.json()
+      if (submitData.error) throw new Error(submitData.error)
+
+      this.setStatus(`Staked! Tx: ${submitData.signature.slice(0, 20)}…`)
+    } catch (e) {
+      this.setStatus(`Error: ${e.message}`)
+      this.stakeButtonTarget.disabled = false
+    }
+  }
+
+  setStatus(msg) {
+    if (this.hasStatusTarget) this.statusTarget.textContent = msg
+  }
+}
+```
+
+#### esbuild — IIFE format required
+
+`@solana/web3.js` uses `import.meta` internally. Bundle as IIFE and define
+`import.meta.url` away so the bundle runs as a plain script (no `type="module"`
+needed):
+
+```json
+// package.json
+"build": "esbuild app/javascript/application.js --bundle --sourcemap --format=iife --define:global=globalThis --define:import.meta.url=undefined --outdir=app/assets/builds --public-path=/assets"
+```
+
+> **Note:** `@solana/web3.js` is still needed in the browser solely to
+> deserialize the server-built transaction (`Transaction.from`) before passing it
+> to the wallet for signing. Broadcasting is handled server-side by
+> `WalletStandard` + `rpc.send_transaction`, so `Connection` and `sendRawTransaction`
+> are not used. All React and `@solana/wallet-adapter-react*` packages can be
+> removed from `package.json`.
+
+---
+
+### 6. Working with public keys
+
 
 ```ruby
 # From a Base58 string (most common – what wallets return)
@@ -372,7 +679,7 @@ pk1 == pk2   # => true  (System Program address)
 
 ---
 
-### 6. Networks
+### 7. Networks
 
 ```ruby
 net = SolanaWalletAdapter::Network::MainnetBeta

data/lib/solana_wallet_adapter/message_signer_adapter.rb

@@ -36,6 +36,8 @@ module SolanaWalletAdapter
 
   # Input parameters for a SIWS sign-in request.
   class SignInInput < T::Struct
+    extend T::Sig
+
     # The domain presenting the sign-in request (e.g. "example.com").
     const :domain,      String
 

data/lib/solana_wallet_adapter/version.rb

@@ -2,5 +2,5 @@
 # typed: strict
 
 module SolanaWalletAdapter
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/solana_wallet_adapter/wallet_registry.rb

@@ -28,7 +28,7 @@ module SolanaWalletAdapter
       extend T::Sig
 
       # Register one or more adapter classes.
-      sig { params(adapter_classes: T::Array[T.class_of(BaseWalletAdapter)]).void }
+      sig { params(adapter_classes: T.class_of(BaseWalletAdapter)).void }
       def register(*adapter_classes)
         adapter_classes.each do |klass|
           instance = klass.new

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: solana_ruby_wallet_adapter
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - pzupan
 bindir: bin
 cert_chain: []
-date: 2026-04-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -177,7 +177,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Modular Solana wallet adapters for Ruby on Rails
 test_files: []