erpc-sdk 0.7.0 → 0.8.0

data/lib/erpc_sdk/transport.rb

@@ -18,9 +18,9 @@ module ERPC
       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
+      raise TimeoutError, timeout, cause: nil
     rescue IOError, EOFError, SocketError, SystemCallError, OpenSSL::SSL::SSLError
-      raise TransportError, "Unable to reach ERPC"
+      raise TransportError, "Unable to reach ERPC", cause: nil
     end
 
     def stream(url:, headers:, timeout: DEFAULT_TIMEOUT)
@@ -36,11 +36,11 @@ module ERPC
           end
         end
       rescue Net::OpenTimeout, Net::ReadTimeout, Net::WriteTimeout
-        raise TimeoutError, timeout
+        raise TimeoutError, timeout, cause: nil
       rescue HttpError
         raise
       rescue IOError, EOFError, SocketError, SystemCallError, OpenSSL::SSL::SSLError
-        raise TransportError, "Unable to reach ERPC"
+        raise TransportError, "Unable to reach ERPC", cause: nil
       end
     end
 
@@ -57,20 +57,34 @@ module ERPC
   end
 
   class HttpJsonRpcTransport
-    attr_reader :endpoint, :max_batch_size
+    attr_reader :max_batch_size
 
-    def initialize(api_key:, endpoint:, headers:, timeout:, adapter:, max_batch_size: 256)
+    def initialize(api_key: nil, endpoint:, headers: {}, timeout:, adapter:, max_batch_size: 256,
+                   direct: false, redactions: [], unavailable_namespace: nil)
       @api_key = api_key
       @endpoint = endpoint
-      @headers = headers
+      @public_endpoint = URLs.public_endpoint(endpoint)
+      @headers = headers.to_h.dup.freeze
       @timeout = timeout
       @adapter = adapter
       @max_batch_size = max_batch_size
+      @direct = direct
+      @redactions = redactions
+      @unavailable_namespace = unavailable_namespace
       @next_id = 0
       @id_mutex = Mutex.new
     end
 
+    def endpoint
+      @public_endpoint
+    end
+
+    def inspect
+      "#<#{self.class} endpoint=#{endpoint.inspect} max_batch_size=#{max_batch_size.inspect}>"
+    end
+
     def request(method, params = nil)
+      ensure_configured
       request_id = next_id
       body = { "jsonrpc" => "2.0", "id" => request_id, "method" => method }
       body["params"] = params unless params.nil?
@@ -82,6 +96,7 @@ module ERPC
       if calls.length > max_batch_size
         raise InvalidResponseError, "A batch may contain at most #{max_batch_size} calls"
       end
+      ensure_configured
 
       requests = calls.map do |call|
         method = call.fetch(:method) { call.fetch("method") }
@@ -123,19 +138,28 @@ module ERPC
 
     private
 
+    def ensure_configured
+      return if @unavailable_namespace.nil?
+
+      raise NotConfiguredError, @unavailable_namespace
+    end
+
     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)
+      ensure_configured
+      uri = URI.parse(@endpoint)
+      unless @direct
+        query = URI.decode_www_form(uri.query.to_s)
+        query << ["api-key", @api_key]
+        uri.query = URI.encode_www_form(query)
+      end
       response = @adapter.request(
         method: :post,
         url: uri.to_s,
-        headers: @headers.merge("accept" => "application/json", "content-type" => "application/json"),
+        headers: protocol_headers,
         body: JSON.generate(body),
         timeout: @timeout
       )
@@ -143,7 +167,7 @@ module ERPC
 
       JSON.parse(response.body)
     rescue JSON::ParserError
-      raise InvalidResponseError, "ERPC returned malformed JSON"
+      raise InvalidResponseError, "ERPC returned malformed JSON", cause: nil
     end
 
     def unwrap(response, expected_id)
@@ -161,8 +185,17 @@ module ERPC
         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)
+      credentials = @direct ? @redactions : @api_key
+      data = error.key?("data") ? Redaction.value(error["data"], credentials) : nil
+      raise JsonRpcError.new(error["code"], Redaction.text(error["message"], credentials), data)
+    end
+
+    def protocol_headers
+      headers = @headers.dup
+      if @direct
+        headers.delete_if { |name, _| %w[accept content-type].include?(name.to_s.downcase) }
+      end
+      headers.merge("accept" => "application/json", "content-type" => "application/json")
     end
 
     def valid_id?(value)
@@ -171,17 +204,26 @@ module ERPC
   end
 
   class RestTransport
-    attr_reader :endpoint
-
-    def initialize(credential:, endpoint:, headers:, timeout:, adapter:)
+    def initialize(credential: nil, endpoint:, headers: {}, timeout:, adapter:, unavailable_namespace: nil)
       @credential = credential
       @endpoint = endpoint
-      @headers = headers
+      @public_endpoint = URLs.public_endpoint(endpoint)
+      @headers = headers.to_h.dup.freeze
       @timeout = timeout
       @adapter = adapter
+      @unavailable_namespace = unavailable_namespace
+    end
+
+    def endpoint
+      @public_endpoint
+    end
+
+    def inspect
+      "#<#{self.class} endpoint=#{endpoint.inspect}>"
     end
 
     def get(path, query = nil)
+      ensure_configured
       response = @adapter.request(
         method: :get,
         url: url(path, query),
@@ -192,10 +234,11 @@ module ERPC
 
       JSON.parse(response.body)
     rescue JSON::ParserError
-      raise InvalidResponseError, "ERPC returned malformed JSON"
+      raise InvalidResponseError, "ERPC returned malformed JSON", cause: nil
     end
 
     def stream(path, query = nil)
+      ensure_configured
       @adapter.stream(
         url: url(path, query),
         headers: @headers.merge("authorization" => "Bearer #{@credential}", "accept" => "text/event-stream"),
@@ -205,6 +248,12 @@ module ERPC
 
     private
 
+    def ensure_configured
+      return if @unavailable_namespace.nil?
+
+      raise NotConfiguredError, @unavailable_namespace
+    end
+
     def url(path, query)
       uri = URI.parse(URLs.with_path(endpoint, path))
       pairs = []

data/lib/erpc_sdk/version.rb

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

data/lib/erpc_sdk/websocket.rb

@@ -22,6 +22,10 @@ module ERPC
       connect
     end
 
+    def inspect
+      "#<#{self.class} endpoint=#{URLs.public_endpoint(@uri).inspect}>"
+    end
+
     def write_text(text)
       write_frame(0x1, text.b)
     end
@@ -84,13 +88,13 @@ module ERPC
       handshake
     rescue ::Timeout::Error
       tcp&.close
-      raise TimeoutError, @timeout
+      raise TimeoutError, @timeout, cause: nil
     rescue ConfigError, TimeoutError
       tcp&.close
       raise
     rescue IOError, EOFError, SocketError, SystemCallError, OpenSSL::SSL::SSLError
       tcp&.close
-      raise TransportError, "Unable to reach ERPC WebSocket"
+      raise TransportError, "Unable to reach ERPC WebSocket", cause: nil
     end
 
     def handshake
@@ -123,7 +127,7 @@ module ERPC
         raise TransportError, "ERPC returned an invalid WebSocket upgrade"
       end
     rescue ::Timeout::Error
-      raise TimeoutError, @timeout
+      raise TimeoutError, @timeout, cause: nil
     end
 
     def read_until(delimiter, limit)
@@ -176,16 +180,16 @@ module ERPC
         Timeout.timeout(@timeout) { @socket.write(prefix + mask + masked) }
       end
     rescue ::Timeout::Error
-      raise TimeoutError, @timeout
+      raise TimeoutError, @timeout, cause: nil
     rescue IOError, EOFError, SocketError, SystemCallError, OpenSSL::SSL::SSLError
-      raise TransportError, "Unable to reach ERPC WebSocket"
+      raise TransportError, "Unable to reach ERPC WebSocket", cause: nil
     end
 
     def read_exact(length)
       value = +"".b
       while value.bytesize < length
         ready = IO.select([@socket], nil, nil, @timeout)
-        raise TimeoutError, @timeout unless ready
+        raise TimeoutError, @timeout, cause: nil unless ready
 
         chunk = @socket.readpartial(length - value.bytesize)
         raise EOFError if chunk.empty?
@@ -194,7 +198,7 @@ module ERPC
       end
       value
     rescue EOFError, IOError, SocketError, SystemCallError, OpenSSL::SSL::SSLError
-      raise TransportError, "ERPC WebSocket connection closed"
+      raise TransportError, "ERPC WebSocket connection closed", cause: nil
     end
 
     def secure_compare(left, right)
@@ -205,10 +209,17 @@ module ERPC
   end
 
   class WebSocketJsonRpcTransport
-    def initialize(connection_url, credential, timeout, connection_factory: nil)
+    attr_reader :endpoint
+
+    def initialize(connection_url, credential, timeout, connection_factory: nil, direct: false,
+                   redactions: [], unavailable_namespace: nil)
       @connection_url = connection_url
       @credential = credential
       @timeout = timeout
+      @direct = direct
+      @redactions = redactions
+      @unavailable_namespace = unavailable_namespace
+      @endpoint = URLs.public_endpoint(connection_url)
       @connection_factory = connection_factory || ->(url, seconds) { WebSocketConnection.new(url, seconds) }
       @mutex = Mutex.new
       @connection = nil
@@ -220,6 +231,10 @@ module ERPC
       @closed = false
     end
 
+    def inspect
+      "#<#{self.class} endpoint=#{endpoint.inspect}>"
+    end
+
     def request(method, params = nil)
       connection = ensure_connection
       request_id = @mutex.synchronize { @next_id += 1 }
@@ -233,7 +248,7 @@ module ERPC
 
       unwrap(response, request_id)
     rescue ::Timeout::Error
-      raise TimeoutError, @timeout
+      raise TimeoutError, @timeout, cause: nil
     ensure
       @mutex.synchronize { @pending.delete(request_id) } if request_id
     end
@@ -268,6 +283,7 @@ module ERPC
     private
 
     def ensure_connection
+      ensure_configured
       @mutex.synchronize do
         raise TransportError, "WebSocket transport is closed" if @closed
         return @connection if @connection
@@ -302,7 +318,7 @@ module ERPC
       end
     rescue StandardError => error
       @mutex.synchronize { @connection = nil if @connection.equal?(connection) }
-      fail_pending(TransportError.new(Redaction.text(error.message, @credential)))
+      fail_pending(TransportError.new(Redaction.text(error.message, redaction_credentials)))
     end
 
     def fail_pending(error)
@@ -319,13 +335,25 @@ module ERPC
         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)
+        credentials = redaction_credentials
+        data = error.key?("data") ? Redaction.value(error["data"], credentials) : nil
+        raise JsonRpcError.new(error["code"], Redaction.text(error["message"], credentials), data)
       end
       raise InvalidResponseError, "ERPC returned an invalid WebSocket response" unless response.key?("result")
 
       response["result"]
     end
+
+    def ensure_configured
+      return if @unavailable_namespace.nil?
+
+      raise NotConfiguredError, @unavailable_namespace
+    end
+
+    def redaction_credentials
+      @direct ? @redactions : @credential
+    end
+
   end
 
   class RpcSubscription
@@ -355,7 +383,7 @@ module ERPC
 
       Timeout.timeout(timeout) { @queue.pop }
     rescue ::Timeout::Error
-      raise TimeoutError, timeout
+      raise TimeoutError, timeout, cause: nil
     end
 
     def unsubscribe
@@ -372,6 +400,10 @@ module ERPC
       @transport = transport
     end
 
+    def endpoint
+      @transport.endpoint
+    end
+
     def on_notification(listener = nil, &block)
       @transport.on_notification(listener, &block)
     end

data/lib/erpc_sdk.rb

@@ -12,3 +12,4 @@ require_relative "erpc_sdk/swap"
 require_relative "erpc_sdk/client"
 require_relative "erpc_sdk/token_catalog"
 require_relative "erpc_sdk/token_rankings"
+require_relative "erpc_sdk/bridge"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: erpc-sdk
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - ELSOUL LABO B.V.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-16 00:00:00.000000000 Z
+date: 2026-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -60,11 +60,14 @@ files:
 - LICENSE
 - README.md
 - lib/erpc_sdk.rb
+- lib/erpc_sdk/bridge.rb
 - lib/erpc_sdk/client.rb
 - lib/erpc_sdk/config.rb
 - lib/erpc_sdk/dex_catalog.rb
 - lib/erpc_sdk/errors.rb
+- lib/erpc_sdk/generated/bridge_capabilities.rb
 - lib/erpc_sdk/generated/dex_catalog.rb
+- lib/erpc_sdk/generated/swap_execution_capabilities.rb
 - lib/erpc_sdk/generated/token_catalog.rb
 - lib/erpc_sdk/generated/token_rankings.rb
 - lib/erpc_sdk/rest.rb