remitmd 0.1.5 → 0.1.7

data/lib/remitmd/models.rb

@@ -16,35 +16,40 @@ module Remitmd
   module EscrowStatus
     PENDING   = "pending"
     FUNDED    = "funded"
-    RELEASED  = "released"
+    ACTIVE    = "active"
+    COMPLETED = "completed"
     CANCELLED = "cancelled"
-    EXPIRED   = "expired"
+    FAILED    = "failed"
   end
 
   module TabStatus
-    OPEN    = "open"
-    CLOSED  = "closed"
-    SETTLED = "settled"
+    OPEN      = "open"
+    CLOSED    = "closed"
+    EXPIRED   = "expired"
+    SUSPENDED = "suspended"
   end
 
   module StreamStatus
     ACTIVE    = "active"
+    CLOSED    = "closed"
+    COMPLETED = "completed"
     PAUSED    = "paused"
-    ENDED     = "ended"
     CANCELLED = "cancelled"
   end
 
   module BountyStatus
     OPEN      = "open"
+    CLOSED    = "closed"
     AWARDED   = "awarded"
     EXPIRED   = "expired"
-    RECLAIMED = "reclaimed"
+    CANCELLED = "cancelled"
   end
 
   module DepositStatus
     LOCKED    = "locked"
     RETURNED  = "returned"
     FORFEITED = "forfeited"
+    EXPIRED   = "expired"
   end
 
   # ─── Permit & Contract Addresses ─────────────────────────────────────────
@@ -92,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
@@ -116,12 +123,11 @@ module Remitmd
       @deposit        = h["deposit"]
       @fee_calculator = h["fee_calculator"]
       @key_registry   = h["key_registry"]
-      @arbitration    = h["arbitration"]
       @relayer        = h["relayer"]
     end
 
     attr_reader :chain_id, :usdc, :router, :escrow, :tab, :stream,
-                :bounty, :deposit, :fee_calculator, :key_registry, :arbitration,
+                :bounty, :deposit, :fee_calculator, :key_registry,
                 :relayer
   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

@@ -2,8 +2,6 @@
 
 require "bigdecimal"
 require "bigdecimal/util"
-require "net/http"
-require "uri"
 require "json"
 
 module Remitmd
@@ -14,13 +12,6 @@ module Remitmd
     "localhost" => "0x5FbDB2315678afecb367f032d93F642f64180aa3",
   }.freeze
 
-  # Default JSON-RPC endpoints per chain (for nonce fetching).
-  DEFAULT_RPC_URLS = {
-    "base-sepolia" => "https://sepolia.base.org",
-    "base" => "https://mainnet.base.org",
-    "localhost" => "http://127.0.0.1:8545",
-  }.freeze
-
   # Primary remit.md client. All payment operations are methods on RemitWallet.
   #
   # @example Quickstart
@@ -39,16 +30,14 @@ module Remitmd
     # @param signer [Signer, nil]      custom signer (pass instead of private_key)
     # @param chain [String]            chain name — "base", "base_sepolia"
     # @param api_url [String, nil]     override API base URL
-    # @param rpc_url [String, nil]     override JSON-RPC URL for on-chain queries
     # @param transport [Object, nil]   inject mock transport (used by MockRemit)
-    def initialize(private_key: nil, signer: nil, chain: "base", api_url: nil, router_address: nil, rpc_url: nil, transport: nil)
+    def initialize(private_key: nil, signer: nil, chain: "base", api_url: nil, router_address: nil, transport: nil)
       if transport
         # MockRemit path: transport + signer injected directly
         @signer    = signer
         @transport = transport
         @chain_key = "base-sepolia"
         @chain_id  = ChainId::BASE_SEPOLIA
-        @rpc_url   = DEFAULT_RPC_URLS["base-sepolia"]
         @mock_mode = true
         return
       end
@@ -61,18 +50,14 @@ module Remitmd
       end
 
       @signer = signer || PrivateKeySigner.new(private_key)
-      # Normalize chain key for USDC/RPC 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]
       @chain_id      = cfg[:chain_id]
       router_address ||= ""
-      @rpc_url = rpc_url || ENV["REMITMD_RPC_URL"] || DEFAULT_RPC_URLS[@chain_key] || DEFAULT_RPC_URLS["base-sepolia"]
       @transport = HttpTransport.new(
         base_url:       base_url,
         signer:         @signer,
@@ -82,14 +67,19 @@ module Remitmd
     end
 
     # Build a RemitWallet from environment variables.
-    # Reads: REMITMD_PRIVATE_KEY, REMITMD_CHAIN, REMITMD_API_URL, REMITMD_ROUTER_ADDRESS, REMITMD_RPC_URL.
+    # Reads: REMITMD_KEY (primary) or REMITMD_PRIVATE_KEY (deprecated fallback),
+    # REMITMD_CHAIN, REMITMD_API_URL, REMITMD_ROUTER_ADDRESS.
     def self.from_env
-      key            = ENV.fetch("REMITMD_PRIVATE_KEY") { raise ArgumentError, "REMITMD_PRIVATE_KEY not set" }
+      key = ENV["REMITMD_KEY"] || ENV["REMITMD_PRIVATE_KEY"]
+      if ENV["REMITMD_PRIVATE_KEY"] && !ENV["REMITMD_KEY"]
+        warn "[remitmd] REMITMD_PRIVATE_KEY is deprecated, use REMITMD_KEY instead"
+      end
+      raise ArgumentError, "REMITMD_KEY not set" unless key
+
       chain          = ENV.fetch("REMITMD_CHAIN", "base")
       api_url        = ENV["REMITMD_API_URL"]
       router_address = ENV["REMITMD_ROUTER_ADDRESS"]
-      rpc_url        = ENV["REMITMD_RPC_URL"]
-      new(private_key: key, chain: chain, api_url: api_url, router_address: router_address, rpc_url: rpc_url)
+      new(private_key: key, chain: chain, api_url: api_url, router_address: router_address)
     end
 
     # The Ethereum address associated with this wallet.
@@ -108,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 ─────────────────────────────────────────────────
@@ -161,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
 
@@ -184,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
 
@@ -241,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
@@ -285,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
 
@@ -350,7 +341,15 @@ module Remitmd
     # @param usdc_address [String, nil] override the USDC contract address
     # @return [PermitSignature]
     def sign_usdc_permit(spender, value, deadline, nonce = 0, usdc_address: nil)
-      usdc_addr = usdc_address || USDC_ADDRESSES[@chain_key] || ""
+      usdc_addr = usdc_address || USDC_ADDRESSES[@chain_key]
+      if usdc_addr.nil? || usdc_addr.empty?
+        raise RemitError.new(
+          RemitError::INVALID_ADDRESS,
+          "No USDC address configured for chain #{@chain_key.inspect}. " \
+          "Valid chains: #{USDC_ADDRESSES.keys.join(", ")}",
+          context: { chain: @chain_key }
+        )
+      end
       chain_id = @chain_id || ChainId::BASE_SEPOLIA
 
       # Domain separator for USDC (EIP-2612)
@@ -397,8 +396,16 @@ module Remitmd
     # @param deadline [Integer, nil] optional Unix timestamp; defaults to 1 hour from now
     # @return [PermitSignature]
     def sign_permit(spender, amount, deadline: nil)
-      usdc_addr = USDC_ADDRESSES[@chain_key] || ""
-      nonce = fetch_usdc_nonce(usdc_addr)
+      usdc_addr = USDC_ADDRESSES[@chain_key]
+      if usdc_addr.nil? || usdc_addr.empty?
+        raise RemitError.new(
+          RemitError::INVALID_ADDRESS,
+          "No USDC address configured for chain #{@chain_key.inspect}. " \
+          "Valid chains: #{USDC_ADDRESSES.keys.join(", ")}",
+          context: { chain: @chain_key }
+        )
+      end
+      nonce = fetch_permit_nonce(usdc_addr)
       dl = deadline || (Time.now.to_i + 3600)
       raw = (amount * 1_000_000).round.to_i
       sign_usdc_permit(spender, raw, dl, nonce, usdc_address: usdc_addr)
@@ -418,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
@@ -454,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
@@ -509,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
@@ -554,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
 
@@ -571,9 +578,9 @@ 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
-      rescue StandardError
-        # permit signing failed — proceed without permit (custodial fallback)
+        body[:permit] = resolved&.to_h
+      rescue StandardError => e
+        warn "[remitmd] create_fund_link: auto-permit failed: #{e.message}"
       end
       LinkResponse.new(@transport.post("/links/fund", body))
     end
@@ -589,9 +596,9 @@ 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
-      rescue StandardError
-        # permit signing failed — proceed without permit (custodial fallback)
+        body[:permit] = resolved&.to_h
+      rescue StandardError => e
+        warn "[remitmd] create_withdraw_link: auto-permit failed: #{e.message}"
       end
       LinkResponse.new(@transport.post("/links/withdraw", body))
     end
@@ -599,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
@@ -611,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. " \
@@ -622,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.",
@@ -652,56 +676,39 @@ module Remitmd
 
     # ─── Permit helpers ──────────────────────────────────────────────────
 
-    # Fetch the current EIP-2612 nonce for this wallet from the USDC contract.
-    # Uses JSON-RPC eth_call with selector 0x7ecebe00 (nonces(address)).
+    # Fetch the EIP-2612 permit nonce from the API.
     # @param usdc_address [String] the USDC contract address
     # @return [Integer] current nonce
-    def fetch_usdc_nonce(usdc_address)
+    def fetch_permit_nonce(_usdc_address)
       return 0 if @mock_mode
 
-      padded = address.downcase.delete_prefix("0x").rjust(64, "0")
-      data = "0x7ecebe00#{padded}"
-      payload = {
-        jsonrpc: "2.0",
-        id: 1,
-        method: "eth_call",
-        params: [{ to: usdc_address, data: data }, "latest"]
-      }
-
-      uri = URI.parse(@rpc_url)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = (uri.scheme == "https")
-      http.read_timeout = 10
-      http.open_timeout = 5
-
-      req = Net::HTTP::Post.new(uri.request_uri)
-      req["Content-Type"] = "application/json"
-      req.body = payload.to_json
-
-      resp = http.request(req)
-      result = JSON.parse(resp.body)
-
-      if result["error"]
-        msg = result["error"].is_a?(Hash) ? result["error"]["message"] : result["error"].to_s
-        raise RemitError.new(RemitError::NETWORK_ERROR, "RPC error fetching nonce: #{msg}")
+      data = @transport.get("/status/#{address}")
+      nonce = data.is_a?(Hash) ? data["permit_nonce"] : nil
+      if nonce.nil?
+        raise RemitError.new(
+          RemitError::NETWORK_ERROR,
+          "permit_nonce not available from API for #{address}. " \
+          "Ensure the server supports the permit_nonce field in GET /api/v1/status.",
+          context: { address: address }
+        )
       end
-
-      (result["result"] || "0x0").to_i(16)
+      nonce.to_i
     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.