throttled_json_rpc_client 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d75ceb289344a401badd6873381a592e0fa445a4b65baf0ca369d53bf3fd6ed
-  data.tar.gz: 66eafc5b5be6cb4a95080f6050cc7cc9baa21e48cc3db15d4fae8d3fc942ed59
+  metadata.gz: 59ebf0f85dc101410fcd0a3a665777ed1ffbae6e662e895acf7e338756cb8155
+  data.tar.gz: 58cee4e703c32b3a771b90bb5adc801f96d22b4359ff730ecac9820e8afaab91
 SHA512:
-  metadata.gz: 2c72d92f7ffca6c3f627e356d6a52a7a857e5a063a84182ce222bc25ad2c11d31ba3e138041648ebd30a2dc6074f12d49869f3da103915b040c3825b5b58fcf1
-  data.tar.gz: cfed9cb9aa7d1a41f36e373c4cd7744a3fb2e7d0f88c830bf64050ad8e40f4540602c30efe05fdd9e30dc64a49a89154fcfc815371c7a8cf127b47beb2c78433
+  metadata.gz: f6491a2d5685dae9e50c264271b6c07cb8701cb87c5b65709dfbcc4f594e3be7059deab89cc450a61402a32f7bd1a488dbd6f777bb189066ddc55d2600144a98
+  data.tar.gz: 237c09309c9f13de9b72660af01b8266ebc1f78deb9f31de11c71a7fba263e57611a503c19910091c5333e90bf11ee76f149f92020d4ed0f5509506dda88b2fb

data/README.md

@@ -14,33 +14,23 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
-## example1, without rate throttling
-```ruby
-rpc_url = "https://1rpc.io/eth"
-
-eth = JsonRpcClient::Eth.new(rpc_url)
-
-p eth.block_number
-```
-
-## example2, with rate throttling
-> The rate limit on the server is called Rate Limiting, and the rate limit on the client is called Rate Throttling.
-
 This rate throttling can be used in multi-threaded, multi-process, multi-machine environments.
+
 ```ruby
-rpc_url = "https://1rpc.io/eth"
+rpc_url = "https://eth.llamarpc.com"
 
 # default equals to ThrottledJsonRpcClient::Eth.new(url, rate: 5, interval: 1, redis_urls: ["redis://localhost:6379/2"])
-eth = ThrottledJsonRpcClient::Eth.new(rpc_url)
+client = ThrottledJsonRpcClient::Client.new(rpc_url)
 
 threads = []
 10.times do
   threads << Thread.new do
-    p eth.block_number
+    p client.call("eth_getBlockByNumber", ["0x1234", false])
   end
 end
 threads.map(&:join)
 ```
+see [example](./example.rb)
 
 ## Development
 

data/example.rb

@@ -1,14 +1,17 @@
-rpc_url = "https://1rpc.io/eth"
+rpc_url = "https://eth.llamarpc.com"
 
-eth = ThrottledJsonRpcClient::Eth.new(
+# limit: 1 request / 5 seconds
+client = ThrottledJsonRpcClient::Client.new(
   rpc_url,
-  redis_urls: ["redis://redis:6379/2"]
+  rate: 1,
+  interval: 5,
+  redis_urls: ["redis://localhost:6379/2"]
 )
 
 threads = []
 10.times do
   threads << Thread.new do
-    p eth.block_number
+    p client.call("eth_blockNumber", [])
   end
 end
 threads.map(&:join)

data/lib/json_rpc_client.rb

@@ -0,0 +1,97 @@
+require "faraday"
+require "json"
+require "time"
+
+class JsonRpcClient
+  class RpcError < StandardError; end
+
+  DEFAULT_MAX_BATCH_SIZE = 100
+  DEFAULT_TIMEOUT = 30
+
+  def initialize(
+    endpoint,
+    timeout: DEFAULT_TIMEOUT,
+    max_batch_size: DEFAULT_MAX_BATCH_SIZE,
+    headers: {}
+  )
+    @endpoint = endpoint
+    @max_batch_size = max_batch_size
+    @timeout = timeout
+    @headers = { "Content-Type" => "application/json" }.merge(headers)
+    @request_id = 0
+    @last_request_time = Time.now
+    @request_times = []
+  end
+
+  def call(method, params = nil)
+    payload = build_request(method, params)
+    response = make_request(payload)
+
+    raise RpcError, "RPC error: #{response["error"]}" if response["error"]
+
+    response["result"]
+  end
+
+  def batch_call(calls)
+    if calls.size > @max_batch_size
+      raise RpcError,
+            "Batch size #{calls.size} exceeds maximum allowed size of #{@max_batch_size}"
+    end
+
+    results = []
+    batch_payload = calls.map do |method, params|
+      build_request(method, params)
+    end
+
+    responses = make_request(batch_payload)
+
+    # Handle single response case
+    responses = [responses] unless responses.is_a?(Array)
+
+    # Sort responses by id to maintain order
+    sorted_responses = responses.sort_by { |r| r["id"] }
+
+    sorted_responses.each do |response|
+      raise RpcError, "RPC error in batch: #{response["error"]}" if response["error"]
+
+      results << response["result"]
+    end
+
+    results
+  end
+
+  private
+
+  def build_request(method, params)
+    @request_id += 1
+    {
+      jsonrpc: "2.0",
+      method: method,
+      params: params || [],
+      id: @request_id
+    }
+  end
+
+  def make_request(payload)
+    connection = Faraday.new(@endpoint) do |conn|
+      conn.options.timeout = @timeout
+      conn.ssl.verify = false
+      conn.adapter Faraday.default_adapter
+    end
+
+    response = connection.post do |req|
+      req.headers = @headers
+      req.body = payload.to_json
+    end
+
+    raise RpcError, "HTTP error: #{response.status} - #{response.body}" unless response.success?
+
+    JSON.parse(response.body)
+  rescue Faraday::TimeoutError => e
+    raise RpcError, "Request timed out after #{@timeout} seconds"
+  rescue Faraday::ConnectionFailed => e
+    raise RpcError, "Connection failed: #{e.message}"
+  rescue Faraday::SSLError => e
+    raise RpcError, "SSL Error: #{e.message}"
+  end
+end

data/lib/limiter/distributed_rate_queue.rb

@@ -25,6 +25,7 @@ class DistributedRateQueue
 
   def wait_for_next_turn
     wait = lock_manager.get_remaining_ttl_for_resource(key)
+    return if wait.nil?
     return unless wait.positive?
 
     # Logger.log("Waiting for #{wait / 1000.0} seconds", Process.pid)

data/lib/throttled_json_rpc_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ThrottledJsonRpcClient
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/throttled_json_rpc_client.rb

@@ -1,11 +1,79 @@
 # frozen_string_literal: true
 
-require "net/http"
-require "json"
-require "uri"
-
+require "delegate"
+require_relative "limiter/distributed_rate_queue"
+require_relative "json_rpc_client"
 require_relative "throttled_json_rpc_client/version"
 
-require_relative "limiter/distributed_rate_queue"
-require_relative "json_rpc_client/eth"
-require_relative "throttled_json_rpc_client/eth"
+module ThrottledJsonRpcClient
+  class Client < SimpleDelegator
+    DEFAULT_MAX_RETRIES = 3
+    DEFAULT_BASE_DELAY = 1 # Base delay in seconds
+
+    # limit: #{rate} requests / #{interval} seconds
+    def initialize(
+      endpoint,
+      timeout: JsonRpcClient::DEFAULT_TIMEOUT,
+      max_batch_size: JsonRpcClient::DEFAULT_MAX_BATCH_SIZE,
+      headers: {},
+      # retry params
+      max_retries: DEFAULT_MAX_RETRIES,
+      base_delay: DEFAULT_BASE_DELAY,
+      # limit params
+      rate: 5, 
+      interval: 1, # in seconds
+      redis_urls: ["redis://localhost:6379/2"]
+    )
+      @max_retries = max_retries
+      @base_delay = base_delay
+      @queue = DistributedRateQueue.new(
+        redis_urls: redis_urls,
+        key: "key:#{endpoint}",
+        rate: rate,
+        interval: interval
+      )
+      super(
+        JsonRpcClient.new(
+          endpoint, 
+          timeout: timeout, 
+          max_batch_size: max_batch_size, 
+          headers: headers
+        )
+      )
+    end
+
+    def call(method, params = nil)
+      retries = 0
+      begin
+        @queue.shift do
+          super(method, params)
+        end
+      rescue JsonRpcClient::RpcError => e
+        retries += 1
+        if retries <= @max_retries
+          delay = @base_delay * (2**(retries - 1))
+          sleep(delay)
+          retry
+        end
+        raise e
+      end
+    end
+
+    def batch_call(calls)
+      retries = 0
+      begin
+        @queue.shift do
+          super(calls)
+        end
+      rescue JsonRpcClient::RpcError => e
+        retries += 1
+        if retries <= @max_retries
+          delay = @base_delay * (2**(retries - 1))
+          sleep(delay)
+          retry
+        end
+        raise e
+      end
+    end
+  end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: throttled_json_rpc_client
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Aki Wu
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-18 00:00:00.000000000 Z
+date: 2024-11-25 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: redlock
   requirement: !ruby/object:Gem::Requirement
@@ -38,10 +52,9 @@ files:
 - README.md
 - Rakefile
 - example.rb
-- lib/json_rpc_client/eth.rb
+- lib/json_rpc_client.rb
 - lib/limiter/distributed_rate_queue.rb
 - lib/throttled_json_rpc_client.rb
-- lib/throttled_json_rpc_client/eth.rb
 - lib/throttled_json_rpc_client/version.rb
 - sig/throttled_json_rpc_client.rbs
 homepage: https://github.com/wuminzhe/throttled_json_rpc_client
@@ -66,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.21
 signing_key:
 specification_version: 4
 summary: throttled_json_rpc_client

data/lib/json_rpc_client/eth.rb

@@ -1,61 +0,0 @@
-module JsonRpcClient
-  class HttpError < StandardError; end
-  class JSONRpcError < StandardError; end
-
-  class << self
-    def request(url, method, params)
-      uri = URI.parse(url)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == "https"
-
-      request = Net::HTTP::Post.new(uri, "Content-Type" => "application/json")
-      request.body = { jsonrpc: "2.0", method: method, params: params, id: 1 }.to_json
-
-      # https://docs.ruby-lang.org/en/master/Net/HTTPResponse.html
-      response = http.request(request)
-      raise HttpError, response unless response.is_a?(Net::HTTPOK)
-
-      body = JSON.parse(response.body)
-      raise JSONRpcError, body["error"] if body["error"]
-
-      body["result"]
-    end
-  end
-
-  class Eth
-    attr_reader :url
-
-    def initialize(url)
-      @url = url
-    end
-
-    def get_block_by_bumber(block_number_or_block_tag, transaction_detail_flag = false)
-      rpc_method = "eth_getBlockByNumber"
-      params = [block_number_or_block_tag, transaction_detail_flag]
-      JsonRpcClient.request(url, rpc_method, params)
-    end
-
-    # == get_block_by_bumber('latest'])['number']
-    def block_number
-      rpc_method = "eth_blockNumber"
-      params = []
-      JsonRpcClient.request(url, rpc_method, params)
-    end
-
-    #############################
-    # use method_missing to define all the methods
-    #############################
-    def respond_to_missing?(*_args)
-      true
-    end
-
-    # example:
-    #   eth.get_balance('0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045', 'latest')
-    def method_missing(method, *args)
-      words = method.to_s.split("_")
-      rpc_method = "eth_#{words[0]}#{words[1..].collect(&:capitalize).join}"
-      params = args
-      JsonRpcClient.request(url, rpc_method, params)
-    end
-  end
-end

data/lib/throttled_json_rpc_client/eth.rb

@@ -1,23 +0,0 @@
-require "delegate"
-
-module ThrottledJsonRpcClient
-  class Eth < SimpleDelegator
-    # limit: #{rate} requests / #{interval} seconds
-    def initialize(url, rate: 5, interval: 1, redis_urls: ["redis://localhost:6379/2"])
-      @queue = DistributedRateQueue.new(
-        redis_urls: redis_urls,
-        key: "key:#{url}",
-        rate: rate,
-        interval: interval
-      )
-
-      super(JsonRpcClient::Eth.new(url))
-    end
-
-    def method_missing(*args, **kwargs, &block)
-      @queue.shift do
-        super
-      end
-    end
-  end
-end