solrengine-rpc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6153fbe152baa967ab457bd1cb90c16b978c9e270bdff09e087f2f85298fde6d
+  data.tar.gz: b7a4c693fae301f5c2faf511507a1864e3bdc7e280f1331c426739fd03428efa
+SHA512:
+  metadata.gz: 9e9192a9993b141904b5af5d539c0dd4a220d969ebdd075778c006cfab8826e9bbdba5e3b61a9b83ce89892d7bd5090c38356e4b60a0fcd8df47e54f3f40ccf0
+  data.tar.gz: ebac91864b9821fc2a1b3283b4a5ec60dea5cea930b9a4a676ec04312081ebd127cf48283a63097a89139ef1a588ec55bdb4199f59beb418cbc01e6715f69706

data/README.md

@@ -0,0 +1,49 @@
+# SolRengine RPC
+
+Solana JSON-RPC client for Ruby. Handles balance queries, token accounts, signatures, transactions, and blockhash — with SSL CRL tolerance and multi-network support.
+
+Part of the [SolRengine](https://github.com/solrengine) framework.
+
+## Install
+
+```ruby
+gem "solrengine-rpc"
+```
+
+## Usage
+
+```ruby
+client = Solrengine::Rpc.client
+
+client.get_balance("Abc...xyz")           # => 2.5 (SOL)
+client.get_token_accounts("Abc...xyz")    # => [{ mint:, ui_amount:, ... }]
+client.get_recent_signatures("Abc...xyz") # => [{ signature:, block_time:, ... }]
+client.get_latest_blockhash               # => "abc123..."
+client.get_signature_status("sig...")     # => { "confirmationStatus" => "finalized" }
+client.get_transaction("sig...")          # => { full tx details }
+```
+
+## Configuration
+
+```ruby
+Solrengine::Rpc.configure do |config|
+  config.network = "mainnet"  # or "devnet", "testnet"
+  config.rpc_url = "https://mainnet.helius-rpc.com/?api-key=YOUR_KEY"
+  config.ws_url  = "wss://mainnet.helius-rpc.com/?api-key=YOUR_KEY"
+end
+```
+
+Or via environment variables:
+
+```
+SOLANA_NETWORK=devnet
+SOLANA_RPC_URL=https://mainnet.helius-rpc.com/?api-key=xxx
+SOLANA_WS_URL=wss://mainnet.helius-rpc.com/?api-key=xxx
+SOLANA_RPC_DEVNET_URL=https://devnet.helius-rpc.com/?api-key=xxx
+```
+
+In a Rails app, you can also use `config/solana.yml` — the engine loads it automatically.
+
+## License
+
+MIT

data/lib/solrengine/rpc/client.rb

@@ -0,0 +1,122 @@
+require "json"
+
+module Solrengine
+  module Rpc
+    class Client
+      include SslHttp
+
+      def initialize(rpc_url: nil)
+        @rpc_url = rpc_url || Solrengine::Rpc.configuration.rpc_url
+      end
+
+      def get_balance(wallet_address, commitment: "confirmed")
+        result = rpc_request("getBalance", [ wallet_address, { "commitment" => commitment } ])
+        lamports = result.dig("result", "value")
+        return nil unless lamports
+
+        lamports.to_f / 1_000_000_000
+      end
+
+      def get_token_accounts(wallet_address, program_id: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")
+        result = rpc_request("getTokenAccountsByOwner", [
+          wallet_address,
+          { "programId" => program_id },
+          { "encoding" => "jsonParsed" }
+        ])
+
+        accounts = result.dig("result", "value") || []
+
+        accounts.filter_map do |account|
+          info = account.dig("account", "data", "parsed", "info")
+          next unless info
+
+          token_amount = info["tokenAmount"]
+          amount = token_amount["uiAmount"].to_f
+          next if amount.zero?
+
+          {
+            mint: info["mint"],
+            balance: token_amount["amount"],
+            decimals: token_amount["decimals"],
+            ui_amount: amount,
+            ui_amount_string: token_amount["uiAmountString"]
+          }
+        end
+      end
+
+      def get_recent_signatures(wallet_address, limit: 10)
+        result = rpc_request("getSignaturesForAddress", [
+          wallet_address,
+          { "limit" => limit }
+        ])
+
+        signatures = result.dig("result") || []
+
+        signatures.map do |sig|
+          {
+            signature: sig["signature"],
+            slot: sig["slot"],
+            block_time: sig["blockTime"] ? Time.at(sig["blockTime"]) : nil,
+            error: sig["err"],
+            memo: sig["memo"],
+            confirmation_status: sig["confirmationStatus"]
+          }
+        end
+      end
+
+      def get_latest_blockhash(commitment: "finalized")
+        result = rpc_request("getLatestBlockhash", [ { "commitment" => commitment } ])
+        value = result.dig("result", "value")
+        return nil unless value
+
+        {
+          blockhash: value["blockhash"],
+          last_valid_block_height: value["lastValidBlockHeight"]
+        }
+      end
+
+      def get_signature_status(signature)
+        result = rpc_request("getSignatureStatuses", [ [ signature ] ])
+        result.dig("result", "value", 0)
+      end
+
+      def get_transaction(signature)
+        result = rpc_request("getTransaction", [
+          signature,
+          { "encoding" => "jsonParsed", "maxSupportedTransactionVersion" => 0 }
+        ])
+
+        result["result"]
+      end
+
+      # Generic RPC call for methods not covered above
+      def request(method, params = [])
+        rpc_request(method, params)
+      end
+
+      private
+
+      def rpc_request(method, params = [])
+        uri = URI.parse(@rpc_url)
+        http = ssl_http(uri)
+
+        request = Net::HTTP::Post.new(uri.request_uri.empty? ? "/" : uri.request_uri)
+        request["Content-Type"] = "application/json"
+        request.body = {
+          jsonrpc: "2.0",
+          id: 1,
+          method: method,
+          params: params
+        }.to_json
+
+        response = http.request(request)
+        JSON.parse(response.body)
+      rescue => e
+        if defined?(Rails)
+          Rails.logger.error("Solrengine RPC error: #{e.class} - #{e.message}")
+        end
+        {}
+      end
+    end
+  end
+end

data/lib/solrengine/rpc/configuration.rb

@@ -0,0 +1,63 @@
+module Solrengine
+  module Rpc
+    class Configuration
+      NETWORKS = %w[mainnet devnet testnet].freeze
+
+      DEFAULT_RPC_URLS = {
+        "mainnet" => "https://api.mainnet-beta.solana.com",
+        "devnet"  => "https://api.devnet.solana.com",
+        "testnet" => "https://api.testnet.solana.com"
+      }.freeze
+
+      DEFAULT_WS_URLS = {
+        "mainnet" => "wss://api.mainnet-beta.solana.com",
+        "devnet"  => "wss://api.devnet.solana.com",
+        "testnet" => "wss://api.testnet.solana.com"
+      }.freeze
+
+      attr_writer :network, :rpc_url, :ws_url
+
+      def network
+        @network ||= ENV.fetch("SOLANA_NETWORK", "mainnet")
+      end
+
+      def rpc_url
+        @rpc_url ||= env_rpc_url || DEFAULT_RPC_URLS[network]
+      end
+
+      def ws_url
+        @ws_url ||= env_ws_url || DEFAULT_WS_URLS[network]
+      end
+
+      def mainnet?
+        network == "mainnet"
+      end
+
+      def explorer_base
+        mainnet? ? "https://solscan.io" : "https://explorer.solana.com"
+      end
+
+      def explorer_cluster
+        mainnet? ? "" : "?cluster=#{network}"
+      end
+
+      private
+
+      def env_rpc_url
+        case network
+        when "mainnet" then ENV["SOLANA_RPC_URL"]
+        when "devnet"  then ENV["SOLANA_RPC_DEVNET_URL"]
+        when "testnet" then ENV["SOLANA_RPC_TESTNET_URL"]
+        end
+      end
+
+      def env_ws_url
+        case network
+        when "mainnet" then ENV["SOLANA_WS_URL"]
+        when "devnet"  then ENV["SOLANA_WS_DEVNET_URL"]
+        when "testnet" then ENV["SOLANA_WS_TESTNET_URL"]
+        end
+      end
+    end
+  end
+end

data/lib/solrengine/rpc/engine.rb

@@ -0,0 +1,23 @@
+module Solrengine
+  module Rpc
+    class Engine < ::Rails::Engine
+      isolate_namespace Solrengine::Rpc
+
+      initializer "solrengine-rpc.configure" do
+        # Load config from solana.yml if it exists and no explicit config was set
+        config_path = Rails.root.join("config", "solana.yml")
+        if config_path.exist?
+          solana_config = Rails.application.config_for(:solana).deep_stringify_keys
+          cfg = Solrengine::Rpc.configuration
+          cfg.network = solana_config["network"] if solana_config["network"]
+
+          network_config = solana_config.dig("networks", cfg.network)
+          if network_config
+            cfg.rpc_url = network_config["rpc_url"] if network_config["rpc_url"]
+            cfg.ws_url = network_config["ws_url"] if network_config["ws_url"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solrengine/rpc/ssl_http.rb

@@ -0,0 +1,26 @@
+require "net/http"
+
+module Solrengine
+  module Rpc
+    # HTTP helper that tolerates SSL certificates with unavailable CRLs.
+    # Some Solana and Jupiter endpoints have certs that Ruby's OpenSSL
+    # rejects due to missing Certificate Revocation Lists.
+    module SslHttp
+      private
+
+      def ssl_http(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.verify_callback = ->(_preverify_ok, store_ctx) {
+          return true if store_ctx.error == 0
+          return true if store_ctx.error == OpenSSL::X509::V_ERR_UNABLE_TO_GET_CRL
+          false
+        }
+        http.open_timeout = 10
+        http.read_timeout = 10
+        http
+      end
+    end
+  end
+end

data/lib/solrengine/rpc/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Solrengine
+  module Rpc
+    VERSION = "0.1.0"
+  end
+end

data/lib/solrengine/rpc.rb

@@ -0,0 +1,25 @@
+require_relative "rpc/version"
+require_relative "rpc/configuration"
+require_relative "rpc/ssl_http"
+require_relative "rpc/client"
+require_relative "rpc/engine" if defined?(Rails::Engine)
+
+module Solrengine
+  module Rpc
+    class Error < StandardError; end
+
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration)
+      end
+
+      def client(rpc_url: nil)
+        Client.new(rpc_url: rpc_url || configuration.rpc_url)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: solrengine-rpc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jose Ferrer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+description: Ruby client for Solana's JSON-RPC API. Handles balance, token accounts,
+  signatures, transactions, and blockhash queries. Includes SSL CRL workaround and
+  multi-network configuration.
+email:
+- estoy@moviendo.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/solrengine/rpc.rb
+- lib/solrengine/rpc/client.rb
+- lib/solrengine/rpc/configuration.rb
+- lib/solrengine/rpc/engine.rb
+- lib/solrengine/rpc/ssl_http.rb
+- lib/solrengine/rpc/version.rb
+homepage: https://github.com/solrengine/rpc
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/solrengine/rpc
+  source_code_uri: https://github.com/solrengine/rpc
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Solana JSON-RPC client for Ruby with SSL CRL fix and network config
+test_files: []