weft-sdk 0.25.0 → 0.32.5

data/lib/weft/facilitator/fee.rb

@@ -1,27 +1,35 @@
+require 'json'
+
+require_relative 'client'
+
 module Weft
   module Facilitator
     module Fee
-      DEFAULT_TTL = 300
+      DEFAULT_TTL_MS = 5 * 60 * 1000
 
       @cache = nil
 
       class << self
-        def get_fee_info(client: Client.new, ttl: DEFAULT_TTL)
+        def get_fee_info(client: Client.new, ttl: DEFAULT_TTL_MS)
           return @cache[:fee] if cache_valid?
 
           supported = client.supported
-          fee = supported['fee']
+          fee = supported['fee'] || supported[:fee]
           raise 'Fee information not found in /supported response' unless fee
 
           validate_fee!(fee)
+          normalized = {
+            'amount' => fee['amount'] || fee[:amount],
+            'asset' => fee['asset'] || fee[:asset],
+            'network' => fee['network'] || fee[:network]
+          }
 
           @cache = {
-            fee: fee,
-            fetched_at: Time.now.to_i,
+            fee: normalized,
+            fetched_at: now_ms,
             ttl: ttl
           }
-
-          fee
+          normalized
         end
 
         def invalidate_fee_cache
@@ -33,13 +41,20 @@ module Weft
         def cache_valid?
           return false unless @cache
 
-          Time.now.to_i - @cache[:fetched_at] < @cache[:ttl]
+          now_ms - @cache[:fetched_at] < @cache[:ttl]
+        end
+
+        def now_ms
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
         end
 
         def validate_fee!(fee)
-          raise 'Invalid fee structure: amount must be a string' unless fee['amount'].is_a?(String)
-          raise 'Invalid fee structure: asset must be a string' unless fee['asset'].is_a?(String)
-          raise 'Invalid fee structure: network must be a string' unless fee['network'].is_a?(String)
+          amount = fee['amount'] || fee[:amount]
+          asset = fee['asset'] || fee[:asset]
+          network = fee['network'] || fee[:network]
+          raise 'Invalid fee structure: amount must be a string' unless amount.is_a?(String)
+          raise 'Invalid fee structure: asset must be a string' unless asset.is_a?(String)
+          raise 'Invalid fee structure: network must be a string' unless network.is_a?(String)
         end
       end
     end

data/lib/weft/facilitator/handshake.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative '../generated/version'
+require_relative 'json_wire'
+require_relative 'product'
+
+module Weft
+  module Facilitator
+    WEFT_DECLARED_HEADER = 'X-Weft-Declared'
+    WEFT_API_KEY_HEADER = 'X-API-Key'
+    HEADER_SAFE = /\A[\x21-\x7e]+\z/
+    ADAPTER_NAME = 'rack'
+
+    module Handshake
+      module_function
+
+      def build_auth_headers(adapter, api_key, declaration)
+        declaration = stringify_declaration(declaration)
+        key = resolve_api_key(api_key)
+        supported = {
+          'User-Agent' => "weft-sdk-#{adapter}/#{sdk_version}"
+        }
+        supported['Authorization'] = "Bearer #{key}" unless key.nil?
+
+        declared = declared_identity_value(declaration)
+        supported[WEFT_DECLARED_HEADER] = declared unless declared.nil?
+
+        headers = { 'supported' => supported }
+        unless key.nil?
+          headers['settle'] = { WEFT_API_KEY_HEADER => key }
+          headers['verify'] = { WEFT_API_KEY_HEADER => key }
+        end
+        headers
+      end
+
+      def declared_identity_value(declaration)
+        declared = Product.sanitize_product_identity(declaration)
+        dimensions = Product.resolve_dimensions(declaration['dimensions'], Product.create_warn)
+        payload = {}
+        payload['name'] = declared['name'] if declared.key?('name')
+        payload['type'] = declared['type'] if declared.key?('type')
+        payload['tags'] = declared['tags'] if declared.key?('tags')
+        payload['icon_url'] = declared['iconUrl'] if declared.key?('iconUrl')
+        payload['dimensions'] = dimensions unless dimensions.nil?
+        return nil if payload.empty?
+
+        JsonWire.base64url_encode(JsonWire.generate(payload))
+      end
+
+      def resolve_api_key(api_key)
+        return nil if api_key.nil?
+        unless api_key.is_a?(String)
+          warn "[weft] ignoring apiKey: expected a string, got #{js_type(api_key)}"
+          return nil
+        end
+
+        trimmed = api_key.strip
+        if trimmed.empty?
+          warn '[weft] ignoring empty apiKey'
+          return nil
+        end
+        unless HEADER_SAFE.match?(trimmed)
+          warn '[weft] ignoring apiKey: it contains whitespace or non-printable ' \
+               'characters that cannot travel in an HTTP header'
+          return nil
+        end
+
+        trimmed
+      end
+
+      def stringify_declaration(declaration)
+        return {} unless declaration.is_a?(Hash)
+
+        declaration.each_with_object({}) do |(key, value), out|
+          out[key.to_s] = value
+        end
+      end
+
+      def sdk_version
+        defined?(SDK) ? SDK::VERSION : VERSION
+      end
+
+      def js_type(value)
+        case value
+        when Integer, Float then 'number'
+        when TrueClass, FalseClass then 'boolean'
+        else 'object'
+        end
+      end
+    end
+  end
+end

data/lib/weft/facilitator/json_wire.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'json'
+
+module Weft
+  module Facilitator
+    # JSON.stringify and the two base64 forms @x402/core puts on the wire.
+    module JsonWire
+      module_function
+
+      def generate(value)
+        return nil if circular?(value)
+
+        JSON.generate(sanitize(value))
+      rescue JSON::GeneratorError, JSON::NestingError
+        nil
+      end
+
+      def circular?(value, seen = {})
+        case value
+        when Hash, Array
+          return true if seen[value.object_id]
+
+          seen[value.object_id] = true
+          children = value.is_a?(Hash) ? value.values : value
+          children.any? { |item| circular?(item, seen) }
+        else
+          false
+        end
+      end
+
+      def sanitize(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, item), out|
+            out[key.is_a?(Symbol) ? key.to_s : key] = sanitize(item)
+          end
+        when Array
+          value.map { |item| sanitize(item) }
+        when Float
+          value.finite? ? value : nil
+        else
+          value
+        end
+      end
+
+      def base64_encode(text)
+        Base64.strict_encode64(text.b)
+      end
+
+      def base64_decode(text)
+        Base64.strict_decode64(text).force_encoding(Encoding::UTF_8)
+      end
+
+      def base64url_encode(text)
+        Base64.urlsafe_encode64(text.b, padding: false)
+      end
+
+      def base64url_decode(text)
+        padded = text.tr('-_', '+/')
+        padded += '=' * ((4 - (padded.length % 4)) % 4)
+        Base64.decode64(padded).force_encoding(Encoding::UTF_8)
+      end
+
+      def encode_json(value)
+        json = generate(value)
+        raise ArgumentError, 'value is not JSON' if json.nil?
+
+        base64_encode(json)
+      end
+    end
+  end
+end