solana_rpc_ruby 1.0.0.pre → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bea15d348b3cc9652473f49747cff8a89992b43543bcf3d569c1aef933c03cf
-  data.tar.gz: d9741e5591c96851ba5d71c70ac09687e7888748e5a82dcbde3e2eab3cebff7f
+  metadata.gz: 2b473e11604fa0d409efbe09260aa85bf467a1b76b6fa014e7a0716e019b3c5e
+  data.tar.gz: 7e116f4bdb58358bf85c3260eb526be306445d87ec87788648ee40ffbd9bd80d
 SHA512:
-  metadata.gz: f28f02c36ed297a1fb527244e2e4e859a636920bd99c9a8cdc4fd20b2f345738d8c2fd011786ccbe4f2b69677d4d089cee77b85572dbb55b18cd6a94ad89e931
-  data.tar.gz: c6ac7e9ee342c856553bcb3053c50f8dee9db48c667946a5d0ecb775b3b026c39eacfed59b254697d0aebe1b89c2a933cff7b4f65b72823855f9dc7d1a48b69a
+  metadata.gz: 5013b6799259a02d77cc232e3a1456a2de52b71c93c31e78a376c702656ed7c6444577e2f4467ceb8c5aa7df7b9b78d4bb05ee27711f003e08d6576c15b84fc4
+  data.tar.gz: ada8e45a050f6bc74e712f9a61a2e8b62032a6a9e60e8a21627c99dd5ce48673833b3cc119c6a893b117dcb81233e1aa8c196bb5cd27145bf684ab88b9c257cb

data/CHANGELOG.md

@@ -1,3 +1,13 @@
 # Changelog
-## 1.0.0 (TBA)
+## 1.0.0
 * Initial release
+
+## 1.0.1
+* Add optional id argument that can be passed to MethodsWrapper class.
+
+## 1.1.0
+* Add websockets connection to gem.
+
+## 1.1.1
+* Fix SolanaRpcRuby::ApiError occurring when websocket program runs for too long
+(#<SolanaRpcRuby::ApiError: NoMethodError undefined method ping)

data/README.md

@@ -1,4 +1,4 @@
-![specs](https://github.com/Block-Logic/solana-rpc-ruby/actions/workflows/specs.yml/badge.svg?branch=177580443_create_wrapper_for_solana_rpc)
+![specs](https://github.com/Block-Logic/solana-rpc-ruby/actions/workflows/specs.yml/badge.svg)
 # solana_rpc_ruby
 A Solana RPC Client for Ruby. This gem provides a wrapper methods for Solana RPC JSON API https://docs.solana.com/developing/clients/jsonrpc-api.
 
@@ -21,7 +21,7 @@ Next, you need to run the generator:
 rails g solana_rpc_ruby:install
 ```
 
-The latter command will generate a new config file `config/solana_rpc_ruby_config.rb` looking like this:
+The latter command will generate a new config file `config/initializers/solana_rpc_ruby_config.rb` looking like this:
 
 ```ruby
 require 'solana_rpc_ruby'
@@ -29,21 +29,171 @@ require 'solana_rpc_ruby'
 SolanaRpcRuby.config do |c|
   c.cluster = 'https://api.testnet.solana.com'
   c.json_rpc_version = '2.0'
-  c.encoding = 'base58'
   # ...other options
 end
 ```
 You can customize it to your needs.
 
 ### Usage examples
+
+#### JSON RPC API
 ```ruby
 # If you set default cluster you don't need to pass it every time.
-method_wrapper = SolanaRpcRuby::MethodsWrapper.new(cluster: 'https://api.testnet.solana.com')
+method_wrapper = SolanaRpcRuby::MethodsWrapper.new(
+  # optional, if not passed, default cluster from config will be used
+  cluster: 'https://api.testnet.solana.com',
+
+  # optional, if not passed, default random number 
+  # from range 1 to 99_999 will be used
+  id: 123 
+)
+
 response = method_wrapper.get_account_info(account_pubkey)
 puts response
+
+# You can check cluster and id that are used.
+method_wrapper.cluster
+method_wrapper.id
+```
+#### Subscription Websocket (BETA)
+```ruby
+ws_method_wrapper = SolanaRpcRuby::WebsocketsMethodsWrapper.new(
+  # optional, if not passed, default ws_cluster from config will be used
+  cluster: 'ws://api.testnet.solana.com',
+
+  # optional, if not passed, default random number 
+  # from range 1 to 99_999 will be used
+  id: 123 
+)
+
+# You should see stream of messages in your console.
+ws_method_wrapper.root_subscribe
+
+# You can pass a block to do something with websocket's messages, ie:
+block = Proc.new do |message|
+  json = JSON.parse(message)
+  puts json['params']
+end
+
+ws_method_wrapper.root_subscribe(&block)
+
+# You can check cluster and id that are used.
+ws_method_wrapper.cluster
+ws_method_wrapper.id
+```
+
+#### Websockets usage in Rails
+You can easily plug-in websockets connection to your rails app by using ActionCable.
+Here is an example for development environment.
+More explanation on Action Cable here: https://www.pluralsight.com/guides/updating-a-rails-app's-wall-feed-in-real-time-with-actioncable
+
+0. Make sure that you have action_cable and solana_rpc_ruby gems installed properly. Also install redis unless you have it.
+
+1. Mount action_cable in `routes.rb`.
+```
+Rails.application.routes.draw do
+  mount ActionCable.server => '/cable'
+  ...
+end
+```
+
+2. Update `config/environments/development.rb`.
+```
+config.action_cable.url = "ws://localhost:3000/cable"
+config.action_cable.allowed_request_origins = [/http:\/\/*/, /https:\/\/*/]
+```
+
+3. Update adapter in `cable.yml`.
+```
+development:
+  adapter: redis
+  url: <%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %>
+```
+
+4. Create a channel.
+```
+rails g channel wall
 ```
 
-All info about methods you can find in the docs on: FILL THE ADDRESS!!!
+5. Your `wall_channel.rb` should look like this:
+```
+class WallChannel < ApplicationCable::Channel
+  def subscribed
+    stream_from "wall_channel"
+  end
+
+  def unsubscribed
+    # Any cleanup needed when channel is unsubscribed
+  end
+end
+```
+
+6. Your `wall_channel.js` should look like this (json keys are configured for `root_subscription` method response):
+```
+import consumer from "./consumer"
+
+consumer.subscriptions.create("WallChannel", {
+  connected() {
+    console.log("Connected to WallChannel");
+    // Called when the subscription is ready for use on the server
+  },
+
+  disconnected() {
+    // Called when the subscription has been terminated by the server
+  },
+
+  received(data) {
+    let wall = document.getElementById('wall');
+
+    wall.innerHTML += "<p>Result: "+ data['message']['result'] + "</p>";
+    // Called when there's incoming data on the websocket for this channel
+  }
+});
+
+
+```
+
+7. Create placeholder somewhere in your view for messages.
+```
+<div id='wall' style='overflow-y: scroll; height:400px;''>
+  <h1>Solana subscription messages</h1>
+</div>
+```
+
+8. Create a script with a block to run websockets (`script/websockets_solana.rb`).
+```
+require_relative '../config/environment'
+
+ws_method_wrapper = SolanaRpcRuby::WebsocketsMethodsWrapper.new
+
+# Example of block that can be passed to the method to manipulate the data.
+block = Proc.new do |message|
+  json = JSON.parse(message)
+
+  ActionCable.server.broadcast(
+    "wall_channel",
+    {
+      message: json['params']
+    }
+  )
+end
+
+ws_method_wrapper.root_subscribe(&block)
+```
+9. Run `rails s`, open webpage where you put your placeholder.
+10. Open `http://localhost:3000/address_with_websockets_view`.
+11. Run `rails r script/websockets_solana.rb` in another terminal window.
+12. You should see incoming websocket messages on your webpage.
+### Demo scripts
+Gem is coming with demo scripts that you can run and test API and Websockets.
+
+1. Clone the repo
+2. Set the gemset
+3. Run `ruby demo.rb` or `ruby demo_ws_METHOD.rb` to see example output.
+4. Check the gem or Solana JSON RPC API docs to get more information about method usage and modify demo scripts loosely.
+
+All info about methods you can find in the docs on: https://www.rubydoc.info/github/Block-Logic/solana-rpc-ruby/main/SolanaRpcRuby
+
 Also, as a reference you can use docs from solana: https://docs.solana.com/developing/clients/jsonrpc-api
 ## License
 

data/lib/generators/solana_rpc_ruby/install_generator.rb

@@ -6,7 +6,7 @@ module SolanaRpcRuby
 
       desc 'Creates a SolanaRpcRuby config file.'
       def copy_config
-        template 'solana_rpc_ruby_config.rb', "#{Rails.root}/config/solana_rpc_ruby.rb"
+        template 'solana_rpc_ruby_config.rb', "#{Rails.root}/config/initializers/solana_rpc_ruby.rb"
       end
     end
   end

data/lib/generators/templates/solana_rpc_ruby_config.rb

@@ -1,14 +1,13 @@
 require_relative 'solana_rpc_ruby'
 
-# DEVNET_CLUSTER = 'https://api.devnet.solana.com'
-# MAINNET_CLUSTER = 'https://api.mainnet-beta.solana.com'
-# TESTNET_CLUSTER = 'https://api.testnet.solana.com'
-
 SolanaRpcRuby.config do |c|
-  # These are mandatory options that you must set before using gem:
+  # These are options that you can set before using gem:
   # 
+  # You can use this setting or pass cluster directly, check the docs.
   # c.cluster = 'https://api.testnet.solana.com'
-  # c.json_rpc = '2.0
-  # c.encoding = 'base58'
-  # c.id = 1
+  # c.ws_cluster = 'ws://api.testnet.solana.com'
+
+
+  # This one is mandatory.
+  c.json_rpc_version = '2.0'
 end

data/lib/solana_rpc_ruby/api_client.rb

@@ -1,5 +1,4 @@
 require 'net/http'
-
 module SolanaRpcRuby
   ##
   # ApiClient class serves as a client for solana JSON RPC API.
@@ -14,29 +13,29 @@ module SolanaRpcRuby
     attr_accessor :default_headers
 
     # Initialize object with cluster address where requests will be sent.
-    # 
-    # @param cluster [String] 
+    #
+    # @param cluster [String]
     def initialize(cluster = nil)
       @cluster = cluster || SolanaRpcRuby.cluster
 
       message = 'Cluster is missing. Please provide default cluster in config or pass it to the client directly.'
       raise ArgumentError, message unless @cluster
     end
-    
+
     # Sends request to the api.
     #
-    # @param body [Hash] 
+    # @param body [Hash]
     # @param http_method [Symbol]
     # @param params [Hash]
-    # 
+    #
     # @return [Object] Net::HTTPOK
     def call_api(body:, http_method:, params: {})
       uri = URI(@cluster)
       rpc_response = Net::HTTP.public_send(
-        http_method, 
-        uri, 
-        body, 
-        default_headers, 
+        http_method,
+        uri,
+        body,
+        default_headers,
       )
 
       rpc_response
@@ -44,12 +43,12 @@ module SolanaRpcRuby
     rescue Timeout::Error,
            Net::HTTPError,
            Net::HTTPNotFound,
-           Net::HTTPServerException,
+           Net::HTTPClientException,
            Net::HTTPFatalError,
            Net::ReadTimeout => e
-
       fail ApiError.new(message: e.message)
     rescue StandardError => e
+
       message = "#{e.class} #{e.message}\n Backtrace: \n #{e.backtrace}"
       fail ApiError.new(message: message)
     end

data/lib/solana_rpc_ruby/api_error.rb

@@ -6,20 +6,20 @@ module SolanaRpcRuby
     # Error code.
     # @return [Integer]
     attr_reader :code
-    
+
     # Error message.
     # @return [String]
     attr_reader :message
-    
+
     # Initialize object with json response from the API with error.
-    # 
+    #
     # @param code [Integer]
     # @param message [String]
-    # 
+    #
     # @return [SolanaRpcRuby::ApiError]
     def initialize(code: nil, message:)
       @code = code
-      @message = message
+      @message = message.to_s
 
       super message
     end

data/lib/solana_rpc_ruby/helper_methods.rb

@@ -12,5 +12,18 @@ module SolanaRpcRuby
   
       object.nil? || object.empty?
     end
+
+    # Creates method name to match names required by Solana RPC JSON.
+    # 
+    # @param method [String]
+    # 
+    # @return [String]
+    def create_method_name(method)
+      return '' unless method && (method.is_a?(String) || method.is_a?(Symbol))
+
+      method.to_s.split('_').map.with_index do |string, i|
+        i == 0 ? string : string.capitalize
+      end.join
+    end
   end
 end