erpc-sdk 0.7.0 → 0.8.0

data/lib/erpc_sdk/client.rb

@@ -27,53 +27,161 @@ module ERPC
 
     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"
       )
-      ethereum_ws = WebSocketJsonRpcTransport.new(
-        URLs.websocket(config.endpoint, config.api_key, "/eth"),
-        config.api_key,
-        config.timeout,
-        connection_factory: websocket_factory
+      avalanche_avax_transport = legacy_http.call(
+        URLs.with_path(config.avalanche_endpoint, "/ava"),
+        "avalanche.avax"
       )
-      avalanche_ws = WebSocketJsonRpcTransport.new(
-        URLs.websocket(config.avalanche_endpoint, config.api_key, "/ava-ws"),
-        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 = 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,33 +212,33 @@ 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"
           )
@@ -142,31 +250,58 @@ module ERPC
         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
 

data/lib/erpc_sdk/errors.rb

@@ -1,11 +1,20 @@
 # frozen_string_literal: true
 
 require "uri"
+require "base64"
 
 module ERPC
   class Error < StandardError; end
 
   class ConfigError < Error; end
+  class NotConfiguredError < Error
+    attr_reader :namespace
+
+    def initialize(namespace)
+      @namespace = namespace.to_s.freeze
+      super("ERPC namespace #{@namespace.inspect} is not configured")
+    end
+  end
   class BatchPolicyError < Error; end
   class InvalidResponseError < Error; end
   class TransportError < Error; end
@@ -41,21 +50,30 @@ module ERPC
   module Redaction
     module_function
 
+    PERCENT_ESCAPE = /%[0-9A-Fa-f]{2}/.freeze
+
     def text(value, credential)
       result = value.to_s
-      variants(credential).each { |secret| result = result.gsub(secret, "[REDACTED]") unless secret.empty? }
+      variants(credential).each do |secret|
+        result = result.gsub(secret, "[REDACTED]") unless secret.empty?
+        next unless secret.match?(PERCENT_ESCAPE)
+
+        result = result.gsub(percent_escape_pattern(secret), "[REDACTED]")
+      end
       result
     end
 
-    def value(value, credential)
+    def value(value, credential, depth = 0)
+      return "[REDACTED]" if depth >= 32
+
       case value
       when String
         text(value, credential)
       when Array
-        value.map { |item| self.value(item, credential) }
+        value.map { |item| self.value(item, credential, depth + 1) }
       when Hash
         value.to_h do |key, item|
-          [text(key, credential), self.value(item, credential)]
+          [key.is_a?(String) ? text(key, credential) : key, self.value(item, credential, depth + 1)]
         end
       else
         value
@@ -63,12 +81,85 @@ module ERPC
     end
 
     def variants(credential)
-      percent_encoded = credential.to_s.b.each_byte.map do |byte|
-        character = byte.chr
-        character.match?(/[A-Za-z0-9_.~-]/) ? character : format("%%%02X", byte)
-      end.join
-      [credential.to_s, URI.encode_www_form_component(credential.to_s), percent_encoded].uniq
+      values = credential.is_a?(Array) ? credential : [credential]
+      encoded = values.flat_map do |value|
+        next [] if value.nil? || value.to_s.empty?
+
+        text = value.to_s
+        percent_encoded = text.b.each_byte.map do |byte|
+          character = byte.chr
+          character.match?(/[A-Za-z0-9_.~-]/) ? character : format("%%%02X", byte)
+        end.join
+        [
+          text,
+          URI.encode_www_form_component(text),
+          percent_encoded
+        ]
+      end
+      encoded.uniq.sort_by { |value| [-value.length, value] }
     end
     private_class_method :variants
+
+    def percent_escape_pattern(value)
+      escaped = Regexp.escape(value.to_s)
+      pattern = escaped.gsub(PERCENT_ESCAPE) do |escape|
+        "%#{percent_character_class(escape[1])}#{percent_character_class(escape[2])}"
+      end
+      Regexp.new(pattern)
+    end
+    private_class_method :percent_escape_pattern
+
+    def percent_character_class(value)
+      "[#{[value.upcase, value.downcase].uniq.join}]"
+    end
+    private_class_method :percent_character_class
+
+    def direct_variants(http_url:, websocket_url: nil, headers: {})
+      values = []
+      [http_url, websocket_url].compact.each do |endpoint|
+        query = URI.parse(endpoint).query.to_s
+        query.split("&").each do |component|
+          next if component.empty?
+
+          raw_value = component.include?("=") ? component.split("=", 2).last : component
+          next if raw_value.empty?
+
+          values << raw_value
+          begin
+            values << URI.decode_www_form_component(raw_value)
+          rescue ArgumentError
+            # The endpoint validator rejects invalid percent escapes. Keep
+            # the raw value as a defensive fallback for caller-built objects.
+          end
+        end
+      end
+
+      headers.each do |name, value|
+        next unless value.is_a?(String) && !value.empty?
+
+        values << value
+        next unless %w[authorization proxy-authorization].include?(name.to_s.downcase)
+
+        parts = value.strip.split(/\s+/, 2)
+        next unless parts.length == 2 && %w[bearer basic].include?(parts.first.downcase)
+
+        credential = parts.last
+        values << credential
+        next unless parts.first.casecmp?("basic")
+
+        begin
+          decoded = Base64.strict_decode64(credential).force_encoding(Encoding::UTF_8)
+          values << decoded
+          if decoded.include?(":")
+            username, password = decoded.split(":", 2)
+            values << username << password
+          end
+        rescue ArgumentError, EncodingError
+          # Raw and encoded forms above still cover malformed Basic values.
+        end
+      end
+
+      variants(values)
+    end
   end
 end

data/lib/erpc_sdk/generated/bridge_capabilities.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Generated by registry/generate-bridge-capabilities.mjs. Do not edit.
+
+module ERPC
+  BRIDGE_CAPABILITIES_JSON = '[{"bridgeCapabilityId":"bridge-mayan-swift-v2-eurc-eth-sol","providerId":"mayan-swift-v2","capabilityKind":"external-provider-dynamic","sourceChainId":"eip155:1","destinationChainId":"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp","sourceTokenDeploymentId":"deployment-0011","destinationTokenDeploymentId":"deployment-0013","sourceTokenAddress":"0x1abaea1f7c830bd89acc67ec4af516284b1bc33c","destinationTokenAddress":"HzwqbKZw8HxMN6bF2yFZNrht3c2iXXzpKcFu7uBEDKtr","sourceTokenStandard":"erc20","destinationTokenStandard":"spl-token","sourceTokenDecimals":6,"destinationTokenDecimals":6,"sourceProviderChainName":"ethereum","destinationProviderChainName":"solana","sourceProviderChainId":1,"destinationProviderChainId":0,"sourceWormholeChainId":2,"destinationWormholeChainId":1,"sourceUsdcDeploymentId":"deployment-0008","sourceUsdcAddress":"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48","sourceUsdcStandard":"erc20","sourceUsdcDecimals":6,"swiftContract":"0x40ffe85a28dc9993541449464d7529a922142960","forwarderAddress":"0x337685fdab40d39bd02028545a4ffa7d287cc3e2","forwarderFunctionSelector":"0x30dedc57","jupiterProgramAddress":null,"builderEndpoint":"https://tx-builder.mayan.finance","explorerEndpoint":"https://explorer-api.mayan.finance/v3","dependencies":["mayan-hosted-quote-api","mayan-hosted-transaction-builder","mayan-hosted-source-swap-builder","swift-auction-solvers","relayers","wormhole-guardian-messaging","mayan-explorer-indexer"],"status":"active"},{"bridgeCapabilityId":"bridge-mayan-swift-v2-eurc-sol-eth","providerId":"mayan-swift-v2","capabilityKind":"external-provider-dynamic","sourceChainId":"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp","destinationChainId":"eip155:1","sourceTokenDeploymentId":"deployment-0013","destinationTokenDeploymentId":"deployment-0011","sourceTokenAddress":"HzwqbKZw8HxMN6bF2yFZNrht3c2iXXzpKcFu7uBEDKtr","destinationTokenAddress":"0x1abaea1f7c830bd89acc67ec4af516284b1bc33c","sourceTokenStandard":"spl-token","destinationTokenStandard":"erc20","sourceTokenDecimals":6,"destinationTokenDecimals":6,"sourceProviderChainName":"solana","destinationProviderChainName":"ethereum","sourceProviderChainId":0,"destinationProviderChainId":1,"sourceWormholeChainId":1,"destinationWormholeChainId":2,"sourceUsdcDeploymentId":"deployment-0010","sourceUsdcAddress":"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v","sourceUsdcStandard":"spl-token","sourceUsdcDecimals":6,"swiftContract":"mayan34VedncxdK2XobtvWFDXQASUTBXhUVzt2kKgny","forwarderAddress":null,"forwarderFunctionSelector":null,"jupiterProgramAddress":"JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4","builderEndpoint":"https://tx-builder.mayan.finance","explorerEndpoint":"https://explorer-api.mayan.finance/v3","dependencies":["mayan-hosted-quote-api","mayan-hosted-transaction-builder","mayan-hosted-source-swap-builder","swift-auction-solvers","relayers","wormhole-guardian-messaging","mayan-explorer-indexer","jupiter-v6-source-swap"],"status":"active"}]'.freeze
+  BRIDGE_CAPABILITIES_CONTENT_DIGEST = 'fe698f99218057f8cb40b3e24421d1d78e4e2cd7508cf6e3eb2457b329e5141b'.freeze
+  BRIDGE_CAPABILITIES_AS_OF_DATE = '2026-09-16'.freeze
+end

data/lib/erpc_sdk/generated/swap_execution_capabilities.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Generated by registry/generate-swap-execution-capabilities.mjs. Do not edit.
+
+module ERPC
+  SWAP_EXECUTION_CAPABILITIES_JSON = '[{"swapExecutionCapabilityId":"swap-execution-0001","chainId":"eip155:1","dexDeploymentId":"dex-deployment-0001","poolDefinitionId":"pool-0001","factoryAddress":"0x5c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f","routerAddress":"0x7a250d5630b4cf539739df2c5dacb4c659f2488d","routerKind":"uniswap-v2-router02","adapterKind":"evm-constant-product-v2","token0DeploymentId":"deployment-0008","token0Address":"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48","token0Standard":"erc20","token1DeploymentId":"deployment-0002","token1Address":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2","token1Standard":"erc20","wrappedNativeTokenDeploymentId":"deployment-0002","wrappedNativeTokenAddress":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2","wrappedNativeFunctionSelector":"0xad5c4648","functionKind":"exact-input-erc20-to-erc20","functionSignature":"swapExactTokensForTokens(uint256,uint256,address[],address,uint256)","functionSelector":"0x38ed1739","status":"active"},{"swapExecutionCapabilityId":"swap-execution-0002","chainId":"eip155:43114","dexDeploymentId":"dex-deployment-0002","poolDefinitionId":"pool-0002","factoryAddress":"0x9ad6c38be94206ca50bb0d90783181662f0cfa10","routerAddress":"0x60ae616a2155ee3d9a68541ba4544862310933d4","routerKind":"joe-v1-router02","adapterKind":"evm-constant-product-v2","token0DeploymentId":"deployment-0004","token0Address":"0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7","token0Standard":"erc20","token1DeploymentId":"deployment-0009","token1Address":"0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e","token1Standard":"erc20","wrappedNativeTokenDeploymentId":"deployment-0004","wrappedNativeTokenAddress":"0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7","wrappedNativeFunctionSelector":"0x73b295c2","functionKind":"exact-input-erc20-to-erc20","functionSignature":"swapExactTokensForTokens(uint256,uint256,address[],address,uint256)","functionSelector":"0x38ed1739","status":"active"}]'.freeze
+  SWAP_EXECUTION_CAPABILITIES_CONTENT_DIGEST = '84424dc48687e2cb1dd0c9a2446f820efd2c311e71ce5acacfeb6e882811875f'.freeze
+  SWAP_EXECUTION_CAPABILITIES_AS_OF_DATE = '2026-09-16'.freeze
+  SWAP_EXECUTION_FUNCTION_SIGNATURE = 'swapExactTokensForTokens(uint256,uint256,address[],address,uint256)'.freeze
+  SWAP_EXECUTION_FUNCTION_SELECTOR = '0x38ed1739'.freeze
+end