erpc-sdk 0.4.0

data/lib/erpc_sdk/transport.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "openssl"
+require "socket"
+require "thread"
+require "uri"
+
+module ERPC
+  HttpResponse = Struct.new(:status, :body, keyword_init: true)
+
+  class NetHttpAdapter
+    def request(method:, url:, headers:, body: nil, timeout: DEFAULT_TIMEOUT)
+      uri = URI.parse(url)
+      request = request_class(method).new(uri.request_uri, headers)
+      request.body = body unless body.nil?
+      response = start(uri, timeout) { |http| http.request(request) }
+      HttpResponse.new(status: response.code.to_i, body: response.body.to_s)
+    rescue Net::OpenTimeout, Net::ReadTimeout, Net::WriteTimeout
+      raise TimeoutError, timeout
+    rescue IOError, EOFError, SocketError, SystemCallError, OpenSSL::SSL::SSLError
+      raise TransportError, "Unable to reach ERPC"
+    end
+
+    def stream(url:, headers:, timeout: DEFAULT_TIMEOUT)
+      Enumerator.new do |yielder|
+        uri = URI.parse(url)
+        request = Net::HTTP::Get.new(uri.request_uri, headers)
+        start(uri, timeout) do |http|
+          http.request(request) do |response|
+            status = response.code.to_i
+            raise HttpError, status unless status.between?(200, 299)
+
+            response.read_body { |chunk| yielder << chunk }
+          end
+        end
+      rescue Net::OpenTimeout, Net::ReadTimeout, Net::WriteTimeout
+        raise TimeoutError, timeout
+      rescue HttpError
+        raise
+      rescue IOError, EOFError, SocketError, SystemCallError, OpenSSL::SSL::SSLError
+        raise TransportError, "Unable to reach ERPC"
+      end
+    end
+
+    private
+
+    def start(uri, timeout, &block)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", open_timeout: timeout,
+                      read_timeout: timeout, write_timeout: timeout, &block)
+    end
+
+    def request_class(method)
+      { get: Net::HTTP::Get, post: Net::HTTP::Post }.fetch(method.to_sym)
+    end
+  end
+
+  class HttpJsonRpcTransport
+    attr_reader :endpoint, :max_batch_size
+
+    def initialize(api_key:, endpoint:, headers:, timeout:, adapter:, max_batch_size: 256)
+      @api_key = api_key
+      @endpoint = endpoint
+      @headers = headers
+      @timeout = timeout
+      @adapter = adapter
+      @max_batch_size = max_batch_size
+      @next_id = 0
+      @id_mutex = Mutex.new
+    end
+
+    def request(method, params = nil)
+      request_id = next_id
+      body = { "jsonrpc" => "2.0", "id" => request_id, "method" => method }
+      body["params"] = params unless params.nil?
+      unwrap(post(body), request_id)
+    end
+
+    def batch(calls)
+      return [] if calls.empty?
+      if calls.length > max_batch_size
+        raise InvalidResponseError, "A batch may contain at most #{max_batch_size} calls"
+      end
+
+      requests = calls.map do |call|
+        method = call.fetch(:method) { call.fetch("method") }
+        item = { "jsonrpc" => "2.0", "id" => next_id, "method" => method }
+        if call.key?(:params) || call.key?("params")
+          item["params"] = call.key?(:params) ? call[:params] : call["params"]
+        end
+        item
+      rescue KeyError
+        raise ConfigError, "batch calls require a method"
+      end
+
+      response = post(requests)
+      unless response.is_a?(Array)
+        raise_rpc(response["error"]) if response.is_a?(Hash) && response["error"].is_a?(Hash)
+        raise InvalidResponseError, "ERPC returned a non-array batch response"
+      end
+
+      by_id = {}
+      response.each do |item|
+        unless item.is_a?(Hash) && valid_id?(item["id"])
+          raise InvalidResponseError, "ERPC returned an invalid batch item"
+        end
+        raise InvalidResponseError, "ERPC returned a duplicate batch id" if by_id.key?(item["id"])
+
+        by_id[item["id"]] = item
+      end
+
+      results = requests.map do |request|
+        item = by_id.delete(request["id"])
+        raise InvalidResponseError, "ERPC omitted a batch response" unless item
+
+        unwrap(item, request["id"])
+      end
+      raise InvalidResponseError, "ERPC returned an unexpected batch response id" unless by_id.empty?
+
+      results
+    end
+
+    private
+
+    def next_id
+      @id_mutex.synchronize { @next_id += 1 }
+    end
+
+    def post(body)
+      uri = URI.parse(endpoint)
+      query = URI.decode_www_form(uri.query.to_s)
+      query << ["api-key", @api_key]
+      uri.query = URI.encode_www_form(query)
+      response = @adapter.request(
+        method: :post,
+        url: uri.to_s,
+        headers: @headers.merge("accept" => "application/json", "content-type" => "application/json"),
+        body: JSON.generate(body),
+        timeout: @timeout
+      )
+      raise HttpError, response.status unless response.status.between?(200, 299)
+
+      JSON.parse(response.body)
+    rescue JSON::ParserError
+      raise InvalidResponseError, "ERPC returned malformed JSON"
+    end
+
+    def unwrap(response, expected_id)
+      unless response.is_a?(Hash) && response["id"] == expected_id
+        raise InvalidResponseError, "ERPC returned an unexpected response id"
+      end
+      raise_rpc(response["error"]) if response.key?("error")
+      raise InvalidResponseError, "ERPC returned an invalid response" unless response.key?("result")
+
+      response["result"]
+    end
+
+    def raise_rpc(error)
+      unless error.is_a?(Hash) && error["code"].is_a?(Integer) && error["message"].is_a?(String)
+        raise InvalidResponseError, "ERPC returned an invalid RPC error"
+      end
+
+      data = error.key?("data") ? Redaction.value(error["data"], @api_key) : nil
+      raise JsonRpcError.new(error["code"], Redaction.text(error["message"], @api_key), data)
+    end
+
+    def valid_id?(value)
+      value.is_a?(Integer) || value.is_a?(String)
+    end
+  end
+
+  class RestTransport
+    attr_reader :endpoint
+
+    def initialize(credential:, endpoint:, headers:, timeout:, adapter:)
+      @credential = credential
+      @endpoint = endpoint
+      @headers = headers
+      @timeout = timeout
+      @adapter = adapter
+    end
+
+    def get(path, query = nil)
+      response = @adapter.request(
+        method: :get,
+        url: url(path, query),
+        headers: @headers.merge("authorization" => "Bearer #{@credential}", "accept" => "application/json"),
+        timeout: @timeout
+      )
+      raise HttpError, response.status unless response.status.between?(200, 299)
+
+      JSON.parse(response.body)
+    rescue JSON::ParserError
+      raise InvalidResponseError, "ERPC returned malformed JSON"
+    end
+
+    def stream(path, query = nil)
+      @adapter.stream(
+        url: url(path, query),
+        headers: @headers.merge("authorization" => "Bearer #{@credential}", "accept" => "text/event-stream"),
+        timeout: @timeout
+      )
+    end
+
+    private
+
+    def url(path, query)
+      uri = URI.parse(URLs.with_path(endpoint, path))
+      pairs = []
+      (query || {}).each do |key, value|
+        next if value.nil?
+
+        if value.is_a?(Array)
+          value.each { |item| pairs << [key.to_s, item.to_s] }
+        else
+          rendered = value == true ? "true" : value == false ? "false" : value.to_s
+          pairs << [key.to_s, rendered]
+        end
+      end
+      uri.query = URI.encode_www_form(pairs) unless pairs.empty?
+      uri.to_s
+    end
+  end
+end

data/lib/erpc_sdk/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ERPC
+  VERSION = "0.4.0"
+end

data/lib/erpc_sdk/websocket.rb

@@ -0,0 +1,458 @@
+# frozen_string_literal: true
+
+require "base64"
+require "digest/sha1"
+require "json"
+require "openssl"
+require "securerandom"
+require "socket"
+require "thread"
+require "timeout"
+require "uri"
+
+module ERPC
+  class WebSocketConnection
+    MAX_MESSAGE_SIZE = 16 * 1024 * 1024
+    private_constant :MAX_MESSAGE_SIZE
+
+    def initialize(url, timeout)
+      @uri = URI.parse(url)
+      @timeout = timeout
+      @write_mutex = Mutex.new
+      connect
+    end
+
+    def write_text(text)
+      write_frame(0x1, text.b)
+    end
+
+    def read_message
+      payload = +"".b
+      started = false
+      loop do
+        final, opcode, chunk = read_frame
+        case opcode
+        when 0x0
+          raise TransportError, "ERPC returned an invalid WebSocket frame" unless started
+          payload << chunk
+        when 0x1, 0x2
+          raise TransportError, "ERPC returned an invalid WebSocket frame" if started
+          started = true
+          payload << chunk
+        when 0x8
+          raise TransportError, "ERPC WebSocket connection closed"
+        when 0x9
+          write_frame(0xA, chunk)
+          next
+        when 0xA
+          next
+        else
+          raise TransportError, "ERPC returned an invalid WebSocket frame"
+        end
+        raise TransportError, "ERPC WebSocket message is too large" if payload.bytesize > MAX_MESSAGE_SIZE
+        return payload.force_encoding(Encoding::UTF_8) if final
+      end
+    end
+
+    def close
+      write_frame(0x8, "".b)
+    rescue StandardError
+      nil
+    ensure
+      @socket&.close
+    end
+
+    private
+
+    def connect
+      unless %w[ws wss].include?(@uri.scheme) && @uri.host
+        raise ConfigError, "WebSocket endpoint must be an absolute WS(S) URL"
+      end
+
+      tcp = Timeout.timeout(@timeout) { TCPSocket.new(@uri.host, @uri.port) }
+      @socket = if @uri.scheme == "wss"
+                  context = OpenSSL::SSL::SSLContext.new
+                  context.set_params
+                  ssl = OpenSSL::SSL::SSLSocket.new(tcp, context)
+                  ssl.hostname = @uri.host if ssl.respond_to?(:hostname=)
+                  ssl.sync_close = true
+                  Timeout.timeout(@timeout) { ssl.connect }
+                  ssl
+                else
+                  tcp
+                end
+      handshake
+    rescue ::Timeout::Error
+      tcp&.close
+      raise TimeoutError, @timeout
+    rescue ConfigError, TimeoutError
+      tcp&.close
+      raise
+    rescue IOError, EOFError, SocketError, SystemCallError, OpenSSL::SSL::SSLError
+      tcp&.close
+      raise TransportError, "Unable to reach ERPC WebSocket"
+    end
+
+    def handshake
+      key = Base64.strict_encode64(SecureRandom.random_bytes(16))
+      host = @uri.host
+      default_port = (@uri.scheme == "wss" ? 443 : 80)
+      host = "#{host}:#{@uri.port}" unless @uri.port == default_port
+      request = [
+        "GET #{@uri.request_uri} HTTP/1.1",
+        "Host: #{host}",
+        "Upgrade: websocket",
+        "Connection: Upgrade",
+        "Sec-WebSocket-Key: #{key}",
+        "Sec-WebSocket-Version: 13",
+        "\r\n"
+      ].join("\r\n")
+      Timeout.timeout(@timeout) { @socket.write(request) }
+      headers = read_until("\r\n\r\n", 64 * 1024)
+      status, *lines = headers.split("\r\n")
+      raise TransportError, "ERPC rejected the WebSocket upgrade" unless status&.match?(%r{\AHTTP/1\.[01] 101\b})
+
+      response_headers = lines.filter_map do |line|
+        name, separator, value = line.partition(":")
+        [name.downcase, value.strip] unless separator.empty?
+      end.to_h
+      expected = Base64.strict_encode64(Digest::SHA1.digest("#{key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11"))
+      unless response_headers["upgrade"]&.downcase == "websocket" &&
+             response_headers["connection"]&.downcase&.split(/\s*,\s*/)&.include?("upgrade") &&
+             secure_compare(response_headers["sec-websocket-accept"].to_s, expected)
+        raise TransportError, "ERPC returned an invalid WebSocket upgrade"
+      end
+    rescue ::Timeout::Error
+      raise TimeoutError, @timeout
+    end
+
+    def read_until(delimiter, limit)
+      value = +"".b
+      until value.end_with?(delimiter)
+        value << read_exact(1)
+        raise TransportError, "ERPC returned oversized WebSocket headers" if value.bytesize > limit
+      end
+      value
+    end
+
+    def read_frame
+      header = read_exact(2).bytes
+      unless (header[0] & 0x70).zero?
+        raise TransportError, "ERPC returned an invalid WebSocket frame"
+      end
+      final = (header[0] & 0x80) != 0
+      opcode = header[0] & 0x0F
+      masked = (header[1] & 0x80) != 0
+      raise TransportError, "ERPC returned an invalid WebSocket frame" if masked
+
+      length = header[1] & 0x7F
+      length = read_exact(2).unpack1("n") if length == 126
+      length = read_exact(8).unpack1("Q>") if length == 127
+      if opcode >= 0x8 && (!final || length > 125)
+        raise TransportError, "ERPC returned an invalid WebSocket control frame"
+      end
+      raise TransportError, "ERPC WebSocket message is too large" if length > MAX_MESSAGE_SIZE
+
+      payload = read_exact(length)
+      [final, opcode, payload]
+    end
+
+    def write_frame(opcode, payload)
+      mask = SecureRandom.random_bytes(4)
+      header = [0x80 | opcode]
+      length = payload.bytesize
+      if length < 126
+        header << (0x80 | length)
+        prefix = header.pack("C*")
+      elsif length <= 65_535
+        header << (0x80 | 126)
+        prefix = header.pack("C*") + [length].pack("n")
+      else
+        header << (0x80 | 127)
+        prefix = header.pack("C*") + [length].pack("Q>")
+      end
+      masked = payload.bytes.each_with_index.map { |byte, index| byte ^ mask.getbyte(index % 4) }.pack("C*")
+      @write_mutex.synchronize do
+        Timeout.timeout(@timeout) { @socket.write(prefix + mask + masked) }
+      end
+    rescue ::Timeout::Error
+      raise TimeoutError, @timeout
+    rescue IOError, EOFError, SocketError, SystemCallError, OpenSSL::SSL::SSLError
+      raise TransportError, "Unable to reach ERPC WebSocket"
+    end
+
+    def read_exact(length)
+      value = +"".b
+      while value.bytesize < length
+        ready = IO.select([@socket], nil, nil, @timeout)
+        raise TimeoutError, @timeout unless ready
+
+        chunk = @socket.readpartial(length - value.bytesize)
+        raise EOFError if chunk.empty?
+
+        value << chunk
+      end
+      value
+    rescue EOFError, IOError, SocketError, SystemCallError, OpenSSL::SSL::SSLError
+      raise TransportError, "ERPC WebSocket connection closed"
+    end
+
+    def secure_compare(left, right)
+      return false unless left.bytesize == right.bytesize
+
+      left.bytes.zip(right.bytes).reduce(0) { |difference, (a, b)| difference | (a ^ b) }.zero?
+    end
+  end
+
+  class WebSocketJsonRpcTransport
+    def initialize(connection_url, credential, timeout, connection_factory: nil)
+      @connection_url = connection_url
+      @credential = credential
+      @timeout = timeout
+      @connection_factory = connection_factory || ->(url, seconds) { WebSocketConnection.new(url, seconds) }
+      @mutex = Mutex.new
+      @connection = nil
+      @reader = nil
+      @pending = {}
+      @listeners = {}
+      @next_id = 0
+      @next_listener_id = 0
+      @closed = false
+    end
+
+    def request(method, params = nil)
+      connection = ensure_connection
+      request_id = @mutex.synchronize { @next_id += 1 }
+      queue = Queue.new
+      @mutex.synchronize { @pending[request_id] = queue }
+      body = { "jsonrpc" => "2.0", "id" => request_id, "method" => method }
+      body["params"] = params unless params.nil?
+      connection.write_text(JSON.generate(body))
+      response = Timeout.timeout(@timeout) { queue.pop }
+      raise response if response.is_a?(Exception)
+
+      unwrap(response, request_id)
+    rescue ::Timeout::Error
+      raise TimeoutError, @timeout
+    ensure
+      @mutex.synchronize { @pending.delete(request_id) } if request_id
+    end
+
+    def on_notification(listener = nil, &block)
+      selected = listener || block
+      raise ArgumentError, "listener is required" unless selected
+
+      listener_id = @mutex.synchronize do
+        @next_listener_id += 1
+        @listeners[@next_listener_id] = selected
+        @next_listener_id
+      end
+      -> { @mutex.synchronize { @listeners.delete(listener_id) } }
+    end
+
+    def close
+      connection = @mutex.synchronize do
+        return if @closed
+
+        @closed = true
+        current, @connection = @connection, nil
+        current
+      end
+      connection&.close
+      @reader&.join(1)
+      fail_pending(TransportError.new("WebSocket transport is closed"))
+      @mutex.synchronize { @listeners.clear }
+      nil
+    end
+
+    private
+
+    def ensure_connection
+      @mutex.synchronize do
+        raise TransportError, "WebSocket transport is closed" if @closed
+        return @connection if @connection
+
+        @connection = @connection_factory.call(@connection_url, @timeout)
+        connection = @connection
+        @reader = Thread.new { read_loop(connection) }
+        @reader.report_on_exception = false
+        connection
+      end
+    end
+
+    def read_loop(connection)
+      loop do
+        value = JSON.parse(connection.read_message)
+        next unless value.is_a?(Hash)
+
+        id = value["id"]
+        if id.is_a?(Integer) || id.is_a?(String)
+          queue = @mutex.synchronize { @pending[id] }
+          queue << value if queue
+        elsif value["method"].is_a?(String) && value.key?("params")
+          listeners = @mutex.synchronize { @listeners.values.dup }
+          listeners.each do |listener|
+            listener.call(value)
+          rescue StandardError
+            next
+          end
+        end
+      rescue JSON::ParserError
+        next
+      end
+    rescue StandardError => error
+      @mutex.synchronize { @connection = nil if @connection.equal?(connection) }
+      fail_pending(TransportError.new(Redaction.text(error.message, @credential)))
+    end
+
+    def fail_pending(error)
+      queues = @mutex.synchronize { @pending.values.dup }
+      queues.each { |queue| queue << error }
+    end
+
+    def unwrap(response, expected_id)
+      unless response.is_a?(Hash) && response["id"] == expected_id
+        raise InvalidResponseError, "ERPC returned an invalid WebSocket response"
+      end
+      if response.key?("error")
+        error = response["error"]
+        unless error.is_a?(Hash) && error["code"].is_a?(Integer) && error["message"].is_a?(String)
+          raise InvalidResponseError, "ERPC returned an invalid RPC error"
+        end
+        data = error.key?("data") ? Redaction.value(error["data"], @credential) : nil
+        raise JsonRpcError.new(error["code"], Redaction.text(error["message"], @credential), data)
+      end
+      raise InvalidResponseError, "ERPC returned an invalid WebSocket response" unless response.key?("result")
+
+      response["result"]
+    end
+  end
+
+  class RpcSubscription
+    include Enumerable
+
+    attr_reader :id
+
+    def initialize(id, queue, unsubscribe)
+      @id = id
+      @queue = queue
+      @unsubscribe = unsubscribe
+      @closed = false
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      loop { yield self.next }
+    rescue StopIteration
+      self
+    end
+
+    def next(timeout: nil)
+      raise StopIteration if @closed && @queue.empty?
+
+      return @queue.pop if timeout.nil?
+
+      Timeout.timeout(timeout) { @queue.pop }
+    rescue ::Timeout::Error
+      raise TimeoutError, timeout
+    end
+
+    def unsubscribe
+      return true if @closed
+
+      result = @unsubscribe.call
+      @closed = true if result
+      result
+    end
+  end
+
+  class SubscriptionsBase
+    def initialize(transport)
+      @transport = transport
+    end
+
+    def on_notification(listener = nil, &block)
+      @transport.on_notification(listener, &block)
+    end
+
+    def raw(method, params = nil)
+      @transport.request(method, params)
+    end
+
+    def close
+      @transport.close
+    end
+
+    private
+
+    def subscribe_to(subscribe_method, params, unsubscribe_method, listener)
+      queue = Queue.new
+      subscription_id = nil
+      remove = @transport.on_notification do |notification|
+        raw_params = notification["params"]
+        next unless raw_params.is_a?(Hash) && raw_params["subscription"] == subscription_id && raw_params.key?("result")
+
+        result = raw_params["result"]
+        queue << result
+        listener&.call(result)
+      end
+      subscription_id = @transport.request(subscribe_method, params)
+      unless subscription_id.is_a?(Integer) || subscription_id.is_a?(String)
+        remove.call
+        raise InvalidResponseError, "ERPC returned an invalid subscription id"
+      end
+      unsubscribe = lambda do
+        result = @transport.request(unsubscribe_method, [subscription_id])
+        raise InvalidResponseError, "ERPC returned an invalid unsubscribe result" unless [true, false].include?(result)
+
+        remove.call if result
+        result
+      end
+      RpcSubscription.new(subscription_id, queue, unsubscribe)
+    rescue StandardError
+      remove&.call
+      raise
+    end
+  end
+
+  class EthereumSubscriptions < SubscriptionsBase
+    def subscribe(subscription, *options, listener: nil, &block)
+      result = subscribe_to("eth_subscribe", [subscription, *options], "eth_unsubscribe", listener || block)
+      unless result.id.is_a?(String)
+        result.unsubscribe
+        raise InvalidResponseError, "ERPC returned an invalid subscription id"
+      end
+      result
+    end
+  end
+
+  class SolanaSubscriptions < SubscriptionsBase
+    def account_subscribe(address, options = nil, listener: nil, &block)
+      params = [address]
+      params << options unless options.nil?
+      numeric_subscribe("accountSubscribe", params, "accountUnsubscribe", listener || block)
+    end
+
+    def transaction_subscribe(filter, options = nil, listener: nil, &block)
+      params = [filter]
+      params << options unless options.nil?
+      numeric_subscribe("transactionSubscribe", params, "transactionUnsubscribe", listener || block)
+    end
+
+    def raw_subscribe(subscribe_method, params, unsubscribe_method, listener: nil, &block)
+      subscribe_to(subscribe_method, params, unsubscribe_method, listener || block)
+    end
+
+    private
+
+    def numeric_subscribe(subscribe_method, params, unsubscribe_method, listener)
+      result = subscribe_to(subscribe_method, params, unsubscribe_method, listener)
+      unless result.id.is_a?(Integer)
+        result.unsubscribe
+        raise InvalidResponseError, "ERPC returned an invalid subscription id"
+      end
+      result
+    end
+  end
+end

data/lib/erpc_sdk.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "erpc_sdk/version"
+require_relative "erpc_sdk/errors"
+require_relative "erpc_sdk/config"
+require_relative "erpc_sdk/transport"
+require_relative "erpc_sdk/rpc"
+require_relative "erpc_sdk/rest"
+require_relative "erpc_sdk/websocket"
+require_relative "erpc_sdk/client"