remitmd 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77a3a0333d3f1afc8315ad1d523bc9adb70e74d2f5af29bc20b608233b0f67b1
-  data.tar.gz: b04b273b6340c25f8adcc5e755e99a4f32c9e804aec91d2e28058a66f507e9e9
+  metadata.gz: 8c2b03f3cb2f1a05e9a33845448154e4d34fda42f65af31823be2f30fb14b6fe
+  data.tar.gz: 3d6dc094058152593779b5430899400d7b9d6543693ee3dd35dfd08b88f4c131
 SHA512:
-  metadata.gz: 3e343856eb6688f7a5bee1a10fa85ae119e9ac548eeedfb4bb95a21f4a5565d8ad4921efccfcad940f3f8a89fb7a0fd313243c7dd511f132c0540b69e05b2f82
-  data.tar.gz: 284848e90b0c9c53bc80a07fa7a2bc90ea7f3e1afef282b10308a9fc5805b9c750392d75a6055bf152660d15a1b3948d06fddbf179f5daf2ae3b586f0e18a35a
+  metadata.gz: deca4edd8beb6ac2d798102a83838762d746f4508bf5e852bb1b43d74aed1fa24a7b328bc4880560fc5ab60f5bd2c937277123183c3c45cc430bf02407f5c5c8
+  data.tar.gz: c8b3bd0dc87584d00abe0b3acb37a52fa16f1f9af337780dd6aecc861f2cd542d2d684d636b28bef6b0227c13002c3c70388809d2e38a2874255bde0dd1c3932

data/README.md

@@ -24,7 +24,7 @@ gem install remitmd
 ```ruby
 require "remitmd"
 
-wallet = Remitmd::RemitWallet.new(private_key: ENV["REMITMD_PRIVATE_KEY"])
+wallet = Remitmd::RemitWallet.new(private_key: ENV["REMITMD_KEY"])
 
 # Direct payment
 tx = wallet.pay("0xRecipient0000000000000000000000000000001", 1.50)
@@ -39,12 +39,32 @@ Or from environment variables:
 
 ```ruby
 wallet = Remitmd::RemitWallet.from_env
-# Requires: REMITMD_PRIVATE_KEY
+# Requires: REMITMD_KEY (or REMIT_SIGNER_URL + REMIT_SIGNER_TOKEN)
 # Optional: REMITMD_CHAIN (default: "base"), REMITMD_API_URL
 ```
 
 Permits are auto-signed. Every payment method fetches the on-chain USDC nonce, signs an EIP-2612 permit, and includes it automatically.
 
+## Local Signer (Recommended)
+
+The local signer delegates key management to `remit signer`, a localhost HTTP server that holds your encrypted key. Your agent only needs a URL and token — no private key in the environment.
+
+```bash
+export REMIT_SIGNER_URL=http://127.0.0.1:7402
+export REMIT_SIGNER_TOKEN=rmit_sk_...
+```
+
+```ruby
+# Explicit
+signer = Remitmd::HttpSigner.new(url: "http://127.0.0.1:7402", token: "rmit_sk_...")
+wallet = Remitmd::RemitWallet.new(signer: signer)
+
+# Or auto-detect from env (recommended)
+wallet = Remitmd::RemitWallet.from_env # detects REMIT_SIGNER_URL automatically
+```
+
+`RemitWallet.from_env` detects signer credentials automatically. Priority: `REMIT_SIGNER_URL` > `REMITMD_KEY`.
+
 ## Payment Models
 
 ### Direct Payment

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/http_signer.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module Remitmd
+  # Signer backed by a local HTTP signing server.
+  #
+  # Delegates digest signing to an HTTP server (typically
+  # `http://127.0.0.1:7402`). The signer server holds the encrypted key;
+  # this adapter only needs a bearer token and URL.
+  #
+  # @example
+  #   signer = Remitmd::HttpSigner.new(url: "http://127.0.0.1:7402", token: "rmit_sk_...")
+  #   wallet = Remitmd::RemitWallet.new(signer: signer, chain: "base")
+  #
+  class HttpSigner
+    include Signer
+
+    # Create an HttpSigner, fetching and caching the wallet address.
+    #
+    # @param url [String] signer server URL (e.g. "http://127.0.0.1:7402")
+    # @param token [String] bearer token for authentication
+    # @raise [RemitError] if the server is unreachable, returns an error, or returns no address
+    def initialize(url:, token:)
+      @url = url.chomp("/")
+      @token = token
+      @address = fetch_address
+    end
+
+    # Sign a 32-byte digest (raw binary bytes).
+    # Posts to /sign/digest with the hex-encoded digest.
+    # Returns a 0x-prefixed 65-byte hex signature.
+    #
+    # @param digest_bytes [String] 32-byte binary digest
+    # @return [String] 0x-prefixed 65-byte hex signature
+    # @raise [RemitError] on network, auth, policy, or server errors
+    def sign(digest_bytes)
+      hex = "0x#{digest_bytes.unpack1("H*")}"
+      uri = URI("#{@url}/sign/digest")
+      http = build_http(uri)
+
+      req = Net::HTTP::Post.new(uri.path)
+      req["Content-Type"] = "application/json"
+      req["Authorization"] = "Bearer #{@token}"
+      req.body = { digest: hex }.to_json
+
+      resp = begin
+        http.request(req)
+      rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError => e
+        raise RemitError.new(
+          RemitError::NETWORK_ERROR,
+          "HttpSigner: cannot reach signer server at #{@url}: #{e.message}"
+        )
+      end
+
+      handle_sign_response(resp)
+    end
+
+    # The cached Ethereum address (0x-prefixed).
+    # @return [String]
+    attr_reader :address
+
+    # Never expose the bearer token in inspect/to_s output.
+    def inspect
+      "#<Remitmd::HttpSigner address=#{@address}>"
+    end
+
+    alias to_s inspect
+
+    private
+
+    # Fetch the wallet address from GET /address during construction.
+    # @return [String] the 0x-prefixed Ethereum address
+    # @raise [RemitError] on any failure
+    def fetch_address
+      uri = URI("#{@url}/address")
+      http = build_http(uri)
+
+      req = Net::HTTP::Get.new(uri.path)
+      req["Authorization"] = "Bearer #{@token}"
+
+      resp = begin
+        http.request(req)
+      rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError => e
+        raise RemitError.new(
+          RemitError::NETWORK_ERROR,
+          "HttpSigner: cannot reach signer server at #{@url}: #{e.message}"
+        )
+      end
+
+      status = resp.code.to_i
+
+      if status == 401
+        raise RemitError.new(
+          RemitError::UNAUTHORIZED,
+          "HttpSigner: unauthorized -- check your REMIT_SIGNER_TOKEN"
+        )
+      end
+
+      unless (200..299).cover?(status)
+        raise RemitError.new(
+          RemitError::SERVER_ERROR,
+          "HttpSigner: GET /address failed (#{status})"
+        )
+      end
+
+      body = begin
+        JSON.parse(resp.body.to_s)
+      rescue JSON::ParserError
+        raise RemitError.new(
+          RemitError::SERVER_ERROR,
+          "HttpSigner: GET /address returned malformed JSON"
+        )
+      end
+
+      addr = body["address"]
+      if addr.nil? || addr.to_s.empty?
+        raise RemitError.new(
+          RemitError::SERVER_ERROR,
+          "HttpSigner: GET /address returned no address"
+        )
+      end
+
+      addr.to_s
+    end
+
+    # Handle the response from POST /sign/digest.
+    # @param resp [Net::HTTPResponse]
+    # @return [String] the 0x-prefixed hex signature
+    # @raise [RemitError] on any error
+    def handle_sign_response(resp)
+      status = resp.code.to_i
+
+      if status == 401
+        raise RemitError.new(
+          RemitError::UNAUTHORIZED,
+          "HttpSigner: unauthorized -- check your REMIT_SIGNER_TOKEN"
+        )
+      end
+
+      if status == 403
+        reason = begin
+          data = JSON.parse(resp.body.to_s)
+          data["reason"] || "unknown"
+        rescue JSON::ParserError
+          "unknown"
+        end
+        raise RemitError.new(
+          RemitError::UNAUTHORIZED,
+          "HttpSigner: policy denied -- #{reason}"
+        )
+      end
+
+      unless (200..299).cover?(status)
+        detail = begin
+          data = JSON.parse(resp.body.to_s)
+          data["reason"] || data["error"] || "server error"
+        rescue JSON::ParserError
+          "server error"
+        end
+        raise RemitError.new(
+          RemitError::SERVER_ERROR,
+          "HttpSigner: sign failed (#{status}): #{detail}"
+        )
+      end
+
+      body = begin
+        JSON.parse(resp.body.to_s)
+      rescue JSON::ParserError
+        raise RemitError.new(
+          RemitError::SERVER_ERROR,
+          "HttpSigner: POST /sign/digest returned malformed JSON"
+        )
+      end
+
+      sig = body["signature"]
+      if sig.nil? || sig.to_s.empty?
+        raise RemitError.new(
+          RemitError::SERVER_ERROR,
+          "HttpSigner: server returned no signature"
+        )
+      end
+
+      sig.to_s
+    end
+
+    # Build a Net::HTTP client for the given URI.
+    # @param uri [URI] the target URI
+    # @return [Net::HTTP]
+    def build_http(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = 5
+      http.read_timeout = 10
+      http
+    end
+  end
+end

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",