x402.rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6d7c4bbda7de50fffc403636c6951b355f6b782a7d0d6332c0287f501aac2b23
+  data.tar.gz: fa12d2bc84fe3db789ee7db772d0a94a603f86752b61aeef455dc6db01456ca0
+SHA512:
+  metadata.gz: 2cbea85e5c81a576cd9911ffafa5af426ce921665a4e2b45dd4cb157ed69e81f81836d5aea970c3677c46aa5b9bac04a0bcef7a2786fdc88ce1c2c1220bba5bc
+  data.tar.gz: 21096796768eaa15b2f2e5bac1e6ed8e19d15c2f151c5a7979e9502ea4392f16c1df7575372450648600ce6bba534992d6ad8b2afaffa702e95aa62cc948467e

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Filippo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,148 @@
+# x402.rb
+
+Ruby gem for the [x402 protocol](https://docs.x402.org) — HTTP 402-based on-chain payments for APIs and services.
+
+## Installation
+
+```ruby
+gem "x402.rb"
+```
+
+## Components
+
+### Facilitator Client
+
+Interact with an x402 facilitator to verify and settle payments:
+
+```ruby
+require "x402"
+
+facilitator = X402::Facilitator.new
+# or: X402::Facilitator.new(base_url: "https://api.cdp.coinbase.com/platform/v2/x402")
+
+# Check what's supported
+facilitator.supported
+
+# Verify a payment
+result = facilitator.verify(
+  payment_payload: payload,
+  payment_requirements: requirements
+)
+result.valid?      # => true
+result.payer       # => "0x..."
+
+# Settle a payment
+settlement = facilitator.settle(
+  payment_payload: payload,
+  payment_requirements: requirements
+)
+settlement.success?    # => true
+settlement.transaction # => "0xabc..."
+```
+
+### Server Middleware (Rack)
+
+Gate routes behind x402 payments. Works with Rails, Sinatra, and any Rack app:
+
+```ruby
+# config/application.rb (Rails)
+config.middleware.use X402::Server::Middleware, routes: {
+  "GET /api/premium" => {
+    accepts: [{
+      scheme: "exact",
+      network: "eip155:84532",
+      amount: "10000",               # atomic units (USDC has 6 decimals)
+      asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+      pay_to: "0xYourWalletAddress",
+      max_timeout_seconds: 60,
+      extra: { "name" => "USDC", "version" => "2" }
+    }],
+    description: "Premium market data",
+    mime_type: "application/json"
+  }
+}
+```
+
+```ruby
+# Sinatra
+use X402::Server::Middleware, routes: { ... }
+```
+
+The middleware:
+1. Returns `402` with a `PAYMENT-REQUIRED` header for gated routes without payment
+2. Verifies payment via the facilitator when a `PAYMENT-SIGNATURE` header is present
+3. Settles the payment after the downstream app responds successfully
+4. Returns the `PAYMENT-RESPONSE` header with settlement details
+
+### Client Middleware (Faraday)
+
+Automatically handle 402 responses by signing and retrying:
+
+```ruby
+require "faraday"
+require "x402"
+require "x402/client/middleware"
+
+conn = Faraday.new("https://api.example.com") do |f|
+  f.use X402::Client::Middleware, signer: my_signer
+  f.adapter Faraday.default_adapter
+end
+
+# Transparently pays for 402-gated resources
+response = conn.get("/api/premium")
+response.body # => the paid content
+```
+
+The `signer` must implement `#sign(payment_required)` and return an `X402::Types::PaymentPayload` (or `nil` to skip payment). This is where you integrate your wallet/key management.
+
+### Configuration
+
+```ruby
+X402.configure do |c|
+  c.facilitator_url = "https://x402.org/facilitator"  # default (testnet)
+  c.x402_version = 2                                   # default
+end
+```
+
+## Protocol Flow
+
+```
+Client                          Server                      Facilitator
+  |                               |                             |
+  |  GET /premium                 |                             |
+  |------------------------------>|                             |
+  |                               |                             |
+  |  402 + PAYMENT-REQUIRED       |                             |
+  |<------------------------------|                             |
+  |                               |                             |
+  |  GET /premium                 |                             |
+  |  + PAYMENT-SIGNATURE          |                             |
+  |------------------------------>|                             |
+  |                               |  POST /verify               |
+  |                               |---------------------------->|
+  |                               |  { isValid: true }          |
+  |                               |<----------------------------|
+  |                               |                             |
+  |                               |  POST /settle               |
+  |                               |---------------------------->|
+  |                               |  { success, transaction }   |
+  |                               |<----------------------------|
+  |                               |                             |
+  |  200 + PAYMENT-RESPONSE       |                             |
+  |<------------------------------|                             |
+```
+
+## Types
+
+- `X402::Types::PaymentRequired` — server's 402 response with accepted payment options
+- `X402::Types::PaymentRequirements` — a single payment option (scheme, network, amount, asset, payTo)
+- `X402::Types::PaymentPayload` — client's signed payment authorization
+- `X402::Types::SettlementResponse` — settlement result with transaction hash
+- `X402::Types::VerifyResponse` — verification result from facilitator
+- `X402::Types::ResourceInfo` — URL, description, and MIME type of the resource
+
+All types support `#to_h`, `.from_h(hash)`, `#encode` (Base64 JSON), and `.decode(string)`.
+
+## License
+
+MIT

data/lib/x402/client/middleware.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module X402
+  module Client
+    # Faraday middleware that automatically handles x402 payment flows.
+    #
+    # Usage:
+    #   conn = Faraday.new("https://api.example.com") do |f|
+    #     f.use X402::Client::Middleware, signer: my_signer
+    #   end
+    #
+    # The signer must respond to #sign(payment_requirements, resource) and return
+    # a PaymentPayload (or a Hash with the same structure).
+    #
+    class Middleware < Faraday::Middleware
+      def initialize(app, signer:)
+        super(app)
+        @signer = signer
+      end
+
+      def call(env)
+        response = @app.call(env)
+
+        return response unless response.status == 402
+
+        # Parse the payment requirements
+        encoded = response.headers[Header::PAYMENT_REQUIRED] ||
+          response.headers[Header::PAYMENT_REQUIRED.downcase]
+
+        return response unless encoded
+
+        payment_required = Types::PaymentRequired.decode(encoded)
+
+        # Let the signer pick a payment option and produce a signed payload
+        payment_payload = @signer.sign(payment_required)
+        return response unless payment_payload
+
+        payment_payload = if payment_payload.is_a?(Types::PaymentPayload)
+          payment_payload
+        else
+          Types::PaymentPayload.new(**payment_payload)
+        end
+
+        # Retry the request with the payment header
+        env.request_headers[Header::PAYMENT_SIGNATURE] = payment_payload.encode
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/x402/configuration.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module X402
+  class Configuration
+    attr_accessor :facilitator_url, :x402_version
+
+    TESTNET_FACILITATOR = "https://x402.org/facilitator"
+    PRODUCTION_FACILITATOR = "https://api.cdp.coinbase.com/platform/v2/x402"
+
+    def initialize
+      @facilitator_url = TESTNET_FACILITATOR
+      @x402_version = 2
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/x402/facilitator.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module X402
+  class Facilitator
+    attr_reader :base_url
+
+    def initialize(base_url: nil)
+      @base_url = base_url || X402.configuration.facilitator_url
+    end
+
+    # Verify a payment authorization without executing it.
+    #
+    # @param payment_payload [PaymentPayload, Hash] the client's payment payload
+    # @param payment_requirements [PaymentRequirements, Hash] the requirements to verify against
+    # @return [Types::VerifyResponse]
+    def verify(payment_payload:, payment_requirements:)
+      body = {
+        x402Version: X402.configuration.x402_version,
+        paymentPayload: normalize(payment_payload),
+        paymentRequirements: normalize(payment_requirements)
+      }
+
+      response = post("/verify", body)
+      Types::VerifyResponse.from_h(response)
+    end
+
+    # Settle (execute) a verified payment on-chain.
+    #
+    # @param payment_payload [PaymentPayload, Hash] the client's payment payload
+    # @param payment_requirements [PaymentRequirements, Hash] the requirements that were accepted
+    # @return [Types::SettlementResponse]
+    def settle(payment_payload:, payment_requirements:)
+      body = {
+        x402Version: X402.configuration.x402_version,
+        paymentPayload: normalize(payment_payload),
+        paymentRequirements: normalize(payment_requirements)
+      }
+
+      response = post("/settle", body)
+      Types::SettlementResponse.from_h(response)
+    end
+
+    # Get supported schemes, networks, and extensions.
+    #
+    # @return [Hash]
+    def supported
+      get("/supported")
+    end
+
+    private
+
+    def normalize(obj)
+      obj.respond_to?(:to_h) ? obj.to_h : obj
+    end
+
+    def post(path, body)
+      uri = URI.parse("#{base_url.chomp("/")}#{path}")
+      request = Net::HTTP::Post.new(uri)
+      request["Content-Type"] = "application/json"
+      request.body = JSON.generate(body)
+
+      execute(uri, request)
+    end
+
+    def get(path)
+      uri = URI.parse("#{base_url.chomp("/")}#{path}")
+      request = Net::HTTP::Get.new(uri)
+      request["Accept"] = "application/json"
+
+      execute(uri, request)
+    end
+
+    def execute(uri, request)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+
+      response = http.request(request)
+
+      unless response.is_a?(Net::HTTPSuccess)
+        raise FacilitatorError, "Facilitator returned #{response.code}: #{response.body}"
+      end
+
+      JSON.parse(response.body)
+    rescue JSON::ParserError => e
+      raise FacilitatorError, "Invalid JSON from facilitator: #{e.message}"
+    end
+  end
+
+  class FacilitatorError < StandardError; end
+end

data/lib/x402/header.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+
+module X402
+  module Header
+    PAYMENT_REQUIRED  = "PAYMENT-REQUIRED"
+    PAYMENT_SIGNATURE = "PAYMENT-SIGNATURE"
+    PAYMENT_RESPONSE  = "PAYMENT-RESPONSE"
+
+    # Rack normalizes headers to HTTP_UPPER_SNAKE format
+    RACK_PAYMENT_REQUIRED  = "HTTP_PAYMENT_REQUIRED"
+    RACK_PAYMENT_SIGNATURE = "HTTP_PAYMENT_SIGNATURE"
+    RACK_PAYMENT_RESPONSE  = "HTTP_PAYMENT_RESPONSE"
+
+    class << self
+      def encode(data)
+        json = data.is_a?(String) ? data : JSON.generate(data)
+        Base64.strict_encode64(json)
+      end
+
+      def decode(value)
+        JSON.parse(Base64.strict_decode64(value))
+      rescue ArgumentError, JSON::ParserError => e
+        raise DecodeError, "Failed to decode x402 header: #{e.message}"
+      end
+    end
+  end
+
+  class DecodeError < StandardError; end
+end

data/lib/x402/server/middleware.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module X402
+  module Server
+    # Rack middleware that gates routes behind x402 payments.
+    #
+    # Usage:
+    #   use X402::Server::Middleware, routes: {
+    #     "GET /premium" => {
+    #       accepts: [{
+    #         scheme: "exact",
+    #         network: "eip155:84532",
+    #         amount: "10000",
+    #         asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    #         pay_to: "0xYourAddress",
+    #         max_timeout_seconds: 60,
+    #         extra: { name: "USDC", version: "2" }
+    #       }],
+    #       description: "Premium content",
+    #       mime_type: "application/json"
+    #     }
+    #   }
+    #
+    class Middleware
+      def initialize(app, routes:, facilitator: nil)
+        @app = app
+        @routes = normalize_routes(routes)
+        @facilitator = facilitator || X402::Facilitator.new
+      end
+
+      def call(env)
+        route_key = "#{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
+        route_config = @routes[route_key]
+
+        # Not a gated route — pass through
+        return @app.call(env) unless route_config
+
+        payment_header = env[Header::RACK_PAYMENT_SIGNATURE]
+
+        # No payment provided — return 402
+        unless payment_header
+          return payment_required_response(env, route_config)
+        end
+
+        # Decode and verify payment
+        payment_payload = Types::PaymentPayload.decode(payment_header)
+        accepted = payment_payload.accepted
+
+        # Find matching requirements
+        matching = route_config[:accepts].find do |req|
+          req.scheme == accepted.scheme && req.network == accepted.network
+        end
+
+        unless matching
+          return payment_required_response(env, route_config,
+            error: "No matching payment scheme/network")
+        end
+
+        # Verify via facilitator
+        verify_result = @facilitator.verify(
+          payment_payload: payment_payload,
+          payment_requirements: matching
+        )
+
+        unless verify_result.valid?
+          return payment_required_response(env, route_config,
+            error: "Payment verification failed: #{verify_result.invalid_reason}")
+        end
+
+        # Call the downstream app
+        status, headers, body = @app.call(env)
+
+        # Settle the payment
+        settlement = @facilitator.settle(
+          payment_payload: payment_payload,
+          payment_requirements: matching
+        )
+
+        headers[Header::PAYMENT_RESPONSE] = settlement.encode
+
+        if settlement.success?
+          [status, headers, body]
+        else
+          payment_required_response(env, route_config,
+            error: "Settlement failed: #{settlement.error_reason}")
+        end
+      rescue DecodeError => e
+        [400, {"content-type" => "application/json"},
+          [JSON.generate({error: e.message})]]
+      rescue FacilitatorError => e
+        [500, {"content-type" => "application/json"},
+          [JSON.generate({error: e.message})]]
+      end
+
+      private
+
+      def payment_required_response(env, route_config, error: nil)
+        payment_required = Types::PaymentRequired.new(
+          resource: {
+            url: "#{env["rack.url_scheme"]}://#{env["HTTP_HOST"]}#{env["PATH_INFO"]}",
+            description: route_config[:description],
+            mime_type: route_config[:mime_type]
+          },
+          accepts: route_config[:accepts],
+          error: error || "#{Header::PAYMENT_SIGNATURE} header is required"
+        )
+
+        headers = {
+          "content-type" => "application/json",
+          Header::PAYMENT_REQUIRED => payment_required.encode
+        }
+
+        [402, headers, [JSON.generate(payment_required.to_h)]]
+      end
+
+      def normalize_routes(routes)
+        routes.transform_values do |config|
+          config = config.dup
+          config[:accepts] = config[:accepts].map do |a|
+            a.is_a?(Types::PaymentRequirements) ? a : Types::PaymentRequirements.new(**a)
+          end
+          config
+        end
+      end
+    end
+  end
+end

data/lib/x402/types/payment_payload.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module X402
+  module Types
+    class PaymentPayload
+      attr_accessor :x402_version, :resource, :accepted, :payload, :extensions
+
+      def initialize(accepted:, payload:, resource: nil, x402_version: nil, extensions: nil)
+        @x402_version = x402_version || X402.configuration.x402_version
+        @resource = if resource.is_a?(Hash)
+          ResourceInfo.new(**resource)
+        else
+          resource
+        end
+        @accepted = if accepted.is_a?(Hash)
+          PaymentRequirements.new(**accepted)
+        else
+          accepted
+        end
+        @payload = payload
+        @extensions = extensions
+      end
+
+      def to_h
+        h = {
+          x402Version: x402_version,
+          accepted: accepted.to_h,
+          payload: payload
+        }
+        h[:resource] = resource.to_h if resource
+        h[:extensions] = extensions if extensions
+        h
+      end
+
+      def encode
+        Header.encode(to_h)
+      end
+
+      def self.from_h(hash)
+        new(
+          x402_version: hash["x402Version"],
+          resource: ResourceInfo.from_h(hash["resource"]),
+          accepted: PaymentRequirements.from_h(hash["accepted"]),
+          payload: hash["payload"],
+          extensions: hash["extensions"]
+        )
+      end
+
+      def self.decode(encoded_string)
+        from_h(Header.decode(encoded_string))
+      end
+    end
+  end
+end

data/lib/x402/types/payment_required.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module X402
+  module Types
+    class PaymentRequired
+      attr_accessor :x402_version, :error, :resource, :accepts, :extensions
+
+      def initialize(resource:, accepts:, error: nil, x402_version: nil, extensions: nil)
+        @x402_version = x402_version || X402.configuration.x402_version
+        @error = error
+        @resource = resource.is_a?(ResourceInfo) ? resource : ResourceInfo.new(**resource)
+        @accepts = accepts.map do |a|
+          a.is_a?(PaymentRequirements) ? a : PaymentRequirements.new(**a)
+        end
+        @extensions = extensions
+      end
+
+      def to_h
+        h = {
+          x402Version: x402_version,
+          resource: resource.to_h,
+          accepts: accepts.map(&:to_h)
+        }
+        h[:error] = error if error
+        h[:extensions] = extensions if extensions
+        h
+      end
+
+      def encode
+        Header.encode(to_h)
+      end
+
+      def self.from_h(hash)
+        new(
+          x402_version: hash["x402Version"],
+          error: hash["error"],
+          resource: ResourceInfo.from_h(hash["resource"]),
+          accepts: (hash["accepts"] || []).map { |a| PaymentRequirements.from_h(a) },
+          extensions: hash["extensions"]
+        )
+      end
+
+      def self.decode(encoded_string)
+        from_h(Header.decode(encoded_string))
+      end
+    end
+  end
+end

data/lib/x402/types/payment_requirements.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module X402
+  module Types
+    class PaymentRequirements
+      attr_accessor :scheme, :network, :amount, :asset, :pay_to,
+        :max_timeout_seconds, :extra
+
+      def initialize(scheme:, network:, amount:, asset:, pay_to:,
+        max_timeout_seconds: 60, extra: nil)
+        @scheme = scheme
+        @network = network
+        @amount = amount.to_s
+        @asset = asset
+        @pay_to = pay_to
+        @max_timeout_seconds = max_timeout_seconds
+        @extra = extra
+      end
+
+      def to_h
+        h = {
+          scheme: scheme,
+          network: network,
+          amount: amount,
+          asset: asset,
+          payTo: pay_to,
+          maxTimeoutSeconds: max_timeout_seconds
+        }
+        h[:extra] = extra if extra
+        h
+      end
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        new(
+          scheme: hash["scheme"],
+          network: hash["network"],
+          amount: hash["amount"],
+          asset: hash["asset"],
+          pay_to: hash["payTo"],
+          max_timeout_seconds: hash["maxTimeoutSeconds"] || 60,
+          extra: hash["extra"]
+        )
+      end
+    end
+  end
+end

data/lib/x402/types/resource_info.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module X402
+  module Types
+    class ResourceInfo
+      attr_accessor :url, :description, :mime_type
+
+      def initialize(url:, description: nil, mime_type: nil)
+        @url = url
+        @description = description
+        @mime_type = mime_type
+      end
+
+      def to_h
+        h = {url: url}
+        h[:description] = description if description
+        h[:mimeType] = mime_type if mime_type
+        h
+      end
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        new(
+          url: hash["url"],
+          description: hash["description"],
+          mime_type: hash["mimeType"]
+        )
+      end
+    end
+  end
+end

data/lib/x402/types/settlement_response.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module X402
+  module Types
+    class SettlementResponse
+      attr_accessor :success, :error_reason, :payer, :transaction,
+        :network, :amount, :extensions
+
+      def initialize(success:, transaction:, network:, payer: nil,
+        error_reason: nil, amount: nil, extensions: nil)
+        @success = success
+        @transaction = transaction
+        @network = network
+        @payer = payer
+        @error_reason = error_reason
+        @amount = amount
+        @extensions = extensions
+      end
+
+      def success?
+        success
+      end
+
+      def to_h
+        h = {
+          success: success,
+          transaction: transaction,
+          network: network
+        }
+        h[:errorReason] = error_reason if error_reason
+        h[:payer] = payer if payer
+        h[:amount] = amount if amount
+        h[:extensions] = extensions if extensions
+        h
+      end
+
+      def encode
+        Header.encode(to_h)
+      end
+
+      def self.from_h(hash)
+        new(
+          success: hash["success"],
+          transaction: hash["transaction"],
+          network: hash["network"],
+          payer: hash["payer"],
+          error_reason: hash["errorReason"],
+          amount: hash["amount"],
+          extensions: hash["extensions"]
+        )
+      end
+
+      def self.decode(encoded_string)
+        from_h(Header.decode(encoded_string))
+      end
+    end
+  end
+end

data/lib/x402/types/verify_response.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module X402
+  module Types
+    class VerifyResponse
+      attr_accessor :valid, :invalid_reason, :payer
+
+      def initialize(valid:, invalid_reason: nil, payer: nil)
+        @valid = valid
+        @invalid_reason = invalid_reason
+        @payer = payer
+      end
+
+      def valid?
+        valid
+      end
+
+      def self.from_h(hash)
+        new(
+          valid: hash["isValid"],
+          invalid_reason: hash["invalidReason"],
+          payer: hash["payer"]
+        )
+      end
+    end
+  end
+end

data/lib/x402/version.rb

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

data/lib/x402.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "x402/version"
+require_relative "x402/configuration"
+require_relative "x402/header"
+require_relative "x402/types/resource_info"
+require_relative "x402/types/payment_requirements"
+require_relative "x402/types/payment_required"
+require_relative "x402/types/payment_payload"
+require_relative "x402/types/settlement_response"
+require_relative "x402/types/verify_response"
+require_relative "x402/facilitator"
+require_relative "x402/server/middleware"
+require_relative "x402/client/middleware" if defined?(Faraday)

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: x402.rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Filippo
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Enables HTTP 402-based on-chain payments for APIs and services using
+  the x402 open standard. Includes Rack server middleware, Faraday client middleware,
+  and a facilitator API client.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/x402.rb
+- lib/x402/client/middleware.rb
+- lib/x402/configuration.rb
+- lib/x402/facilitator.rb
+- lib/x402/header.rb
+- lib/x402/server/middleware.rb
+- lib/x402/types/payment_payload.rb
+- lib/x402/types/payment_required.rb
+- lib/x402/types/payment_requirements.rb
+- lib/x402/types/resource_info.rb
+- lib/x402/types/settlement_response.rb
+- lib/x402/types/verify_response.rb
+- lib/x402/version.rb
+homepage: https://github.com/filippo/x402.rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/filippo/x402.rb
+  source_code_uri: https://github.com/filippo/x402.rb
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.8
+specification_version: 4
+summary: Ruby implementation of the x402 payment protocol
+test_files: []