remitmd 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77a3a0333d3f1afc8315ad1d523bc9adb70e74d2f5af29bc20b608233b0f67b1
-  data.tar.gz: b04b273b6340c25f8adcc5e755e99a4f32c9e804aec91d2e28058a66f507e9e9
+  metadata.gz: b29ac02ca95fe1053bed848cca89111698f1744bbeb145681a76a3f9ed2d8e66
+  data.tar.gz: d55c4f33eaaa686fa0036e3a0566ee6382a0a544c01093a3d9887e745b2eaa01
 SHA512:
-  metadata.gz: 3e343856eb6688f7a5bee1a10fa85ae119e9ac548eeedfb4bb95a21f4a5565d8ad4921efccfcad940f3f8a89fb7a0fd313243c7dd511f132c0540b69e05b2f82
-  data.tar.gz: 284848e90b0c9c53bc80a07fa7a2bc90ea7f3e1afef282b10308a9fc5805b9c750392d75a6055bf152660d15a1b3948d06fddbf179f5daf2ae3b586f0e18a35a
+  metadata.gz: 9c00d48fc571e6975d9dfd32c679d5b9cf46205742a8a725022907eb997d42de7a61ae040c22dfafb7d5a994277d25f5dafd2e589611e849f94a70c692d71102
+  data.tar.gz: dff3c27cf317ce994999efd38d57f1173f0a1136da0bf4dbcdbf1ff5879a9f737bef96875802108ca130b4e46b3b94eec1cc0f52cace3152c89357018d9f9621

data/lib/remitmd/a2a.rb

@@ -4,7 +4,7 @@ require "net/http"
 require "json"
 require "uri"
 
-module RemitMd
+module Remitmd
   # A2A capability extension declared in an agent card.
   AgentExtension = Data.define(:uri, :description, :required)
 
@@ -37,7 +37,7 @@ module RemitMd
 
     # Fetch and parse the A2A agent card from +base_url/.well-known/agent-card.json+.
     #
-    #   card = RemitMd::AgentCard.discover("https://remit.md")
+    #   card = Remitmd::AgentCard.discover("https://remit.md")
     #   puts card.name   # => "remit.md"
     #   puts card.url    # => "https://remit.md/a2a"
     #
@@ -55,4 +55,190 @@ module RemitMd
       new(JSON.parse(response.body))
     end
   end
+
+  # ─── A2A task types ──────────────────────────────────────────────────────────
+
+  # Status of an A2A task.
+  class A2ATaskStatus
+    attr_reader :state, :message
+
+    def initialize(data)
+      @state   = data["state"].to_s
+      @message = data["message"]
+    end
+  end
+
+  # An artifact part within an A2A artifact.
+  A2AArtifactPart = Data.define(:kind, :data)
+
+  # An artifact returned by an A2A task.
+  class A2AArtifact
+    attr_reader :name, :parts
+
+    def initialize(data)
+      @name  = data["name"]
+      @parts = (data["parts"] || []).map do |p|
+        A2AArtifactPart.new(kind: p["kind"].to_s, data: p["data"] || {})
+      end
+    end
+  end
+
+  # An A2A task returned by message/send, tasks/get, or tasks/cancel.
+  class A2ATask
+    attr_reader :id, :status, :artifacts
+
+    def initialize(data)
+      @id        = data["id"].to_s
+      @status    = A2ATaskStatus.new(data["status"] || {})
+      @artifacts = (data["artifacts"] || []).map { |a| A2AArtifact.new(a) }
+    end
+
+    # Extract txHash from task artifacts, if present.
+    # @return [String, nil]
+    def tx_hash
+      artifacts.each do |artifact|
+        artifact.parts.each do |part|
+          tx = part.data["txHash"] if part.data.is_a?(Hash)
+          return tx if tx.is_a?(String)
+        end
+      end
+      nil
+    end
+  end
+
+  # ─── IntentMandate ──────────────────────────────────────────────────────────
+
+  # A mandate authorizing a payment intent.
+  class IntentMandate
+    attr_reader :mandate_id, :expires_at, :issuer, :max_amount, :currency
+
+    def initialize(mandate_id:, expires_at:, issuer:, max_amount:, currency: "USDC")
+      @mandate_id = mandate_id
+      @expires_at = expires_at
+      @issuer     = issuer
+      @max_amount = max_amount
+      @currency   = currency
+    end
+
+    def to_h
+      {
+        mandateId: @mandate_id,
+        expiresAt: @expires_at,
+        issuer:    @issuer,
+        allowance: {
+          maxAmount: @max_amount,
+          currency:  @currency,
+        },
+      }
+    end
+  end
+
+  # ─── A2A JSON-RPC client ────────────────────────────────────────────────────
+
+  # A2A JSON-RPC client — send payments and manage tasks via the A2A protocol.
+  #
+  # @example
+  #   card   = Remitmd::AgentCard.discover("https://remit.md")
+  #   signer = Remitmd::PrivateKeySigner.new(ENV["REMITMD_KEY"])
+  #   client = Remitmd::A2AClient.from_card(card, signer)
+  #   task   = client.send(to: "0xRecipient...", amount: 10)
+  #   puts task.status.state
+  #
+  class A2AClient
+    CHAIN_IDS = {
+      "base"         => 8453,
+      "base-sepolia" => 84_532,
+    }.freeze
+
+    # @param endpoint [String] full A2A endpoint URL from the agent card
+    # @param signer [#sign, #address] a signer for EIP-712 authentication
+    # @param chain_id [Integer] chain ID
+    # @param verifying_contract [String] verifying contract address
+    def initialize(endpoint:, signer:, chain_id:, verifying_contract: "")
+      parsed    = URI(endpoint)
+      @base_url = "#{parsed.scheme}://#{parsed.host}#{parsed.port == parsed.default_port ? "" : ":#{parsed.port}"}"
+      @path     = parsed.path.empty? ? "/a2a" : parsed.path
+      @transport = HttpTransport.new(
+        base_url:       @base_url,
+        signer:         signer,
+        chain_id:       chain_id,
+        router_address: verifying_contract
+      )
+    end
+
+    # Convenience constructor from an AgentCard and a signer.
+    # @param card [AgentCard]
+    # @param signer [#sign, #address]
+    # @param chain [String] chain name (default: "base")
+    # @param verifying_contract [String]
+    # @return [A2AClient]
+    def self.from_card(card, signer, chain: "base", verifying_contract: "")
+      chain_id = CHAIN_IDS[chain] || CHAIN_IDS["base"]
+      new(
+        endpoint:            card.url,
+        signer:              signer,
+        chain_id:            chain_id,
+        verifying_contract:  verifying_contract
+      )
+    end
+
+    # Send a direct USDC payment via message/send.
+    # @param to [String] recipient 0x address
+    # @param amount [Numeric] amount in USDC
+    # @param memo [String] optional memo
+    # @param mandate [IntentMandate, nil] optional intent mandate
+    # @return [A2ATask]
+    def send(to:, amount:, memo: "", mandate: nil)
+      nonce      = SecureRandom.hex(16)
+      message_id = SecureRandom.hex(16)
+
+      message = {
+        messageId: message_id,
+        role:      "user",
+        parts: [
+          {
+            kind: "data",
+            data: {
+              model:  "direct",
+              to:     to,
+              amount: format("%.2f", amount),
+              memo:   memo,
+              nonce:  nonce,
+            },
+          },
+        ],
+      }
+
+      message[:metadata] = { mandate: mandate.to_h } if mandate
+
+      rpc("message/send", { message: message }, message_id)
+    end
+
+    # Fetch the current state of an A2A task by ID.
+    # @param task_id [String]
+    # @return [A2ATask]
+    def get_task(task_id)
+      rpc("tasks/get", { id: task_id }, task_id[0, 16])
+    end
+
+    # Cancel an in-progress A2A task.
+    # @param task_id [String]
+    # @return [A2ATask]
+    def cancel_task(task_id)
+      rpc("tasks/cancel", { id: task_id }, task_id[0, 16])
+    end
+
+    private
+
+    def rpc(method, params, call_id)
+      body = { jsonrpc: "2.0", id: call_id, method: method, params: params }
+      data = @transport.post(@path, body)
+      if data.is_a?(Hash) && data["error"]
+        err_msg = data["error"]["message"] || JSON.generate(data["error"])
+        raise RemitError.new("SERVER_ERROR", "A2A error: #{err_msg}")
+      end
+      result = data.is_a?(Hash) ? (data["result"] || data) : data
+      A2ATask.new(result)
+    end
+  end
 end

data/lib/remitmd/errors.rb

@@ -15,29 +15,64 @@ module Remitmd
   #     puts e.doc_url  # => "https://remit.md/docs/api-reference/error-codes#invalid_address"
   #   end
   class RemitError < StandardError
-    # Error code constants
-    INVALID_ADDRESS         = "INVALID_ADDRESS"
-    INVALID_AMOUNT          = "INVALID_AMOUNT"
-    INSUFFICIENT_FUNDS      = "INSUFFICIENT_FUNDS"
+    # Error code constants — matches TS SDK (28 codes)
+    # Auth errors
+    INVALID_SIGNATURE       = "INVALID_SIGNATURE"
+    NONCE_REUSED            = "NONCE_REUSED"
+    TIMESTAMP_EXPIRED       = "TIMESTAMP_EXPIRED"
+    UNAUTHORIZED            = "UNAUTHORIZED"
+
+    # Balance / funds
+    INSUFFICIENT_BALANCE    = "INSUFFICIENT_BALANCE"
+    BELOW_MINIMUM           = "BELOW_MINIMUM"
+
+    # Escrow errors
     ESCROW_NOT_FOUND        = "ESCROW_NOT_FOUND"
+    ESCROW_ALREADY_FUNDED   = "ESCROW_ALREADY_FUNDED"
+    ESCROW_EXPIRED          = "ESCROW_EXPIRED"
+
+    # Invoice errors
+    INVALID_INVOICE         = "INVALID_INVOICE"
+    DUPLICATE_INVOICE       = "DUPLICATE_INVOICE"
+    SELF_PAYMENT            = "SELF_PAYMENT"
+    INVALID_PAYMENT_TYPE    = "INVALID_PAYMENT_TYPE"
+
+    # Tab errors
+    TAB_DEPLETED            = "TAB_DEPLETED"
+    TAB_EXPIRED             = "TAB_EXPIRED"
     TAB_NOT_FOUND           = "TAB_NOT_FOUND"
+
+    # Stream errors
     STREAM_NOT_FOUND        = "STREAM_NOT_FOUND"
+    RATE_EXCEEDS_CAP        = "RATE_EXCEEDS_CAP"
+
+    # Bounty errors
+    BOUNTY_EXPIRED          = "BOUNTY_EXPIRED"
+    BOUNTY_CLAIMED          = "BOUNTY_CLAIMED"
+    BOUNTY_MAX_ATTEMPTS     = "BOUNTY_MAX_ATTEMPTS"
     BOUNTY_NOT_FOUND        = "BOUNTY_NOT_FOUND"
-    DEPOSIT_NOT_FOUND       = "DEPOSIT_NOT_FOUND"
-    UNAUTHORIZED            = "UNAUTHORIZED"
-    RATE_LIMITED            = "RATE_LIMITED"
+
+    # Chain errors
+    CHAIN_MISMATCH          = "CHAIN_MISMATCH"
+    CHAIN_UNSUPPORTED       = "CHAIN_UNSUPPORTED"
+
+    # Rate limiting
+    RATE_LIMITED             = "RATE_LIMITED"
+
+    # Cancellation errors
+    CANCEL_BLOCKED_CLAIM_START = "CANCEL_BLOCKED_CLAIM_START"
+    CANCEL_BLOCKED_EVIDENCE    = "CANCEL_BLOCKED_EVIDENCE"
+
+    # Protocol errors
+    VERSION_MISMATCH        = "VERSION_MISMATCH"
     NETWORK_ERROR           = "NETWORK_ERROR"
+
+    # Legacy aliases (kept for backward compat within the SDK)
+    INVALID_ADDRESS         = "INVALID_ADDRESS"
+    INVALID_AMOUNT          = "INVALID_AMOUNT"
+    INSUFFICIENT_FUNDS      = INSUFFICIENT_BALANCE
     SERVER_ERROR            = "SERVER_ERROR"
-    NONCE_REUSED            = "NONCE_REUSED"
-    SIGNATURE_INVALID       = "SIGNATURE_INVALID"
-    ESCROW_ALREADY_COMPLETED = "ESCROW_ALREADY_COMPLETED"
-    ESCROW_EXPIRED          = "ESCROW_EXPIRED"
-    TAB_LIMIT_EXCEEDED      = "TAB_LIMIT_EXCEEDED"
-    BOUNTY_ALREADY_AWARDED  = "BOUNTY_ALREADY_AWARDED"
-    STREAM_NOT_ACTIVE       = "STREAM_NOT_ACTIVE"
-    DEPOSIT_ALREADY_RESOLVED = "DEPOSIT_ALREADY_RESOLVED"
-    USDC_TRANSFER_FAILED    = "USDC_TRANSFER_FAILED"
-    CHAIN_UNAVAILABLE       = "CHAIN_UNAVAILABLE"
+    DEPOSIT_NOT_FOUND       = "DEPOSIT_NOT_FOUND"
 
     attr_reader :code, :doc_url, :context
 

data/lib/remitmd/http.rb

@@ -43,7 +43,7 @@ module Remitmd
     def request(method, path, body)
       attempt = 0
       # Generate idempotency key once per request (stable across retries).
-      idempotency_key = (method == :post || method == :put || method == :patch) ? SecureRandom.uuid : nil
+      idempotency_key = %i[post put patch].include?(method) ? SecureRandom.uuid : nil
       begin
         attempt += 1
         req  = build_request(method, path, body, idempotency_key)
@@ -74,9 +74,10 @@ module Remitmd
       nonce_hex   = "0x#{nonce_bytes.unpack1("H*")}"
       timestamp   = Time.now.to_i
 
-      # Compute EIP-712 hash and sign it.
+      # Strip query string before signing — only the path is included in EIP-712.
+      sign_path   = full_path.split("?").first
       http_method = method.to_s.upcase
-      digest      = eip712_hash(http_method, full_path, timestamp, nonce_bytes)
+      digest      = eip712_hash(http_method, sign_path, timestamp, nonce_bytes)
       signature   = @signer.sign(digest)
 
       req["Content-Type"]      = "application/json"
@@ -155,8 +156,10 @@ module Remitmd
       when 200..299
         parsed
       when 400
-        code = parsed["code"] || RemitError::SERVER_ERROR
-        raise RemitError.new(code, parsed["message"] || "Bad request", context: parsed)
+        # Support nested error format: { "error": { "code": "...", "message": "..." } }
+        err = parsed.is_a?(Hash) && parsed["error"].is_a?(Hash) ? parsed["error"] : parsed
+        code = err["code"] || RemitError::SERVER_ERROR
+        raise RemitError.new(code, err["message"] || "Bad request", context: parsed)
       when 401
         raise RemitError.new(RemitError::UNAUTHORIZED,
                              "Authentication failed — check your private key and chain ID")

data/lib/remitmd/keccak.rb

@@ -77,7 +77,7 @@ module Remitmd
         RC.each { |rc| keccak_round!(state, rc) }
       end
 
-      def keccak_round!(state, rc) # rubocop:disable Metrics/MethodLength
+      def keccak_round!(state, rc)
         # Theta
         c = Array.new(5) do |x|
           state[x] ^ state[x + 5] ^ state[x + 10] ^ state[x + 15] ^ state[x + 20]

data/lib/remitmd/mock.rb

@@ -180,6 +180,7 @@ module Remitmd
         invoice_id = fetch!(b, :invoice_id)
         inv = @state[:pending_invoices].delete(invoice_id)
         raise not_found(RemitError::ESCROW_NOT_FOUND, invoice_id) unless inv
+
         payee  = (inv[:to_agent] || inv["to_agent"]).to_s
         amount = decimal!(inv, :amount)
         memo   = (inv[:task] || inv["task"]).to_s
@@ -310,7 +311,7 @@ module Remitmd
       # Bounty submit
       in ["POST", path] if path.end_with?("/submit") && path.include?("/bounties/")
         id = extract_id(path, "/bounties/", "/submit")
-        bnt = @state[:bounties].fetch(id) { raise not_found(RemitError::BOUNTY_NOT_FOUND, id) }
+        @state[:bounties].fetch(id) { raise not_found(RemitError::BOUNTY_NOT_FOUND, id) }
         {
           "id"            => 1,
           "bounty_id"     => id,
@@ -322,9 +323,9 @@ module Remitmd
 
       # Bounty award
       in ["POST", path] if path.end_with?("/award") && path.include?("/bounties/")
-        id            = extract_id(path, "/bounties/", "/award")
-        submission_id = (b[:submission_id] || b["submission_id"]).to_i
-        bnt           = @state[:bounties].fetch(id) { raise not_found(RemitError::BOUNTY_NOT_FOUND, id) }
+        id  = extract_id(path, "/bounties/", "/award")
+        _submission_id = (b[:submission_id] || b["submission_id"]).to_i
+        bnt = @state[:bounties].fetch(id) { raise not_found(RemitError::BOUNTY_NOT_FOUND, id) }
         new_bnt = update_bounty(bnt, status: BountyStatus::AWARDED)
         @state[:bounties][id] = new_bnt
         bounty_hash(new_bnt)
@@ -620,6 +621,7 @@ module Remitmd
     def check_balance!(amount)
       bal = @state[:balance]
       return if bal >= amount
+
       raise RemitError.new(
         RemitError::INSUFFICIENT_FUNDS,
         "Insufficient balance: have #{bal.to_s("F")} USDC, need #{amount.to_s("F")} USDC",

data/lib/remitmd/models.rb

@@ -23,20 +23,23 @@ module Remitmd
   end
 
   module TabStatus
-    OPEN    = "open"
-    CLOSED  = "closed"
-    EXPIRED = "expired"
+    OPEN      = "open"
+    CLOSED    = "closed"
+    EXPIRED   = "expired"
+    SUSPENDED = "suspended"
   end
 
   module StreamStatus
     ACTIVE    = "active"
     CLOSED    = "closed"
     COMPLETED = "completed"
+    PAUSED    = "paused"
+    CANCELLED = "cancelled"
   end
 
   module BountyStatus
     OPEN      = "open"
-    CLAIMED   = "claimed"
+    CLOSED    = "closed"
     AWARDED   = "awarded"
     EXPIRED   = "expired"
     CANCELLED = "cancelled"
@@ -46,6 +49,7 @@ module Remitmd
     LOCKED    = "locked"
     RETURNED  = "returned"
     FORFEITED = "forfeited"
+    EXPIRED   = "expired"
   end
 
   # ─── Permit & Contract Addresses ─────────────────────────────────────────
@@ -93,12 +97,14 @@ module Remitmd
     def decimal(value)
       return value if value.is_a?(BigDecimal)
       return BigDecimal(value.to_s) if value
+
       nil
     end
 
     def parse_time(value)
       return value if value.is_a?(Time)
       return Time.parse(value) if value.is_a?(String)
+
       nil
     end
   end
@@ -136,7 +142,7 @@ module Remitmd
       @fee          = decimal(h["fee"] || "0")
       @memo         = h["memo"] || ""
       @chain_id     = h["chain_id"]&.to_i
-      @block_number = h["block_number"]&.to_i || 0
+      @block_number = h["block_number"].to_i
       @created_at   = parse_time(h["created_at"])
     end
 
@@ -164,10 +170,10 @@ module Remitmd
     def initialize(attrs)
       h = attrs.transform_keys(&:to_s)
       @address           = h["address"]
-      @score             = h["score"]&.to_i || 0
+      @score             = h["score"].to_i
       @total_paid        = decimal(h["total_paid"])
       @total_received    = decimal(h["total_received"])
-      @transaction_count = h["transaction_count"]&.to_i || 0
+      @transaction_count = h["transaction_count"].to_i
       @member_since      = parse_time(h["member_since"])
     end
 
@@ -203,21 +209,24 @@ module Remitmd
     def initialize(attrs)
       h = attrs.transform_keys(&:to_s)
       @id          = h["id"]
-      @opener      = h["opener"] || h["payer"]
-      @provider    = h["provider"] || h["counterpart"]
+      @payer       = h["payer"] || h["opener"]
+      @payee       = h["payee"] || h["provider"] || h["counterpart"]
       @limit       = decimal(h["limit_amount"] || h["limit"])
-      @used        = decimal(h["used"] || "0")
+      @spent       = decimal(h["spent"] || h["used"] || "0")
       @remaining   = decimal(h["remaining"] || h["limit_amount"] || h["limit"])
       @status      = h["status"]
       @created_at  = parse_time(h["created_at"])
       @closes_at   = parse_time(h["closes_at"])
     end
 
-    attr_reader :id, :opener, :provider, :limit, :used, :remaining,
+    attr_reader :id, :payer, :payee, :limit, :spent, :remaining,
                 :status, :created_at, :closes_at
 
-    # Backward compatibility alias
-    alias counterpart provider
+    # Backward compatibility aliases
+    alias opener payer
+    alias provider payee
+    alias counterpart payee
+    alias used spent
 
     private :decimal, :parse_time
   end
@@ -228,9 +237,9 @@ module Remitmd
       @tab_id     = h["tab_id"]
       @amount     = decimal(h["amount"])
       @cumulative = decimal(h["cumulative"])
-      @call_count = h["call_count"]&.to_i || 0
+      @call_count = h["call_count"].to_i
       @memo       = h["memo"] || ""
-      @sequence   = h["sequence"]&.to_i || 0
+      @sequence   = h["sequence"].to_i
       @signature  = h["signature"]
     end
 
@@ -242,19 +251,29 @@ module Remitmd
   class Stream < Model
     def initialize(attrs)
       h = attrs.transform_keys(&:to_s)
-      @id           = h["id"]
-      @sender       = h["sender"]
-      @recipient    = h["recipient"]
-      @rate_per_sec = decimal(h["rate_per_sec"])
-      @deposited    = decimal(h["deposited"])
-      @withdrawn    = decimal(h["withdrawn"] || "0")
-      @status       = h["status"]
-      @started_at   = parse_time(h["started_at"])
-      @ends_at      = parse_time(h["ends_at"])
+      @id              = h["id"]
+      @payer           = h["payer"] || h["sender"]
+      @payee           = h["payee"] || h["recipient"]
+      @rate_per_second = decimal(h["rate_per_second"] || h["rate_per_sec"])
+      @deposited       = decimal(h["deposited"])
+      @total_streamed  = decimal(h["total_streamed"] || h["withdrawn"] || "0")
+      @max_duration    = h["max_duration"]
+      @max_total       = decimal(h["max_total"])
+      @status          = h["status"]
+      @started_at      = parse_time(h["started_at"])
+      @ends_at         = parse_time(h["ends_at"])
+      @closed_at       = parse_time(h["closed_at"])
     end
 
-    attr_reader :id, :sender, :recipient, :rate_per_sec, :deposited,
-                :withdrawn, :status, :started_at, :ends_at
+    attr_reader :id, :payer, :payee, :rate_per_second, :deposited,
+                :total_streamed, :max_duration, :max_total,
+                :status, :started_at, :ends_at, :closed_at
+
+    # Backward compatibility aliases
+    alias sender payer
+    alias recipient payee
+    alias rate_per_sec rate_per_second
+    alias withdrawn total_streamed
 
     private :decimal, :parse_time
   end
@@ -262,22 +281,27 @@ module Remitmd
   class Bounty < Model
     def initialize(attrs)
       h = attrs.transform_keys(&:to_s)
-      @id               = h["id"]
-      @poster           = h["poster"]
-      @amount           = decimal(h["amount"] || h["award"])
-      @task_description = h["task_description"] || h["description"]
-      @status           = h["status"]
-      @winner           = h["winner"] || ""
-      @expires_at       = parse_time(h["expires_at"])
-      @created_at       = parse_time(h["created_at"])
+      @id           = h["id"]
+      @poster       = h["poster"]
+      @amount       = decimal(h["amount"] || h["award"])
+      @task         = h["task"] || h["task_description"] || h["description"]
+      @submissions  = h["submissions"] || []
+      @validation   = h["validation"]
+      @max_attempts = h["max_attempts"]
+      @deadline     = h["deadline"]
+      @status       = h["status"]
+      @winner       = h["winner"] || ""
+      @expires_at   = parse_time(h["expires_at"])
+      @created_at   = parse_time(h["created_at"])
     end
 
-    attr_reader :id, :poster, :amount, :task_description, :status,
-                :winner, :expires_at, :created_at
+    attr_reader :id, :poster, :amount, :task, :submissions, :validation,
+                :max_attempts, :deadline, :status, :winner, :expires_at, :created_at
 
     # Backward compatibility aliases
     alias award amount
-    alias description task_description
+    alias task_description task
+    alias description task
 
     private :decimal, :parse_time
   end
@@ -285,15 +309,19 @@ module Remitmd
   class BountySubmission < Model
     def initialize(attrs)
       h = attrs.transform_keys(&:to_s)
-      @id          = h["id"]
-      @bounty_id   = h["bounty_id"]
-      @submitter   = h["submitter"]
-      @evidence_hash = h["evidence_hash"]
-      @status      = h["status"]
-      @created_at  = parse_time(h["created_at"])
+      @id           = h["id"]
+      @bounty_id    = h["bounty_id"]
+      @submitter    = h["submitter"]
+      @evidence_uri = h["evidence_uri"] || h["evidence_hash"]
+      @accepted     = h.key?("accepted") ? h["accepted"] : h["status"]
+      @created_at   = parse_time(h["created_at"])
     end
 
-    attr_reader :id, :bounty_id, :submitter, :evidence_hash, :status, :created_at
+    attr_reader :id, :bounty_id, :submitter, :evidence_uri, :accepted, :created_at
+
+    # Backward compatibility aliases
+    alias evidence_hash evidence_uri
+    alias status accepted
 
     private :parse_time
   end
@@ -302,19 +330,21 @@ module Remitmd
     def initialize(attrs)
       h = attrs.transform_keys(&:to_s)
       @id          = h["id"]
-      @depositor   = h["depositor"] || h["payer"]
-      @provider    = h["provider"] || h["beneficiary"]
+      @payer       = h["payer"] || h["depositor"]
+      @payee       = h["payee"] || h["provider"] || h["beneficiary"]
       @amount      = decimal(h["amount"])
       @status      = h["status"]
       @expires_at  = parse_time(h["expires_at"])
       @created_at  = parse_time(h["created_at"])
     end
 
-    attr_reader :id, :depositor, :provider, :amount,
+    attr_reader :id, :payer, :payee, :amount,
                 :status, :expires_at, :created_at
 
-    # Backward compatibility alias
-    alias beneficiary provider
+    # Backward compatibility aliases
+    alias depositor payer
+    alias provider payee
+    alias beneficiary payee
 
     private :decimal, :parse_time
   end
@@ -361,7 +391,7 @@ module Remitmd
       @period         = h["period"]
       @total_spent    = decimal(h["total_spent"])
       @total_fees     = decimal(h["total_fees"])
-      @tx_count       = h["tx_count"]&.to_i || 0
+      @tx_count       = h["tx_count"].to_i
       @top_recipients = h["top_recipients"] || []
     end
 
@@ -407,9 +437,9 @@ module Remitmd
       h = attrs.transform_keys(&:to_s)
       items_raw = h["items"] || []
       @items    = items_raw.map { |tx| Transaction.new(tx) }
-      @total    = h["total"]&.to_i || 0
-      @page     = h["page"]&.to_i || 1
-      @per_page = h["per_page"]&.to_i || 50
+      @total    = h["total"].to_i
+      @page     = (h["page"] || 1).to_i
+      @per_page = (h["per_page"] || 50).to_i
       @has_more = h["has_more"] == true
     end
 

data/lib/remitmd/wallet.rb

@@ -50,12 +50,9 @@ module Remitmd
       end
 
       @signer = signer || PrivateKeySigner.new(private_key)
-      # Normalize chain key for USDC lookups (underscore → hyphen).
+      # Normalize chain key (underscore → hyphen). Full chain name is sent in API bodies.
       @chain_key = chain.tr("_", "-")
-      # Normalize to the base chain name (strip testnet suffix) for use in pay body.
-      # The server accepts "base" — not "base_sepolia" etc.
-      @chain  = chain.sub(/_sepolia\z/, "").sub(/-sepolia\z/, "")
-      cfg     = CHAIN_CONFIG.fetch(chain) do
+      cfg = CHAIN_CONFIG.fetch(chain) do
         raise ArgumentError, "Unknown chain: #{chain}. Valid: #{CHAIN_CONFIG.keys.join(", ")}"
       end
       base_url       = api_url || cfg[:url]
@@ -101,7 +98,7 @@ module Remitmd
     # Get deployed contract addresses. Cached for the lifetime of this client.
     # @return [ContractAddresses]
     def get_contracts
-      @contracts_cache ||= ContractAddresses.new(@transport.get("/contracts"))
+      @get_contracts ||= ContractAddresses.new(@transport.get("/contracts"))
     end
 
     # ─── Balance & Analytics ─────────────────────────────────────────────────
@@ -154,8 +151,8 @@ module Remitmd
       validate_amount!(amount)
       resolved = permit || auto_permit("router", amount.to_f)
       nonce = SecureRandom.hex(16)
-      body = { to: to, amount: amount.to_s, task: memo || "", chain: @chain, nonce: nonce, signature: "0x" }
-      body[:permit] = resolved.to_h
+      body = { to: to, amount: amount.to_f, task: memo || "", chain: @chain_key, nonce: nonce, signature: "0x" }
+      body[:permit] = resolved&.to_h
       Transaction.new(@transport.post("/payments/direct", body))
     end
 
@@ -177,16 +174,16 @@ module Remitmd
       invoice_id = SecureRandom.hex(16)
       nonce      = SecureRandom.hex(16)
       inv_body = {
-        id: invoice_id, chain: @chain,
+        id: invoice_id, chain: @chain_key,
         from_agent: address.downcase, to_agent: payee.downcase,
-        amount: amount.to_s, type: "escrow",
+        amount: amount.to_f, type: "escrow",
         task: memo || "", nonce: nonce, signature: "0x"
       }
       inv_body[:escrow_timeout] = expires_in_secs if expires_in_secs
       @transport.post("/invoices", inv_body)
 
       # Step 2: fund the escrow.
-      esc_body = { invoice_id: invoice_id, permit: resolved.to_h }
+      esc_body = { invoice_id: invoice_id, permit: resolved&.to_h }
       Escrow.new(@transport.post("/escrows", esc_body))
     end
 
@@ -234,12 +231,12 @@ module Remitmd
       validate_amount!(limit_amount)
       resolved = permit || auto_permit("tab", limit_amount.to_f)
       body = {
-        chain: @chain,
+        chain: @chain_key,
         provider: provider,
         limit_amount: limit_amount.to_f,
         per_unit: per_unit.to_f,
         expiry: Time.now.to_i + expires_in_secs,
-        permit: resolved.to_h
+        permit: resolved&.to_h
       }
       Tab.new(@transport.post("/tabs", body))
     end
@@ -278,9 +275,10 @@ module Remitmd
     # @param provider_sig [String, nil] EIP-712 signature from the provider
     # @return [Tab]
     def close_tab(tab_id, final_amount: nil, provider_sig: nil)
-      body = {}
-      body[:final_amount] = final_amount.to_f if final_amount
-      body[:provider_sig] = provider_sig if provider_sig
+      body = {
+        final_amount: final_amount ? final_amount.to_f : 0,
+        provider_sig: provider_sig || "0x"
+      }
       Tab.new(@transport.post("/tabs/#{tab_id}/close", body))
     end
 
@@ -427,11 +425,11 @@ module Remitmd
       validate_amount!(max_total)
       resolved = permit || auto_permit("stream", max_total.to_f)
       body = {
-        chain: @chain,
+        chain: @chain_key,
         payee: payee,
         rate_per_second: rate_per_second.to_s,
         max_total: max_total.to_s,
-        permit: resolved.to_h
+        permit: resolved&.to_h
       }
       Stream.new(@transport.post("/streams", body))
     end
@@ -463,12 +461,12 @@ module Remitmd
       validate_amount!(amount)
       resolved = permit || auto_permit("bounty", amount.to_f)
       body = {
-        chain: @chain,
+        chain: @chain_key,
         amount: amount.to_f,
         task_description: task_description,
         deadline: deadline,
         max_attempts: max_attempts,
-        permit: resolved.to_h
+        permit: resolved&.to_h
       }
       Bounty.new(@transport.post("/bounties", body))
     end
@@ -518,11 +516,11 @@ module Remitmd
       validate_amount!(amount)
       resolved = permit || auto_permit("deposit", amount.to_f)
       body = {
-        chain: @chain,
+        chain: @chain_key,
         provider: provider,
         amount: amount.to_f,
         expiry: Time.now.to_i + expires_in_secs,
-        permit: resolved.to_h
+        permit: resolved&.to_h
       }
       Deposit.new(@transport.post("/deposits", body))
     end
@@ -563,7 +561,7 @@ module Remitmd
     # @return [Webhook]
     def register_webhook(url, events, chains: nil)
       body = { url: url, events: events }
-      body[:chains] = chains if chains
+      body[:chains] = chains || [@chain_key]
       Webhook.new(@transport.post("/webhooks", body))
     end
 
@@ -580,7 +578,7 @@ module Remitmd
       body[:agent_name] = agent_name if agent_name
       begin
         resolved = permit || auto_permit("relayer", 999_999_999.0)
-        body[:permit] = resolved.to_h
+        body[:permit] = resolved&.to_h
       rescue StandardError => e
         warn "[remitmd] create_fund_link: auto-permit failed: #{e.message}"
       end
@@ -598,7 +596,7 @@ module Remitmd
       body[:agent_name] = agent_name if agent_name
       begin
         resolved = permit || auto_permit("relayer", 999_999_999.0)
-        body[:permit] = resolved.to_h
+        body[:permit] = resolved&.to_h
       rescue StandardError => e
         warn "[remitmd] create_withdraw_link: auto-permit failed: #{e.message}"
       end
@@ -608,10 +606,25 @@ module Remitmd
     # ─── Testnet ──────────────────────────────────────────────────────────────
 
     # Mint testnet USDC. Max $2,500 per call, once per hour per wallet.
+    # Uses unauthenticated HTTP (no EIP-712 auth headers).
     # @param amount [Numeric] amount in USDC
     # @return [Hash] { "tx_hash" => "0x...", "balance" => 1234.56 }
     def mint(amount)
-      @transport.post("/mint", { wallet: address, amount: amount })
+      if @mock_mode
+        @transport.post("/mint", { wallet: address, amount: amount })
+      else
+        cfg = CHAIN_CONFIG[@chain_key]
+        base_url = cfg ? cfg[:url] : "https://testnet.remit.md/api/v1"
+        uri = URI("#{base_url}/mint")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.read_timeout = 15
+        req = Net::HTTP::Post.new(uri.path)
+        req["Content-Type"] = "application/json"
+        req.body = { wallet: address, amount: amount }.to_json
+        resp = http.request(req)
+        JSON.parse(resp.body.to_s)
+      end
     end
 
     private
@@ -620,6 +633,7 @@ module Remitmd
 
     def validate_address!(addr)
       return if addr.match?(ADDRESS_RE)
+
       raise RemitError.new(
         RemitError::INVALID_ADDRESS,
         "Invalid address #{addr.inspect}: expected 0x-prefixed 40-character hex string. " \
@@ -631,6 +645,7 @@ module Remitmd
     def validate_amount!(amount)
       d = BigDecimal(amount.to_s)
       return if d >= MIN_AMOUNT
+
       raise RemitError.new(
         RemitError::INVALID_AMOUNT,
         "Amount #{amount} is below the minimum of #{MIN_AMOUNT} USDC.",
@@ -664,7 +679,7 @@ module Remitmd
     # Fetch the EIP-2612 permit nonce from the API.
     # @param usdc_address [String] the USDC contract address
     # @return [Integer] current nonce
-    def fetch_permit_nonce(usdc_address)
+    def fetch_permit_nonce(_usdc_address)
       return 0 if @mock_mode
 
       data = @transport.get("/status/#{address}")
@@ -681,18 +696,19 @@ module Remitmd
     end
 
     # Auto-sign a permit for the given contract type and amount.
+    # Returns nil on failure instead of raising, so callers can proceed without a permit.
     # @param contract [String] contract key — "router", "escrow", "tab", etc.
     # @param amount [Numeric] amount in USDC
-    # @return [PermitSignature]
+    # @return [PermitSignature, nil]
     def auto_permit(contract, amount)
       contracts = get_contracts
       spender = contracts.send(contract.to_sym)
-      raise RemitError.new(
-        RemitError::SERVER_ERROR,
-        "No #{contract} contract address available"
-      ) unless spender
+      return nil unless spender
 
       sign_permit(spender, amount)
+    rescue => e
+      warn "[remitmd] auto-permit failed for #{contract} (amount=#{amount}): #{e.message}"
+      nil
     end
 
     # Spender contract mapping for auto_permit.

data/lib/remitmd/x402_client.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "securerandom"
+require "base64"
+
+module Remitmd
+  # Raised when an x402 payment amount exceeds the configured auto-pay limit.
+  class AllowanceExceededError < RemitError
+    attr_reader :amount_usdc, :limit_usdc
+
+    def initialize(amount_usdc, limit_usdc)
+      @amount_usdc = amount_usdc
+      @limit_usdc  = limit_usdc
+      super(
+        "ALLOWANCE_EXCEEDED",
+        "x402 payment #{format("%.6f", amount_usdc)} USDC exceeds auto-pay limit #{format("%.6f", limit_usdc)} USDC"
+      )
+    end
+  end
+
+  # x402 client — fetch wrapper that auto-pays HTTP 402 Payment Required responses.
+  #
+  # On receiving a 402, the client:
+  # 1. Decodes the PAYMENT-REQUIRED header (base64 JSON)
+  # 2. Checks the amount is within max_auto_pay_usdc
+  # 3. Builds and signs an EIP-3009 transferWithAuthorization
+  # 4. Base64-encodes the PAYMENT-SIGNATURE header
+  # 5. Retries the original request with payment attached
+  #
+  # @example
+  #   signer = Remitmd::PrivateKeySigner.new("0x...")
+  #   client = Remitmd::X402Client.new(wallet: signer)
+  #   response = client.fetch("https://api.provider.com/v1/data")
+  #
+  class X402Client
+    attr_reader :last_payment
+
+    # @param wallet [#sign, #address] a signer that can sign EIP-712 digests
+    # @param max_auto_pay_usdc [Float] maximum USDC amount to auto-pay per request (default: 0.10)
+    def initialize(wallet:, max_auto_pay_usdc: 0.10)
+      @wallet            = wallet
+      @max_auto_pay_usdc = max_auto_pay_usdc
+      @last_payment      = nil
+    end
+
+    # Make an HTTP request, auto-paying any 402 responses within the configured limit.
+    #
+    # @param url [String] the URL to fetch
+    # @param method [Symbol] HTTP method (:get, :post, etc.)
+    # @param headers [Hash] additional request headers
+    # @param body [String, nil] request body (for POST/PUT)
+    # @return [Net::HTTPResponse]
+    def fetch(url, method: :get, headers: {}, body: nil)
+      uri  = URI(url)
+      resp = make_request(uri, method, headers, body)
+
+      if resp.code.to_i == 402
+        handle402(uri, resp, method, headers, body)
+      else
+        resp
+      end
+    end
+
+    private
+
+    def make_request(uri, method, headers, body)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.read_timeout = 15
+
+      req = case method
+            when :get    then Net::HTTP::Get.new(uri)
+            when :post   then Net::HTTP::Post.new(uri)
+            when :put    then Net::HTTP::Put.new(uri)
+            when :delete then Net::HTTP::Delete.new(uri)
+            else              Net::HTTP::Get.new(uri)
+            end
+
+      headers.each { |k, v| req[k.to_s] = v.to_s }
+      req.body = body if body
+      http.request(req)
+    end
+
+    def handle402(uri, response, method, headers, body)
+      # 1. Decode PAYMENT-REQUIRED header.
+      raw = response["payment-required"] || response["PAYMENT-REQUIRED"]
+      raise RemitError.new("SERVER_ERROR", "402 response missing PAYMENT-REQUIRED header") unless raw
+
+      required = JSON.parse(Base64.decode64(raw))
+
+      # 2. Only "exact" scheme is supported.
+      unless required["scheme"] == "exact"
+        raise RemitError.new("SERVER_ERROR", "Unsupported x402 scheme: #{required["scheme"]}")
+      end
+
+      # Store for caller inspection (V2 fields: resource, description, mimeType).
+      @last_payment = required
+
+      # 3. Check auto-pay limit.
+      amount_base_units = required["amount"].to_i
+      amount_usdc       = amount_base_units / 1_000_000.0
+      if amount_usdc > @max_auto_pay_usdc
+        raise AllowanceExceededError.new(amount_usdc, @max_auto_pay_usdc)
+      end
+
+      # 4. Parse chainId from CAIP-2 network string (e.g. "eip155:84532" -> 84532).
+      chain_id = required["network"].split(":")[1].to_i
+
+      # 5. Build EIP-3009 authorization fields.
+      now_secs     = Time.now.to_i
+      valid_before = now_secs + (required["maxTimeoutSeconds"] || 60).to_i
+      nonce_bytes  = SecureRandom.bytes(32)
+      nonce_hex    = "0x#{nonce_bytes.unpack1("H*")}"
+
+      # 6. Sign EIP-712 typed data for TransferWithAuthorization.
+      digest = eip3009_digest(
+        chain_id:     chain_id,
+        asset:        required["asset"],
+        from:         @wallet.address,
+        to:           required["payTo"],
+        value:        amount_base_units,
+        valid_after:  0,
+        valid_before: valid_before,
+        nonce_bytes:  nonce_bytes
+      )
+      signature = @wallet.sign(digest)
+
+      # 7. Build PAYMENT-SIGNATURE JSON payload.
+      payment_payload = {
+        scheme:      required["scheme"],
+        network:     required["network"],
+        x402Version: 1,
+        payload: {
+          signature:     signature,
+          authorization: {
+            from:        @wallet.address,
+            to:          required["payTo"],
+            value:       required["amount"],
+            validAfter:  "0",
+            validBefore: valid_before.to_s,
+            nonce:       nonce_hex,
+          },
+        },
+      }
+      payment_header = Base64.strict_encode64(JSON.generate(payment_payload))
+
+      # 8. Retry with PAYMENT-SIGNATURE header.
+      new_headers = headers.merge("PAYMENT-SIGNATURE" => payment_header)
+      make_request(uri, method, new_headers, body)
+    end
+
+    # Compute the EIP-712 hash for EIP-3009 TransferWithAuthorization.
+    def eip3009_digest(chain_id:, asset:, from:, to:, value:, valid_after:, valid_before:, nonce_bytes:)
+      # Domain separator: USD Coin / version 2
+      domain_type_hash = keccak256(
+        "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
+      )
+      name_hash     = keccak256("USD Coin")
+      version_hash  = keccak256("2")
+      chain_id_enc  = abi_uint256(chain_id)
+      contract_enc  = abi_address(asset)
+
+      domain_data      = domain_type_hash + name_hash + version_hash + chain_id_enc + contract_enc
+      domain_separator = keccak256(domain_data)
+
+      # TransferWithAuthorization struct hash
+      type_hash = keccak256(
+        "TransferWithAuthorization(address from,address to,uint256 value," \
+        "uint256 validAfter,uint256 validBefore,bytes32 nonce)"
+      )
+      struct_data = type_hash +
+                    abi_address(from) +
+                    abi_address(to) +
+                    abi_uint256(value) +
+                    abi_uint256(valid_after) +
+                    abi_uint256(valid_before) +
+                    nonce_bytes
+
+      struct_hash = keccak256(struct_data)
+
+      # Final EIP-712 hash
+      keccak256("\x19\x01" + domain_separator + struct_hash)
+    end
+
+    def keccak256(data)
+      Remitmd::Keccak.digest(data.b)
+    end
+
+    def abi_uint256(value)
+      [value.to_i.to_s(16).rjust(64, "0")].pack("H*")
+    end
+
+    def abi_address(addr)
+      hex = addr.to_s.delete_prefix("0x").rjust(64, "0")
+      [hex].pack("H*")
+    end
+  end
+end

data/lib/remitmd/x402_paywall.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "base64"
+
+module Remitmd
+  # x402 paywall for service providers — gate HTTP endpoints behind payments.
+  #
+  # Providers use this class to:
+  # - Return HTTP 402 responses with properly formatted PAYMENT-REQUIRED headers
+  # - Verify incoming PAYMENT-SIGNATURE headers against the remit.md facilitator
+  #
+  # @example Rack middleware
+  #   paywall = Remitmd::X402Paywall.new(
+  #     wallet_address: "0xYourProviderWallet",
+  #     amount_usdc: 0.001,
+  #     network: "eip155:84532",
+  #     asset: "0x2d846325766921935f37d5b4478196d3ef93707c"
+  #   )
+  #   use paywall.rack_middleware
+  #
+  class X402Paywall
+    # @param wallet_address [String] provider's checksummed Ethereum address (the payTo field)
+    # @param amount_usdc [Float] price per request in USDC (e.g. 0.001)
+    # @param network [String] CAIP-2 network string (e.g. "eip155:84532")
+    # @param asset [String] USDC contract address on the target network
+    # @param facilitator_url [String] base URL of the remit.md facilitator
+    # @param facilitator_token [String] bearer JWT for authenticating calls to /api/v1/x402/verify
+    # @param max_timeout_seconds [Integer] how long the payment authorization remains valid
+    # @param resource [String, nil] V2 — URL or path of the resource being protected
+    # @param description [String, nil] V2 — human-readable description
+    # @param mime_type [String, nil] V2 — MIME type of the resource
+    def initialize( # rubocop:disable Metrics/ParameterLists
+      wallet_address:,
+      amount_usdc:,
+      network:,
+      asset:,
+      facilitator_url: "https://remit.md",
+      facilitator_token: "",
+      max_timeout_seconds: 60,
+      resource: nil,
+      description: nil,
+      mime_type: nil
+    )
+      @wallet_address      = wallet_address
+      @amount_base_units   = (amount_usdc * 1_000_000).round.to_s
+      @network             = network
+      @asset               = asset
+      @facilitator_url     = facilitator_url.chomp("/")
+      @facilitator_token   = facilitator_token
+      @max_timeout_seconds = max_timeout_seconds
+      @resource            = resource
+      @description         = description
+      @mime_type           = mime_type
+    end
+
+    # Return the base64-encoded JSON PAYMENT-REQUIRED header value.
+    # @return [String]
+    def payment_required_header
+      payload = {
+        scheme:            "exact",
+        network:           @network,
+        amount:            @amount_base_units,
+        asset:             @asset,
+        payTo:             @wallet_address,
+        maxTimeoutSeconds: @max_timeout_seconds,
+      }
+      payload[:resource]    = @resource    if @resource
+      payload[:description] = @description if @description
+      payload[:mimeType]    = @mime_type   if @mime_type
+      Base64.strict_encode64(JSON.generate(payload))
+    end
+
+    # Check whether a PAYMENT-SIGNATURE header represents a valid payment.
+    # Calls the remit.md facilitator's /api/v1/x402/verify endpoint.
+    #
+    # @param payment_sig [String, nil] the raw header value (base64 JSON), or nil if absent
+    # @return [Hash] { is_valid: true/false, invalid_reason: String or nil }
+    def check(payment_sig)
+      return { is_valid: false } unless payment_sig
+
+      payment_payload = begin
+        JSON.parse(Base64.decode64(payment_sig))
+      rescue JSON::ParserError
+        return { is_valid: false, invalid_reason: "INVALID_PAYLOAD" }
+      end
+
+      body = {
+        paymentPayload:  payment_payload,
+        paymentRequired: payment_required_object,
+      }
+
+      uri = URI("#{@facilitator_url}/api/v1/x402/verify")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.read_timeout = 10
+
+      req = Net::HTTP::Post.new(uri.path)
+      req["Content-Type"] = "application/json"
+      req["Authorization"] = "Bearer #{@facilitator_token}" unless @facilitator_token.empty?
+      req.body = JSON.generate(body)
+
+      begin
+        resp = http.request(req)
+        unless resp.is_a?(Net::HTTPSuccess)
+          return { is_valid: false, invalid_reason: "FACILITATOR_ERROR" }
+        end
+
+        data = JSON.parse(resp.body)
+      rescue StandardError
+        return { is_valid: false, invalid_reason: "FACILITATOR_ERROR" }
+      end
+
+      {
+        is_valid:       data["isValid"] == true,
+        invalid_reason: data["invalidReason"],
+      }
+    end
+
+    # Rack middleware adapter.
+    #
+    # @example
+    #   use paywall.rack_middleware
+    #
+    # @return [Class] a Rack middleware class
+    def rack_middleware
+      paywall = self
+      Class.new do
+        define_method(:initialize) do |app|
+          @app     = app
+          @paywall = paywall
+        end
+
+        define_method(:call) do |env|
+          payment_sig = env["HTTP_PAYMENT_SIGNATURE"]
+          result = @paywall.check(payment_sig)
+
+          unless result[:is_valid]
+            headers = {
+              "Content-Type"     => "application/json",
+              "PAYMENT-REQUIRED" => @paywall.payment_required_header,
+            }
+            body = JSON.generate({
+              error:         "Payment required",
+              invalidReason: result[:invalid_reason],
+            })
+            return [402, headers, [body]]
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+
+    private
+
+    def payment_required_object
+      {
+        scheme:            "exact",
+        network:           @network,
+        amount:            @amount_base_units,
+        asset:             @asset,
+        payTo:             @wallet_address,
+        maxTimeoutSeconds: @max_timeout_seconds,
+      }
+    end
+  end
+end

data/lib/remitmd.rb

@@ -7,6 +7,9 @@ require_relative "remitmd/signer"
 require_relative "remitmd/http"
 require_relative "remitmd/wallet"
 require_relative "remitmd/mock"
+require_relative "remitmd/a2a"
+require_relative "remitmd/x402_client"
+require_relative "remitmd/x402_paywall"
 
 # remit.md Ruby SDK — universal payment protocol for AI agents.
 #
@@ -22,5 +25,5 @@ require_relative "remitmd/mock"
 #   mock.was_paid?("0x0000000000000000000000000000000000000001", 1.00) # => true
 #
 module Remitmd
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: remitmd
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - remit.md
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-24 00:00:00.000000000 Z
+date: 2026-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -58,6 +58,8 @@ files:
 - lib/remitmd/models.rb
 - lib/remitmd/signer.rb
 - lib/remitmd/wallet.rb
+- lib/remitmd/x402_client.rb
+- lib/remitmd/x402_paywall.rb
 homepage: https://remit.md
 licenses:
 - MIT