callx402 1.0.2 → 1.0.3

package/.github/workflows/npm-publish.yml

@@ -15,14 +15,14 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - run: npm install -g npm@latest
       - uses: actions/setup-node@v4
         with:
-          node-version: '20'
+          node-version: '22'
           registry-url: 'https://registry.npmjs.org'
-
-      - run: npm install
+      - run: npm install -g npm@latest
+      - run: npm ci --no-audit --no-fund
       - run: npm test
+      - run: npm pack --dry-run
 
 
       - name: Publish to npm via Trusted Publishing (OIDC, no token)

package/.github/workflows/review-ci.yml

@@ -0,0 +1,24 @@
+name: callx402 Review Tests (no live payments)
+on:
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+permissions:
+  contents: read
+jobs:
+  verify:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+      - run: npm ci
+      - run: npm test
+      - run: node --check core/rail.js
+      - run: node --check core/payer-auth.js
+      - run: node --check bin/callx402.js
+      - name: Validate package/lockfile version parity
+        run: node -e "const p=require('./package.json');const l=require('./package-lock.json');if(p.version!==l.version||p.version!==l.packages[''].version)process.exit(1)"
+      - name: Verify npm release archive without publishing
+        run: npm pack --dry-run

package/README.md

@@ -301,21 +301,31 @@ read-only diagnostic server-side and returns the result**. No local setup, no
 separate tree, no keys. The rail never fakes execution: every result is
 produced by the diagnostic modules over the evidence you supply.
 
-The quote-before-payment flow, verified live:
+The hosted quote-before-payment flow:
 
 ```sh
-# 1. Free quote: exact price before anything is paid
+# 1. Obtain a free quote. No money moves.
 curl "https://payload-rail.fly.dev/v1/callx402/quote?action=resolve&path=x402"
-# -> {"quote_id":"...","quoted_price_usd":"0.25", ...}
 
-# 2. Invoke unauthenticated -> x402 v2 402 with the exact payment terms
-curl -X POST https://payload-rail.fly.dev/v1/callx402/actions/resolve \
-  -H 'Content-Type: application/json' -d '{"evidence":"{...}"}'
-# -> HTTP 402: exact USDC amount on Base, pay-to address, 300s window, quote_id
+# 2. Run the interactive client. Pay explicitly by card or with USDC.
+#    For USDC redemption, the paying wallet must EIP-191-sign the exact
+#    authorization message displayed by the CLI.
+callx402 resolve --evidence '{"txHash":"0x..."}'
 
-# 3. Pay deliberately from an authorized wallet, then retry with {txHash, quote_id}
+# 3. Agents with an external wallet-produced signature can redeem the
+#    ORIGINAL canonical quote with a signed authorization file:
+callx402 resolve --evidence '{"txHash":"0x..."}' \
+  --tx-hash 0xYOUR_SETTLED_PAYMENT_HASH \
+  --payer-auth @signed-auth.json --approve
 ```
 
+A public transaction hash alone never authorizes an action. The signed authorization
+binds the paying wallet, action, transaction hash, quote, recipient, network,
+and request inputs. Keep the original `quote_inputs` with the signed authorization;
+requesting a new quote does not authorize an older payment. **Never give Payload
+a private key, seed phrase, or wallet recovery phrase.** EIP-1271 contract-wallet
+redemption is not currently enabled. Stripe credits use a separate redemption path.
+
 Live fee schedule: `GET https://payload-rail.fly.dev/v1/callx402/actions`
 (responds `"model":"paid on-demand per action; no subscription required"`).
 The x402-path price is the Stripe-path fee divided by 20 — for example

package/bin/callx402.js

@@ -305,6 +305,7 @@ function parseArgv(argv) {
   const KNOWN_FLAGS = new Set([
     'help', 'version', 'json', 'timeout', 'maxBudget', 'approvalThreshold',
     'idempotencyKey', 'evidence', 'incident', 'goal', 'intent', 'query',
+    'txHash', 'payerAuth', 'creditId',
     'target', 'speed', 'interval', 'network', 'networks', 'asset', 'assets',
     'providers', 'deadline', 'risk',
     'dryRun', 'approve', 'forceRetry', 'retry', 'auth', 'watch', 'once',
@@ -324,7 +325,8 @@ function parseArgv(argv) {
         i += 1;
         continue;
       }
-      const NEEDS_VALUE = new Set(['timeout', 'maxBudget', 'approvalThreshold', 'idempotencyKey', 'evidence', 'incident', 'goal', 'intent', 'query', 'target', 'speed', 'interval', 'network', 'networks', 'asset', 'assets', 'providers', 'deadline', 'risk', 'dir', 'operationId', 'identity']);
+      const NEEDS_VALUE = new Set(['timeout', 'maxBudget', 'approvalThreshold', 'idempotencyKey', 'evidence', 'incident', 'goal', 'intent', 'query', 'target',
+        'txHash', 'payerAuth', 'creditId', 'speed', 'interval', 'network', 'networks', 'asset', 'assets', 'providers', 'deadline', 'risk', 'dir', 'operationId', 'identity']);
       if (NEEDS_VALUE.has(name)) {
         if (val !== null) out.flags[name] = val;
         else if (i + 1 < argv.length && !argv[i + 1].startsWith('-')) out.flags[name] = argv[++i];
@@ -503,7 +505,9 @@ async function main() {
     // payment/authorization -> result. Set CALLX402_LOCAL=1 to prefer the
     // local v2.0.0 runtime tree instead (advanced self-hosted mode).
     if (rail.isRailCommand(actionName) && !rail.preferLocal()) {
-      const railResult = await rail.invokeRail(actionName, args, { yes: args.approve, json: args.json });
+      const railResult = await rail.invokeRail(actionName,
+        { ...args, txHash: flags.txHash, payerAuth: flags.payerAuth, creditId: flags.creditId },
+        { yes: args.approve, json: args.json });
       if (args.json) {
         console.log(JSON.stringify(railResult, null, 2));
       } else if (railResult.ok) {

package/core/payer-auth.js

@@ -0,0 +1,59 @@
+'use strict';
+
+/**
+ * The client never signs messages or accepts wallet private keys.
+ * An external wallet signs the EIP-191 message and supplies a 65-byte signature.
+ * This canonical message MUST remain in lockstep with Rail payer-auth.ts.
+ */
+const fs = require('node:fs');
+const { createHash } = require('node:crypto');
+const path = require('node:path');
+
+function actionRequestHash(action, body) {
+  const data = {
+    action,
+    evidence: body.evidence ?? null,
+    invocation_id: body.invocation_id ?? null,
+    context: body.context ?? null,
+    operation_id: body.operation_id ?? null,
+    target: body.target ?? null,
+    identity: body.identity ?? null,
+  };
+  return '0x' + createHash('sha256').update(JSON.stringify(data), 'utf8').digest('hex');
+}
+
+function buildAuthMessage(auth) {
+  return [
+    'Payload x402 Authorization',
+    `wallet:${String(auth.wallet).toLowerCase()}`,
+    `action:${auth.action}`,
+    `txHash:${String(auth.txHash).toLowerCase()}`,
+    `quote_id:${auth.quote_id}`,
+    `request_hash:${auth.request_hash}`,
+    `network:${auth.network}`,
+    `recipient:${String(auth.recipient).toLowerCase()}`,
+    `nonce:${auth.nonce}`,
+    `expiry:${auth.expiry}`,
+  ].join('\n');
+}
+
+function readSignedAuthorization(value) {
+  if (!value || typeof value !== 'string') throw new Error('payer authorization JSON or @file required');
+  const raw = value.startsWith('@') ?
+    fs.readFileSync(path.resolve(value.slice(1)), 'utf8') : value;
+  const obj = JSON.parse(raw);
+  if (!obj || typeof obj !== 'object' || Array.isArray(obj)) throw new Error('expected an object');
+  if (!/^0x[0-9a-fA-F]{40}$/.test(obj.wallet || '')) throw new Error('invalid wallet');
+  if (!/^0x[0-9a-fA-F]{64}$/.test(obj.txHash || '')) throw new Error('invalid txHash');
+  if (!/^0x[0-9a-fA-F]{40}$/.test(obj.recipient || '')) throw new Error('invalid recipient');
+  if (!/^0x[0-9a-fA-F]{64}$/.test(obj.request_hash || '')) throw new Error('invalid action request hash');
+  if (!/^0x[0-9a-fA-F]{130}$/.test(obj.signature || '')) throw new Error('invalid EIP-191 signature');
+  if (typeof obj.action !== 'string' || typeof obj.network !== 'string' ||
+      typeof obj.quote_id !== 'string' || typeof obj.nonce !== 'string' ||
+      !Number.isSafeInteger(obj.expiry) || obj.expiry <= Math.floor(Date.now() / 1000)) {
+    throw new Error('malformed or expired authorization fields');
+  }
+  return obj;
+}
+
+module.exports = { buildAuthMessage, actionRequestHash, readSignedAuthorization };

package/core/rail.js

@@ -18,12 +18,13 @@
  * Nothing here signs, holds keys, or moves money.
  */
 
+const { randomBytes } = require('node:crypto');
+const { buildAuthMessage, actionRequestHash, readSignedAuthorization } = require('./payer-auth.js');
 const RAIL_BASE = process.env.CALLX402_RAIL || 'https://payload-rail.fly.dev';
 const RAIL_ACTIONS = [
-  'diagnose', 'doctor', 'rescue', 'route', 'resolve', 'execute', 'monitor',
-  'preflight', 'inspect', 'evidence', 'explain', 'recover',
-  'settlement_interpretation', 'safe_retry', 'failure_classification',
-  'duplicate_payment_risk',
+  'diagnose', 'doctor', 'resolve', 'preflight',
+  'evidence', 'explain', 'recover',
+  'settlement_interpretation', 'failure_classification', 'duplicate_payment_risk',
 ];
 
 // Map CLI command names to rail action names.
@@ -120,12 +121,27 @@ async function invokeRail(command, args, opts = {}) {
   const evidence = buildEvidence(action, args);
   const interactive = process.stdin.isTTY && !opts.yes;
 
-  // 1. Free quote first.
+  // 1. Fresh quote for new actions; previously paid agent redemptions
+  // must reuse their ORIGINAL signed quote. A fresh quote has a different
+  // issuedAt/quote_id and would invalidate an otherwise authentic signature.
   let quote;
+  let signedAuthorization = null;
   try {
-    quote = await getQuote(action);
+    if (args.txHash && args.payerAuth) {
+      signedAuthorization = readSignedAuthorization(String(args.payerAuth));
+      if (!signedAuthorization.quote_inputs || typeof signedAuthorization.quote_inputs !== 'object') {
+        throw new Error('Signed authorization file must include the canonical quote_inputs from the original quote.');
+      }
+      quote = {
+        quote_id: signedAuthorization.quote_id,
+        quote_inputs: signedAuthorization.quote_inputs,
+        quoted_price_usd: signedAuthorization.quoted_price_usd ?? 'see signed quote',
+      };
+    } else {
+      quote = await getQuote(action);
+    }
   } catch (err) {
-    return { ok: false, error: `Could not reach the hosted rail for a free quote: ${err.message}` };
+    return { ok: false, error: `Unable to load a valid payment quote: ${err.message}` };
   }
   const price = quote.quoted_price_usd;
   const quoteId = quote.quote_id;
@@ -141,7 +157,7 @@ async function invokeRail(command, args, opts = {}) {
       return {
         ok: false,
         error: `Payment of $${price} required. Re-run with --yes to approve non-interactively, or run interactively.`,
-        quote: { action, price_usd: price, quote_id: quoteId },
+        quote: { action, price_usd: price, quote_id: quoteId, quote_inputs: quote.quote_inputs },
       };
     }
     const approve = await prompt(`  Approve $${price} for '${action}'? [y/N] `);
@@ -151,17 +167,52 @@ async function invokeRail(command, args, opts = {}) {
   }
 
   // 3. Payment: x402 (paste tx hash) or card (browser checkout -> credit ID).
-  let payBody = { evidence, quote_id: quoteId, quote };
-  if (!interactive) {
+  let payBody = { evidence, quote_id: quoteId, quote: quote.quote_inputs || {} };
+  if ((action === 'evidence' || action === 'explain') && args.operationId) {
+    payBody.invocation_id = String(args.operationId);
+  }
+  // Agents can supply a wallet-produced EIP-191 signature through a file;
+  // private keys are never requested or handled by callx402.
+  if (args.creditId) {
+    payBody = { ...payBody, credit_id: String(args.creditId) };
+  } else if (args.txHash && args.payerAuth) {
+    if (!quote.quote_inputs) return { ok: false, error: 'Rail must return canonical quote_inputs before signed redemption.' };
+    const auth = signedAuthorization;
+    if (auth.txHash?.toLowerCase() !== String(args.txHash).toLowerCase() ||
+        auth.action !== action || auth.quote_id !== quoteId ||
+        auth.request_hash !== actionRequestHash(action, payBody)) {
+      return { ok: false, error: 'Signed authorization does not match the transaction, action, and current quote.' };
+    }
+    payBody = { ...payBody, txHash: String(args.txHash).toLowerCase(), payer_auth: auth };
+  }
+  if (!payBody.credit_id && !payBody.payer_auth && !interactive) {
     return {
       ok: false,
-      error: 'Interactive payment required.',
+      error: 'Non-interactive payment requires --credit-id or --tx-hash with --payer-auth @file.',
       quote: { action, price_usd: price, quote_id: quoteId },
-      payment_instructions: `POST ${RAIL_BASE}/v1/callx402/actions/${action} with { evidence, quote_id, quote } to receive a 402, pay, then re-POST with { txHash } or { credit_id }.`,
+      payment_instructions: `Use --credit-id or --tx-hash plus --payer-auth @signed-auth.json after an authorized wallet signature; a bare txHash is never enough.`,
     };
   }
+  if (!payBody.credit_id && !payBody.payer_auth) {
   const method = await prompt('  Pay with [1] USDC on Base (paste tx hash after paying) or [2] card via browser? [1/2] ');
   if (method === '2') {
+    // Stripe is a distinct price path; never imply its fee equals the
+    // previously displayed micropayment quote.
+    let cardPrice;
+    try {
+      const catalog = await railFetch('/v1/callx402/actions');
+      const item = catalog.body?.actions?.find(a => a.action === action);
+      if (catalog.status !== 200 || !Number.isSafeInteger(item?.amount_cents) || item.amount_cents <= 0) {
+        throw new Error('card fee not available');
+      }
+      cardPrice = (item.amount_cents / 100).toFixed(2);
+    } catch {
+      return { ok: false, error: 'Could not confirm the exact card price. Checkout cancelled before payment.' };
+    }
+    const cardApproval = await prompt(`  Card checkout total $ ${cardPrice} USD for '${action}'. Continue? [y/N] `);
+    if (!/^y(es)?$/i.test(cardApproval)) {
+      return { ok: false, error: 'Card checkout cancelled before payment.' };
+    }
     // Stripe checkout path.
     const { status, body } = await railFetch('/v1/callx402/checkout', {
       method: 'POST',
@@ -179,10 +230,11 @@ async function invokeRail(command, args, opts = {}) {
     if (!creditId) return { ok: false, error: 'No credit ID provided.' };
     payBody = { ...payBody, credit_id: creditId };
   } else {
+    if (!quote.quote_inputs) return { ok: false, error: 'Rail must return canonical quote_inputs before USDC payment.' };
     // x402 path: get exact payment terms from the 402, then user pays.
     const { status, body } = await railFetch(`/v1/callx402/actions/${action}`, {
       method: 'POST',
-      body: JSON.stringify({ evidence, quote_id: quoteId, quote }),
+      body: JSON.stringify({ evidence, quote_id: quoteId, quote: quote.quote_inputs }),
     });
     if (status !== 402) {
       return { ok: false, error: `Expected a 402 payment challenge, got HTTP ${status}.` };
@@ -196,7 +248,33 @@ async function invokeRail(command, args, opts = {}) {
     if (!/^0x[0-9a-fA-F]{64}$/.test(txHash)) {
       return { ok: false, error: 'Invalid transaction hash format.' };
     }
-    payBody = { ...payBody, txHash: txHash.toLowerCase() };
+    const wallet = await prompt('  Payer wallet address (0x...): ');
+    if (!/^0x[0-9a-fA-F]{40}$/.test(wallet)) {
+      return { ok: false, error: 'A valid Ethereum payer wallet address is required.' };
+    }
+    const auth = {
+      wallet, action, txHash: txHash.toLowerCase(), quote_id: quoteId,
+      request_hash: actionRequestHash(action, payBody),
+      network: accept.network || 'eip155:8453',
+      recipient: accept.payTo,
+      nonce: '0x' + randomBytes(16).toString('hex'),
+      expiry: Math.floor(Date.now() / 1000) + 300,
+    };
+    if (!/^0x[0-9a-fA-F]{40}$/.test(auth.recipient || '')) {
+      return { ok: false, error: 'The payment challenge omitted a valid recipient; refusing redemption.' };
+    }
+    const signingMessage = buildAuthMessage(auth);
+    console.log('\n  Sign the exact message below using your paying wallet (EIP-191 personal_sign).');
+    console.log('  NEVER paste a seed phrase, private key, or recovery code.\n');
+    console.log(signingMessage);
+    console.log();
+    const signature = await prompt('  Paste wallet signature (0x...): ');
+    if (!/^0x[0-9a-fA-F]{130}$/.test(signature)) {
+      return { ok: false, error: 'Expected a 65-byte Ethereum personal_sign signature.' };
+    }
+    payBody = { ...payBody, txHash: txHash.toLowerCase(),
+      payer_auth: { ...auth, signature } };
+  }
   }
 
   // 4. Submit payment proof -> verified, executed, metered -> result.
@@ -207,6 +285,12 @@ async function invokeRail(command, args, opts = {}) {
   if (status === 402) {
     return { ok: false, error: 'Payment not yet recognized. The quote may have expired — re-run to get a fresh quote.' };
   }
+  if (status === 401) {
+    return { ok: false, error: `Wallet authorization rejected: ${body?.error?.message || 'check signed message and wallet'}` };
+  }
+  if (status === 422) {
+    return { ok: false, error: `Action could not execute: ${body?.error?.message || body?.execution?.error || 'not available'}` };
+  }
   if (status === 409) {
     return { ok: false, error: `Already used: ${body?.error?.message || 'this payment was already consumed'}.` };
   }

package/docs/signed-redemption.md

@@ -0,0 +1,84 @@
+# Secure, on-demand callx402 redemption
+
+A publicly visible on-chain transaction hash is **never** sufficient to redeem
+a paid callx402 action. The payer must produce an EIP-191 `personal_sign`
+signature, outside Payload, over the exact action, transaction hash, quote,
+action inputs, wallet, Base network, Payload recipient, nonce and expiration.
+
+**Never provide your seed phrase or private key to Payload or the CLI.**
+The CLI does not ask for or store wallet secrets.
+
+## Human use
+
+```bash
+callx402 diagnose --evidence '{"error":"settlement timeout"}'
+```
+
+The CLI displays a free **USDC** quote before asking permission to spend.
+For USDC it presents the payment details, then asks for the paying wallet
+address and a signature created by your wallet over the canonical message.
+For Stripe card checkout it explicitly confirms the separate card price.
+
+Only actions supported by the hosted service are presented as paid services.
+Some advanced commands require an optional local runtime and must not be
+misrepresented as completed hosted executions.
+
+## Non-interactive agent use
+
+An agent must obtain a free quote **before** payment:
+
+```text
+GET https://payload-rail.fly.dev/v1/callx402/quote?action=resolve&path=x402
+```
+
+Preserve both `quote_id` and `quote_inputs` from this exact quote response.
+Quote IDs include issuance time; requesting a fresh quote after signing will
+produce a different ID. Use the original quote before it expires.
+
+Use `actionRequestHash(action, body)` from `core/payer-auth.js` for the exact
+input the agent will redeem. For example, if the CLI will send
+`{evidence: "{\\"error\\":\\"settlement timeout\\"}"}`, pass that exact evidence
+**string** to the hash function; do not hash a parsed object instead.
+
+The owner’s wallet must sign the canonical
+`buildAuthMessage({wallet, action, txHash, quote_id, request_hash, network, recipient, nonce, expiry})`
+via EIP-191 `personal_sign` with expiry no further than 15 minutes ahead.
+The resulting JSON file should include:
+
+```json
+{
+  "wallet": "0x...",
+  "action": "resolve",
+  "txHash": "0x...",
+  "quote_id": "the original quote ID",
+  "quote_inputs": {"action":"resolve","path":"x402","...":"other exact canonical inputs"},
+  "quoted_price_usd": "0.25",
+  "request_hash": "0x...",
+  "network": "eip155:8453",
+  "recipient": "0x...",
+  "nonce": "an unpredictable unique value",
+  "expiry": 1790000000,
+  "signature": "0x...65-byte EIP-191 signature"
+}
+```
+
+The example is illustrative, not a usable authorization; use the exact returned
+canonical `quote_inputs`. Run:
+
+```bash
+callx402 resolve --evidence @evidence.json --tx-hash 0xYOUR_TX_HASH \
+  --payer-auth @signed-auth.json --approve
+```
+
+The CLI verifies that the signed action, transaction, quote and request
+digest match what it is about to submit. The Rail independently re-derives
+the quote, recovers the signer, matches the chain payer, checks recipient
+and network, and atomically enforces one-time use. A rejected request
+does not authorize execution.
+
+**Contract wallets:** EIP-1271 is **not yet exposed on this redemption
+path**. The current secured release supports EOA EIP-191 signatures only.
+Do not claim contract-wallet redemption support until integration tests pass.
+
+**No live-money tests:** Developers must use mocked verifier / Stripe
+clients or pre-existing read-only evidence for automated tests.

package/package.json

@@ -27,6 +27,6 @@
     "smoke": "node bin/callx402.js status --json",
     "test": "node --test test/*.test.js"
   },
-  "version": "1.0.2",
+  "version": "1.0.3",
   "mcpName": "io.github.payload-tools/callx402"
-}
+}

package/test/payer-auth.test.js

@@ -0,0 +1,92 @@
+'use strict';
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { buildAuthMessage, actionRequestHash, readSignedAuthorization } = require('../core/payer-auth.js');
+const { invokeRail, isRailCommand } = require('../core/rail.js');
+
+const txHash = '0x' + '22'.repeat(32);
+const wallet = '0x' + '11'.repeat(20);
+const recipient = '0x' + '33'.repeat(20);
+const signature = '0x' + '44'.repeat(65);
+const authorization = () => ({
+  wallet, action: 'resolve', txHash, quote_id: 'q_test',
+  quote_inputs: { action: 'resolve', path: 'x402', issuedAt: 1 }, quoted_price_usd: '0.25',
+  request_hash: actionRequestHash('resolve', { evidence: '{}' }),
+  network: 'eip155:8453', recipient, nonce: 'nonce_unique_1234',
+  expiry: Math.floor(Date.now() / 1000) + 300, signature,
+});
+
+test('client and Rail use canonical EIP-191 signer message', () => {
+  const expected = [
+    'Payload x402 Authorization',
+    'wallet:' + wallet,
+    'action:resolve',
+    'txHash:' + txHash,
+    'quote_id:q_test',
+    'request_hash:' + authorization().request_hash,
+    'network:eip155:8453',
+    'recipient:' + recipient,
+    'nonce:nonce_unique_1234',
+    'expiry:' + authorization().expiry,
+  ].join('\n');
+  assert.equal(buildAuthMessage(authorization()), expected);
+});
+
+test('unsigned, malformed and expired authorizations are rejected before network payment', () => {
+  assert.throws(() => readSignedAuthorization('{}'), /wallet/);
+  const bad = { ...authorization(), expiry: Math.floor(Date.now()/1000) - 1 };
+  assert.throws(() => readSignedAuthorization(JSON.stringify(bad)), /expired/);
+});
+
+test('hosted CLI does not route local-only actions to paid Rail', () => {
+  assert.equal(isRailCommand('execute'), false);
+  assert.equal(isRailCommand('rescue'), false);
+  assert.equal(isRailCommand('resolve'), true);
+});
+
+test('signed noninteractive redemption sends signature, never wallet secrets', async () => {
+  const previous = global.fetch;
+  const requests = [];
+  global.fetch = async (url, init = {}) => {
+    requests.push({ url, init });
+    const quote = String(url).includes('/quote?');
+    const body = quote ? { quoted_price_usd: '0.25', quote_id: 'q_test', quote_inputs: { action: 'resolve', path: 'x402' } } :
+      { ok: true, invocation_id: 'invo_mock', via: 'x402', execution: { executed: true, result: { state: 'UNKNOWN' } } };
+    return { status: 200, text: async () => JSON.stringify(body) };
+  };
+  try {
+    const result = await invokeRail('resolve', {
+      evidence: '{}', txHash, payerAuth: JSON.stringify(authorization()),
+    }, { yes: true, json: true });
+    assert.equal(result.ok, true);
+    assert.equal(requests.length, 1);
+    const body = JSON.parse(requests[0].init.body);
+    assert.deepEqual(body.quote, authorization().quote_inputs);
+    assert.equal(body.txHash, txHash);
+    assert.equal(body.payer_auth.wallet, wallet);
+    assert.equal(body.payer_auth.signature, signature);
+    assert.equal(body.payer_auth.quote_id, 'q_test');
+    assert.equal('privateKey' in body, false);
+  } finally {
+    global.fetch = previous;
+  }
+});
+
+test('stale signature for a different quote fails without submitting a payment proof', async () => {
+  const previous = global.fetch;
+  const requests = [];
+  global.fetch = async (url, init = {}) => {
+    requests.push({ url, init });
+    return { status: 200, text: async () => JSON.stringify({ quoted_price_usd: '0.25', quote_id: 'q_changed', quote_inputs: { action: 'resolve', path: 'x402' } }) };
+  };
+  try {
+    const result = await invokeRail('resolve', {
+      txHash, payerAuth: JSON.stringify({ ...authorization(), action: 'recover' }),
+    }, { yes: true, json: true });
+    assert.equal(result.ok, false);
+    assert.match(result.error, /current quote/);
+    assert.equal(requests.length, 0);
+  } finally {
+    global.fetch = previous;
+  }
+});