erpc-sdk 0.6.0 → 0.8.0

data/lib/erpc_sdk/client.rb

@@ -23,57 +23,165 @@ module ERPC
   )
 
   class Client
-    attr_reader :solana, :ethereum, :avalanche, :price, :account, :usage
+    attr_reader :solana, :ethereum, :avalanche, :price, :account, :usage, :swap
 
     def initialize(config, http_adapter: nil, websocket_factory: nil)
       adapter = http_adapter || NetHttpAdapter.new
-      solana_transport = HttpJsonRpcTransport.new(
-        api_key: config.api_key,
-        endpoint: config.endpoint,
-        headers: config.headers,
-        timeout: config.timeout,
-        adapter: adapter
-      )
-      ethereum_transport = HttpJsonRpcTransport.new(
-        api_key: config.api_key,
-        endpoint: URLs.with_path(config.endpoint, "/eth"),
-        headers: config.headers,
-        timeout: config.timeout,
-        adapter: adapter
-      )
-      avalanche_transport = HttpJsonRpcTransport.new(
-        api_key: config.api_key,
-        endpoint: URLs.with_path(config.avalanche_endpoint, "/ava"),
-        headers: config.headers,
-        timeout: config.timeout,
-        adapter: adapter
-      )
-      avalanche_index_transport = lambda do |path|
+      unavailable_http = lambda do |namespace|
         HttpJsonRpcTransport.new(
-          api_key: config.api_key,
-          endpoint: URLs.with_path(config.avalanche_endpoint, path),
-          headers: config.headers,
+          endpoint: URLs.unavailable_endpoint(namespace),
+          headers: {},
           timeout: config.timeout,
-          adapter: adapter
+          adapter: adapter,
+          unavailable_namespace: namespace
         )
       end
-      solana_ws = WebSocketJsonRpcTransport.new(
-        URLs.websocket(config.endpoint, config.api_key),
-        config.api_key,
-        config.timeout,
-        connection_factory: websocket_factory
+      legacy_http = lambda do |endpoint, namespace|
+        if config.api_key.nil?
+          unavailable_http.call(namespace)
+        else
+          HttpJsonRpcTransport.new(
+            api_key: config.api_key,
+            endpoint: endpoint,
+            headers: config.headers,
+            timeout: config.timeout,
+            adapter: adapter
+          )
+        end
+      end
+      direct_http = lambda do |override|
+        HttpJsonRpcTransport.new(
+          endpoint: override.http_url,
+          headers: override.headers,
+          timeout: config.timeout,
+          adapter: adapter,
+          direct: true,
+          redactions: Redaction.direct_variants(
+            http_url: override.http_url,
+            websocket_url: override.websocket_url,
+            headers: override.headers
+          )
+        )
+      end
+      selected_http = lambda do |override, endpoint, namespace|
+        override.nil? ? legacy_http.call(endpoint, namespace) : direct_http.call(override)
+      end
+
+      unavailable_websocket = lambda do |namespace|
+        WebSocketJsonRpcTransport.new(
+          URLs.unavailable_endpoint(namespace),
+          nil,
+          config.timeout,
+          connection_factory: websocket_factory,
+          unavailable_namespace: namespace
+        )
+      end
+      legacy_websocket = lambda do |endpoint, namespace|
+        if config.api_key.nil?
+          unavailable_websocket.call(namespace)
+        else
+          WebSocketJsonRpcTransport.new(
+            endpoint,
+            config.api_key,
+            config.timeout,
+            connection_factory: websocket_factory
+          )
+        end
+      end
+      direct_websocket = lambda do |override, namespace|
+        if override.websocket_url.nil?
+          unavailable_websocket.call(namespace)
+        else
+          WebSocketJsonRpcTransport.new(
+            override.websocket_url,
+            nil,
+            config.timeout,
+            connection_factory: websocket_factory,
+            direct: true,
+            redactions: Redaction.direct_variants(
+              http_url: override.http_url,
+              websocket_url: override.websocket_url,
+              headers: override.headers
+            )
+          )
+        end
+      end
+      selected_websocket = lambda do |override, endpoint, namespace|
+        override.nil? ? legacy_websocket.call(endpoint, namespace) : direct_websocket.call(override, namespace)
+      end
+
+      solana_transport = selected_http.call(config.solana_rpc, config.endpoint, "solana.rpc")
+      solana_aux_transport = if config.solana_rpc || config.api_key
+                              solana_transport
+                            else
+                              unavailable_http.call("solana.das")
+                            end
+      solana_history_transport = if config.solana_rpc || config.api_key
+                                  solana_transport
+                                else
+                                  unavailable_http.call("solana.history")
+                                end
+      solana_leaders_transport = if config.solana_rpc || config.api_key
+                                  solana_transport
+                                else
+                                  unavailable_http.call("solana.leaders")
+                                end
+      solana_analytics_transport = if config.solana_rpc || config.api_key
+                                    solana_transport
+                                  else
+                                    unavailable_http.call("solana.analytics")
+                                  end
+      ethereum_transport = selected_http.call(
+        config.ethereum_rpc,
+        URLs.with_path(config.endpoint, "/eth"),
+        "ethereum.rpc"
+      )
+      avalanche_transport = selected_http.call(
+        config.avalanche_c_rpc,
+        URLs.with_path(config.avalanche_endpoint, "/ava"),
+        "avalanche.rpc"
+      )
+      avalanche_avax_transport = legacy_http.call(
+        URLs.with_path(config.avalanche_endpoint, "/ava"),
+        "avalanche.avax"
       )
-      ethereum_ws = WebSocketJsonRpcTransport.new(
-        URLs.websocket(config.endpoint, config.api_key, "/eth"),
-        config.api_key,
-        config.timeout,
-        connection_factory: websocket_factory
+      avalanche_x_chain_transport = if config.api_key
+                                     avalanche_avax_transport
+                                   else
+                                     unavailable_http.call("avalanche.x_chain")
+                                   end
+      avalanche_p_chain_transport = if config.api_key
+                                     avalanche_avax_transport
+                                   else
+                                     unavailable_http.call("avalanche.p_chain")
+                                   end
+      avalanche_proposer_vm_transport = if config.api_key
+                                        avalanche_avax_transport
+                                      else
+                                        unavailable_http.call("avalanche.proposer_vm")
+                                      end
+      avalanche_info_transport = if config.api_key
+                                  avalanche_avax_transport
+                                else
+                                  unavailable_http.call("avalanche.info")
+                                end
+      avalanche_index_transport = lambda do |path, namespace|
+        legacy_http.call(URLs.with_path(config.avalanche_endpoint, path), namespace)
+      end
+      solana_ws = selected_websocket.call(
+        config.solana_rpc,
+        config.api_key.nil? ? URLs.unavailable_endpoint("solana.subscriptions") : URLs.websocket(config.endpoint, config.api_key, ""),
+        "solana.subscriptions"
+      )
+      ethereum_ws = selected_websocket.call(
+        config.ethereum_rpc,
+        config.api_key.nil? ? URLs.unavailable_endpoint("ethereum.subscriptions") : URLs.websocket(config.endpoint, config.api_key, "/eth"),
+        "ethereum.subscriptions"
       )
-      avalanche_ws = WebSocketJsonRpcTransport.new(
-        URLs.websocket(config.avalanche_endpoint, config.api_key, "/ava-ws"),
-        config.api_key,
-        config.timeout,
-        connection_factory: websocket_factory
+      avalanche_ws = selected_websocket.call(
+        config.avalanche_c_rpc,
+        config.api_key.nil? ? URLs.unavailable_endpoint("avalanche.subscriptions") : URLs.websocket(config.avalanche_endpoint, config.api_key, "/ava-ws"),
+        "avalanche.subscriptions"
       )
 
       @solana = SolanaClient.new(
@@ -83,16 +191,16 @@ module ERPC
           parameter_mode: :positional,
           batch_policy: :solana_standard
         ),
-        das: RpcNamespace.new(solana_transport, SOLANA_DAS_METHODS, parameter_mode: :named),
-        history: RpcNamespace.new(solana_transport, SOLANA_HISTORY_METHODS, parameter_mode: :positional),
+        das: RpcNamespace.new(solana_aux_transport, SOLANA_DAS_METHODS, parameter_mode: :named),
+        history: RpcNamespace.new(solana_history_transport, SOLANA_HISTORY_METHODS, parameter_mode: :positional),
         leaders: RpcNamespace.new(
-          solana_transport,
+          solana_leaders_transport,
           SOLANA_LEADER_METHODS,
           parameter_mode: :positional,
           batch_policy: :unsupported
         ),
         analytics: RpcNamespace.new(
-          solana_transport,
+          solana_analytics_transport,
           SOLANA_ANALYTICS_METHODS,
           parameter_mode: :positional
         ),
@@ -104,65 +212,96 @@ module ERPC
       )
       @avalanche = AvalancheClient.new(
         rpc: RpcNamespace.new(avalanche_transport, ETHEREUM_RPC_METHODS, parameter_mode: :positional),
-        avax: avalanche_namespace(avalanche_transport, AVALANCHE_AVAX_METHODS, "avax"),
-        x_chain: avalanche_namespace(avalanche_transport, AVALANCHE_X_CHAIN_METHODS, "avm"),
-        p_chain: avalanche_namespace(avalanche_transport, AVALANCHE_P_CHAIN_METHODS, "platform"),
+        avax: avalanche_namespace(avalanche_avax_transport, AVALANCHE_AVAX_METHODS, "avax"),
+        x_chain: avalanche_namespace(avalanche_x_chain_transport, AVALANCHE_X_CHAIN_METHODS, "avm"),
+        p_chain: avalanche_namespace(avalanche_p_chain_transport, AVALANCHE_P_CHAIN_METHODS, "platform"),
         proposer_vm: avalanche_namespace(
-          avalanche_transport,
+          avalanche_proposer_vm_transport,
           AVALANCHE_PROPOSER_VM_METHODS,
           "proposervm"
         ),
-        info: avalanche_namespace(avalanche_transport, AVALANCHE_INFO_METHODS, "info"),
+        info: avalanche_namespace(avalanche_info_transport, AVALANCHE_INFO_METHODS, "info"),
         index: AvalancheIndexClient.new(
           c_chain_blocks: avalanche_namespace(
-            avalanche_index_transport.call("/ava/ext/index/C/block"),
+            avalanche_index_transport.call("/ava/ext/index/C/block", "avalanche.index.c_chain_blocks"),
             AVALANCHE_INDEX_METHODS,
             "index"
           ),
           p_chain_blocks: avalanche_namespace(
-            avalanche_index_transport.call("/ava/ext/index/P/block"),
+            avalanche_index_transport.call("/ava/ext/index/P/block", "avalanche.index.p_chain_blocks"),
             AVALANCHE_INDEX_METHODS,
             "index"
           ),
           x_chain_blocks: avalanche_namespace(
-            avalanche_index_transport.call("/ava/ext/index/X/block"),
+            avalanche_index_transport.call("/ava/ext/index/X/block", "avalanche.index.x_chain_blocks"),
             AVALANCHE_INDEX_METHODS,
             "index"
           ),
           x_chain_transactions: avalanche_namespace(
-            avalanche_index_transport.call("/ava/ext/index/X/tx"),
+            avalanche_index_transport.call("/ava/ext/index/X/tx", "avalanche.index.x_chain_transactions"),
             AVALANCHE_INDEX_METHODS,
             "index"
           )
         ),
         subscriptions: EthereumSubscriptions.new(avalanche_ws)
       )
+      @swap = SwapClient.new(
+        ethereum_transport: ethereum_transport,
+        avalanche_transport: avalanche_transport
+      )
       @price = PriceClient.new(
-        RestTransport.new(
-          credential: config.api_key,
-          endpoint: config.endpoint,
-          headers: config.headers,
-          timeout: config.timeout,
-          adapter: adapter
-        )
+        if config.api_key.nil?
+          RestTransport.new(
+            endpoint: URLs.unavailable_endpoint("price"),
+            timeout: config.timeout,
+            adapter: adapter,
+            unavailable_namespace: "price"
+          )
+        else
+          RestTransport.new(
+            credential: config.api_key,
+            endpoint: config.endpoint,
+            headers: config.headers,
+            timeout: config.timeout,
+            adapter: adapter
+          )
+        end
       )
       @account = AccountClient.new(
-        RestTransport.new(
-          credential: config.api_key,
-          endpoint: config.account_endpoint,
-          headers: config.headers,
-          timeout: config.timeout,
-          adapter: adapter
-        )
+        if config.api_key.nil?
+          RestTransport.new(
+            endpoint: URLs.unavailable_endpoint("account"),
+            timeout: config.timeout,
+            adapter: adapter,
+            unavailable_namespace: "account"
+          )
+        else
+          RestTransport.new(
+            credential: config.api_key,
+            endpoint: config.account_endpoint,
+            headers: config.headers,
+            timeout: config.timeout,
+            adapter: adapter
+          )
+        end
       )
       @usage = UsageClient.new(
-        RestTransport.new(
-          credential: config.api_key,
-          endpoint: config.user_endpoint,
-          headers: config.headers,
-          timeout: config.timeout,
-          adapter: adapter
-        )
+        if config.api_key.nil?
+          RestTransport.new(
+            endpoint: URLs.unavailable_endpoint("usage"),
+            timeout: config.timeout,
+            adapter: adapter,
+            unavailable_namespace: "usage"
+          )
+        else
+          RestTransport.new(
+            credential: config.api_key,
+            endpoint: config.user_endpoint,
+            headers: config.headers,
+            timeout: config.timeout,
+            adapter: adapter
+          )
+        end
       )
       @closed = false
     end

data/lib/erpc_sdk/config.rb

@@ -12,6 +12,33 @@ module ERPC
   module URLs
     module_function
 
+    DIRECT_HTTP_SCHEMES = %w[http https].freeze
+    DIRECT_WEBSOCKET_SCHEMES = %w[ws wss].freeze
+
+    def direct_endpoint(value, kind:, namespace: "direct endpoint")
+      schemes = kind == :websocket ? DIRECT_WEBSOCKET_SCHEMES : DIRECT_HTTP_SCHEMES
+      unless value.is_a?(String)
+        raise ConfigError, "#{namespace} must be an absolute #{kind == :websocket ? 'WS(S)' : 'HTTP(S)'} URL", cause: nil
+      end
+
+      input = value.strip
+      scheme_match = input.match?(/\A[a-z][a-z\d+.-]*:\/\//i)
+      authority = input[/\A[a-z][a-z\d+.-]*:\/\/([^\/?#]*)/i, 1]
+      valid = !input.empty? && scheme_match && !input.include?("#") && authority &&
+              !authority.empty? && !authority.include?("@")
+      begin
+        uri = URI.parse(input)
+        valid &&= uri.absolute? && !uri.host.to_s.empty? && schemes.include?(uri.scheme)
+      rescue URI::InvalidURIError, ArgumentError
+        valid = false
+      end
+      unless valid
+        raise ConfigError, "#{namespace} must be an absolute #{kind == :websocket ? 'WS(S)' : 'HTTP(S)'} URL", cause: nil
+      end
+
+      input.freeze
+    end
+
     def normalize_endpoint(value, local_http_only: false)
       uri = URI.parse(value.to_s)
       unless uri.absolute? && uri.host && %w[http https].include?(uri.scheme)
@@ -29,7 +56,22 @@ module ERPC
       uri.path = "/" if uri.path.empty?
       uri.to_s
     rescue URI::InvalidURIError, ArgumentError
-      raise ConfigError, "endpoint must be an absolute HTTP(S) URL"
+      raise ConfigError, "endpoint must be an absolute HTTP(S) URL", cause: nil
+    end
+
+    def public_endpoint(endpoint)
+      uri = endpoint.is_a?(URI::Generic) ? endpoint.dup : URI.parse(endpoint.to_s)
+      uri.query = nil
+      uri.fragment = nil
+      uri.user = nil if uri.respond_to?(:user=)
+      uri.to_s
+    rescue URI::InvalidURIError, ArgumentError
+      "[REDACTED]"
+    end
+
+    def unavailable_endpoint(namespace)
+      safe = namespace.to_s.gsub(/[^a-z\d._-]+/i, "-")
+      "https://unconfigured.invalid/#{safe}"
     end
 
     def with_path(endpoint, path)
@@ -56,14 +98,65 @@ module ERPC
     end
   end
 
+  class RpcEndpointConfig
+    attr_reader :http_url, :websocket_url, :headers
+
+    def initialize(http_url:, websocket_url: nil, headers: {})
+      @http_url = URLs.direct_endpoint(http_url, kind: :http, namespace: "http_url")
+      @websocket_url = if websocket_url.nil?
+                         nil
+                       else
+                         URLs.direct_endpoint(websocket_url, kind: :websocket, namespace: "websocket_url")
+                       end
+      unless headers.is_a?(Hash) || headers.respond_to?(:to_h)
+        raise ConfigError, "direct endpoint headers must be a mapping"
+      end
+
+      begin
+        values = headers.to_h
+      rescue StandardError
+        raise ConfigError, "direct endpoint headers must be a mapping", cause: nil
+      end
+      unless values.all? { |name, value| name.is_a?(String) && value.is_a?(String) }
+        raise ConfigError, "direct endpoint headers must contain string names and values"
+      end
+
+      @headers = values.dup.freeze
+      freeze
+    end
+
+    def inspect
+      websocket = websocket_url.nil? ? "nil" : URLs.public_endpoint(websocket_url).inspect
+      "#<#{self.class} http_url=#{URLs.public_endpoint(http_url).inspect} " \
+        "websocket_url=#{websocket} " \
+        "header_names=#{headers.keys.inspect}>"
+    end
+
+    alias to_s inspect
+  end
+
   class ClientConfig
-    attr_reader :api_key, :endpoint, :account_endpoint, :user_endpoint, :headers, :timeout, :avalanche_endpoint
+    attr_reader :api_key, :endpoint, :account_endpoint, :user_endpoint, :headers, :timeout,
+                :avalanche_endpoint, :solana_rpc, :ethereum_rpc, :avalanche_c_rpc
 
-    def initialize(api_key:, endpoint: DEFAULT_ENDPOINT, account_endpoint: DEFAULT_ACCOUNT_ENDPOINT,
+    def initialize(api_key: nil, endpoint: DEFAULT_ENDPOINT, account_endpoint: DEFAULT_ACCOUNT_ENDPOINT,
                    user_endpoint: DEFAULT_USER_ENDPOINT, headers: {}, timeout: DEFAULT_TIMEOUT,
-                   avalanche_endpoint: DEFAULT_AVALANCHE_ENDPOINT)
-      @api_key = api_key.to_s.strip
-      raise ConfigError, "api_key must not be empty" if @api_key.empty?
+                   avalanche_endpoint: DEFAULT_AVALANCHE_ENDPOINT, solana_rpc: nil,
+                   ethereum_rpc: nil, avalanche_c_rpc: nil)
+      direct_endpoints = [solana_rpc, ethereum_rpc, avalanche_c_rpc]
+      unless direct_endpoints.all? { |value| value.nil? || value.is_a?(RpcEndpointConfig) }
+        raise ConfigError, "direct RPC overrides must use RpcEndpointConfig"
+      end
+
+      @api_key = if api_key.nil?
+                   nil
+                 elsif api_key.is_a?(String)
+                   api_key.strip
+                 else
+                   raise ConfigError, "api_key must be a string"
+                 end
+      @api_key = nil if @api_key&.empty?
+      raise ConfigError, "api_key must not be empty" if @api_key.nil? && direct_endpoints.compact.empty?
       raise ConfigError, "timeout must be positive" unless timeout.is_a?(Numeric) && timeout.finite? && timeout.positive?
 
       @endpoint = URLs.normalize_endpoint(endpoint)
@@ -72,13 +165,19 @@ module ERPC
       @user_endpoint = URLs.normalize_endpoint(user_endpoint)
       @headers = headers.to_h.transform_keys(&:to_s).transform_values(&:to_s).freeze
       @timeout = timeout.to_f
+      @solana_rpc = solana_rpc
+      @ethereum_rpc = ethereum_rpc
+      @avalanche_c_rpc = avalanche_c_rpc
     end
 
     def inspect
-      "#<#{self.class} api_key=[REDACTED] endpoint=#{endpoint.inspect} " \
+      key = api_key.nil? ? nil : "[REDACTED]"
+      "#<#{self.class} api_key=#{key.inspect} endpoint=#{endpoint.inspect} " \
         "avalanche_endpoint=#{avalanche_endpoint.inspect} " \
         "account_endpoint=#{account_endpoint.inspect} user_endpoint=#{user_endpoint.inspect} " \
-        "header_names=#{headers.keys.inspect} timeout=#{timeout.inspect}>"
+        "header_names=#{headers.keys.inspect} timeout=#{timeout.inspect} " \
+        "solana_rpc=#{solana_rpc.inspect} ethereum_rpc=#{ethereum_rpc.inspect} " \
+        "avalanche_c_rpc=#{avalanche_c_rpc.inspect}>"
     end
   end