@blindmarket/mcp-server 0.3.4 → 0.3.6

package/dist/rent.js

@@ -1,7 +1,14 @@
 import { z } from 'zod';
-import { formatEther, parseEther } from 'ethers';
-import { aesEncrypt, eciesEncrypt, generateAesKey, sha256Hex } from './crypto.js';
+import { Contract, Interface, formatUnits, parseUnits } from 'ethers';
+import { aesDecrypt, aesEncrypt, eciesDecrypt, eciesEncrypt, generateAesKey, sha256Hex } from './crypto.js';
 import { createQuote, consumeQuote, getSpend, putSpend, updateSpend } from './state.js';
+import { createSettlementResolver } from './settlement.js';
+// Read-only view of BlindEscrow.getTask, for reading a task's state directly
+// from the chain that holds it. Field order matches contracts/BlindEscrow.sol;
+// a post-#38 deployment appends disputedAt, which ABI decoding ignores.
+const ESCROW_READ_ABI = [
+    'function getTask(uint256) view returns (tuple(address agent,address worker,address token,uint256 amount,bytes32 taskHash,bytes32 evidenceHash,uint8 status,string category,string locationZone,uint256 createdAt,uint256 deadline,uint8 submissionAttempts))',
+];
 /**
  * Tier-2 spending tools: the CURRENT encrypted post/rent flow, executed
  * entirely locally. This is a 1:1 port of the "Use from your agent" script
@@ -22,6 +29,16 @@ import { createQuote, consumeQuote, getSpend, putSpend, updateSpend } from './st
  */
 const ZERO_TOKEN = '0x0000000000000000000000000000000000000000';
 const GAS_LIMIT = 1000000n; // matches the canonical rent script
+// Auto-verify releases the payment, so the bar can't be "one character" — but
+// 40 made a correct 30-character URL unpayable. 20 is the platform floor
+// (DEFAULT_MIN_CONTENT_CHARS in the backend's autoVerify, where min_length is a
+// hard floor). Accepted limit: a one-word correct answer still can't
+// auto-verify without an expected_answer. MUST match the web app's
+// RENTAL_VERIFICATION_CRITERIA (frontend/src/components/UseServiceModal.tsx and
+// UseFromAgentModal.tsx) so a rental is judged the same whichever client paid
+// for it. The index route also rejects 'auto' with no real criterion (400
+// AUTO_CRITERIA_REQUIRED).
+const RENTAL_VERIFICATION_CRITERIA = { min_length: 20 };
 function ok(data) {
     return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
 }
@@ -40,11 +57,34 @@ export function registerRentTools(server, cfg, walletCtx) {
             err.code = 'NO_API_KEY';
             throw err;
         }
-        const res = await fetch(`${cfg.apiBase}${path}`, {
-            method,
-            headers: { 'Content-Type': 'application/json', 'X-API-Key': cfg.apiKey },
-            body: body ? JSON.stringify(body) : undefined,
-        });
+        // Explicit, named timeout. Node's fetch otherwise fails after ~5 minutes
+        // with a bare "fetch failed" — which is what post_task reported, twice,
+        // for posts that had already landed on-chain while /a2a/tasks/index sat
+        // behind a dead Redis socket server-side. 120s is above the slowest
+        // healthy call (index polls for a receipt for ~1 min) and well below the
+        // point where a caller assumes the money is lost.
+        let res;
+        try {
+            res = await fetch(`${cfg.apiBase}${path}`, {
+                method,
+                headers: { 'Content-Type': 'application/json', 'X-API-Key': cfg.apiKey },
+                body: body ? JSON.stringify(body) : undefined,
+                signal: AbortSignal.timeout(120_000),
+            });
+        }
+        catch (e) {
+            // Node's fetch reports every socket-level failure as a bare "fetch
+            // failed" and hides the real reason in `cause` (ECONNRESET, socket
+            // hang up, ECONNREFUSED…). Surface it: "fetch failed" alone cost a
+            // debugging session that ended in "the server restarted mid-request".
+            const cause = e?.cause;
+            const detail = cause?.code ?? cause?.message ?? e?.message ?? String(e);
+            const err = new Error(e?.name === 'TimeoutError'
+                ? `${path} did not answer within 120s. The backend may be stalled (check its Redis connection); if this was a spend, retry with the SAME idempotencyKey — it resumes, never double-pays.`
+                : `${path} unreachable (${detail}). If the backend restarted mid-request and this was a spend, retry with the SAME idempotencyKey — it resumes from the last persisted stage.`);
+            err.code = e?.name === 'TimeoutError' ? 'BACKEND_TIMEOUT' : 'BACKEND_UNREACHABLE';
+            throw err;
+        }
         const json = await res.json().catch(() => ({}));
         if (!res.ok || !json.success) {
             const err = new Error(`${path} failed: ${json.error?.message || res.status}`);
@@ -53,21 +93,195 @@ export function registerRentTools(server, cfg, walletCtx) {
         }
         return json.data;
     }
-    function requireWallet() {
+    const settlement = createSettlementResolver({ apiBase: cfg.apiBase ?? 'https://api.blindmarket.xyz', api });
+    /** How this process pays. On 0G that is the local wallet, which must exist.
+     *  On Base nothing signs locally — the relay signs from the API key's owner
+     *  wallet — so a missing BLINDMARKET_PRIVATE_KEY is not an error there. */
+    async function requireFunding() {
+        let s;
+        try {
+            s = await settlement();
+        }
+        catch (err) {
+            return { error: fail(err.code ?? 'SETTLEMENT_UNKNOWN', err.message) };
+        }
+        if (s.mode === 'base')
+            return { s, payFrom: s.payFrom };
         if (!walletCtx) {
-            return { error: fail('NO_WALLET', 'Spending tools need a local funding wallet — set BLINDMARKET_PRIVATE_KEY (see wallet_status)') };
+            return { error: fail('NO_WALLET', 'Spending on 0G needs a local funding wallet — set BLINDMARKET_PRIVATE_KEY (see wallet_status)') };
+        }
+        return { s, payFrom: walletCtx.wallet.address };
+    }
+    const ERC20 = new Interface([
+        'function allowance(address owner, address spender) view returns (uint256)',
+        'function approve(address spender, uint256 amount) returns (bool)',
+        'function balanceOf(address owner) view returns (uint256)',
+    ]);
+    function usdc(s) {
+        return new Contract(s.usdcAddress, ERC20, s.provider);
+    }
+    /** Spendable balance of whoever pays, in the settlement token's units. */
+    async function payFromBalance(s, payFrom) {
+        try {
+            const raw = s.mode === 'base'
+                ? await usdc(s).balanceOf(payFrom)
+                : await walletCtx.provider.getBalance(payFrom);
+            return formatUnits(raw, s.decimals);
+        }
+        catch {
+            return null;
+        }
+    }
+    /** The backend builds every unsigned tx for whichever chain it thinks holds
+     *  the task, and the tx carries no chainId. Discovery is only a hint about
+     *  that chain (see settlement.ts). So before broadcasting, check the tx
+     *  targets the escrow THIS mode expects — otherwise native value goes to a
+     *  Base address on the 0G RPC, or a 0G refund is relayed onto Base. A
+     *  mismatch also drops the cached mode so the next call re-asks. */
+    async function verifyTarget(s, to, what) {
+        const target = String(to).toLowerCase();
+        const expected = s.mode === 'base' ? s.escrowAddress : s.escrowAddress;
+        if (expected) {
+            if (target === expected.toLowerCase())
+                return;
+            settlement.invalidate();
+            const e = new Error(`backend built ${what} for ${to} but this process is in ${s.mode} mode expecting escrow ${expected}. ` +
+                (s.mode === 'base'
+                    ? 'This task is escrowed on 0G — handle it with BLINDMARKET_SETTLEMENT=0g and a local key, or from the web app.'
+                    : 'The backend is building Base transactions — re-run and discovery will re-check, or set BLINDMARKET_SETTLEMENT=base.'));
+            e.code = 'ESCROW_MISMATCH';
+            throw e;
+        }
+        // 0G with no escrow address to compare against (forced 0g, or a backend
+        // that doesn't report one). The cheapest truth we have is whether
+        // anything lives at `to` on the 0G RPC — a Base escrow address holds no
+        // BlindEscrow there.
+        const code = await walletCtx.provider.getCode(to).catch(() => '0x');
+        if (code === '0x') {
+            settlement.invalidate();
+            const e = new Error(`backend built ${what} for ${to}, which holds no contract on the 0G RPC — it is almost certainly a Base transaction. Set BLINDMARKET_SETTLEMENT=base.`);
+            e.code = 'ESCROW_MISMATCH';
+            throw e;
+        }
+    }
+    async function relaySend(s, tx) {
+        // gas:'auto' asks the backend to negotiate: user-pays (USDC) → app-pays →
+        // wallet-pays, advancing only on Privy's exact refusal for each rung. The
+        // negotiation lives server-side on purpose — that is the one place that
+        // sees Privy's raw errors, and it is shared with the web app, so both
+        // clients behave identically. An earlier version did the fallback here,
+        // and it skipped app-pays entirely: the wallet kept paying its own ETH
+        // even after sponsorship was switched on in the Privy dashboard.
+        const r = await api('POST', '/api/v1/tx/relay-tx', {
+            walletAddress: s.payFrom,
+            to: tx.to,
+            data: tx.data,
+            value: tx.value === undefined ? undefined : String(tx.value),
+            chain: s.relayChain,
+            asset: 'usdc',
+            gas: 'auto',
+        });
+        if (!r?.hash) {
+            const e = new Error('relay-tx returned no hash');
+            e.code = 'RELAY_NO_HASH';
+            throw e;
+        }
+        // A backend older than the `gas` field answers without it. That backend
+        // also has no negotiation, so the only way it succeeds is the explicit
+        // default it applies to this body: user-pays.
+        return { hash: r.hash, isUserOp: r.isUserOp === true, gas: r.gas ?? 'user-pays' };
+    }
+    /** Wait for a relayed tx to land. A plain hash can be polled for its receipt;
+     *  a user-op hash cannot (getTransactionReceipt is always null for it), so
+     *  that case returns at once and the caller confirms by on-chain STATE —
+     *  see ensureAllowance and waitCancelled. */
+    async function waitRelayed(s, hash, isUserOp) {
+        if (isUserOp)
+            return;
+        for (let i = 0; i < 30; i++) {
+            const receipt = await s.provider.getTransactionReceipt(hash).catch(() => null);
+            if (receipt) {
+                if (receipt.status === 0) {
+                    const e = new Error(`relayed tx ${hash} reverted`);
+                    e.code = 'TX_REVERTED';
+                    throw e;
+                }
+                return;
+            }
+            await new Promise((r) => setTimeout(r, 3000));
         }
-        return walletCtx;
+        const e = new Error(`relayed tx ${hash} not confirmed after 90s — retry with the same idempotencyKey to resume`);
+        e.code = 'TX_PENDING';
+        throw e;
+    }
+    /** Base only: createTask pulls USDC via transferFrom, so the escrow needs an
+     *  allowance first. Confirmed by re-reading allowance() rather than by
+     *  receipt, which is what makes the user-op case decidable. */
+    async function ensureAllowance(s, record) {
+        const need = BigInt(record.amountWei);
+        const token = usdc(s);
+        if ((await token.allowance(s.payFrom, s.escrowAddress)) >= need)
+            return;
+        const approve = async () => {
+            const data = ERC20.encodeFunctionData('approve', [s.escrowAddress, need]);
+            const { hash } = await relaySend(s, { to: s.usdcAddress, data });
+            // Persist BEFORE waiting: a crash here must resume into the poll below.
+            updateSpend(record.idempotencyKey, { stage: 'approved', approveTxHash: hash });
+            record.stage = 'approved';
+            record.approveTxHash = hash;
+        };
+        const settled = async () => {
+            for (let i = 0; i < 30; i++) {
+                if ((await token.allowance(s.payFrom, s.escrowAddress)) >= need)
+                    return true;
+                await new Promise((r) => setTimeout(r, 3000));
+            }
+            return false;
+        };
+        if (record.stage === 'created') {
+            await approve();
+            if (await settled())
+                return;
+        }
+        // Resumed at 'approved' (or the fresh approve never landed): the earlier
+        // approve was dropped or reverted. Sending another is safe — ERC-20
+        // approve SETS the allowance, it does not add — and it is the only way
+        // out of this stage, so do it rather than leave the record stuck.
+        if (await settled())
+            return;
+        await approve();
+        if (await settled())
+            return;
+        const e = new Error(`USDC allowance still below ${formatUnits(need, s.decimals)} after two approves (last ${record.approveTxHash}) — check the relay wallet's USDC balance and retry with the same idempotencyKey`);
+        e.code = 'APPROVE_PENDING';
+        throw e;
     }
     /** Fund escrow + index — the shared tail of rent_service and post_task.
-     *  Resumable at every stage via the spend ledger. */
+     *  Resumable at every stage via the spend ledger.
+     *
+     *  Two funding paths, chosen by settlement mode:
+     *    0g   — native value from the local wallet, signed and sent here.
+     *    base — USDC via transferFrom: approve first (ensureAllowance), then the
+     *           createTask the backend built, both through the Privy relay with
+     *           no local signing at all. The backend picks the escrow; we only
+     *           check it is the one we approved. */
     async function fundAndIndex(record) {
-        const ctx = walletCtx;
+        const s = await settlement();
         let { txHash } = record;
-        if (record.stage === 'created') {
+        // A record remembers the chain it started on. If the backend flips mode
+        // between attempts, re-funding through the other path would double-fund
+        // or send native value into a USDC transferFrom — refuse instead.
+        if (record.settlement && record.settlement !== s.mode) {
+            const e = new Error(`spend ${record.idempotencyKey} started on ${record.settlement} but the backend now settles on ${s.mode} — finish or refund it from the web app`);
+            e.code = 'SETTLEMENT_CHANGED';
+            throw e;
+        }
+        if (record.stage === 'created' || record.stage === 'approved') {
+            if (s.mode === 'base')
+                await ensureAllowance(s, record);
             const { unsignedTx } = await api('POST', '/api/v1/tasks', {
                 taskHash: record.taskHash,
-                token: ZERO_TOKEN,
+                token: s.mode === 'base' ? s.usdcAddress : ZERO_TOKEN,
                 amount: record.amountWei,
                 locationZone: 'global',
                 duration: String(record.durationSecs ?? 3600),
@@ -78,22 +292,39 @@ export function registerRentTools(server, cfg, walletCtx) {
                 rootHash: record.rootHash,
                 wrappedKeys: record.privacy === 'public' ? undefined : record.wrappedKeys,
             });
-            const tx = await ctx.wallet.sendTransaction({
-                to: unsignedTx.to,
-                data: unsignedTx.data,
-                value: BigInt(record.amountWei),
-                gasLimit: GAS_LIMIT,
-            });
-            // Persist the tx hash BEFORE waiting: if we crash mid-confirmation the
-            // resume path re-runs /tasks/index with this hash instead of re-funding.
-            updateSpend(record.idempotencyKey, { stage: 'funded', txHash: tx.hash });
-            txHash = tx.hash;
-            await tx.wait();
+            // Either branch: the tx must target the escrow this mode expects. On
+            // Base that is also the escrow the allowance above was granted to.
+            await verifyTarget(s, unsignedTx.to, 'createTask');
+            if (s.mode === 'base') {
+                const { hash, isUserOp, gas } = await relaySend(s, { to: unsignedTx.to, data: unsignedTx.data });
+                // Persist BEFORE waiting, same reasoning as the 0G branch below.
+                updateSpend(record.idempotencyKey, { stage: 'funded', txHash: hash, isUserOp, gas });
+                record.gas = gas;
+                txHash = hash;
+                record.isUserOp = isUserOp;
+                await waitRelayed(s, hash, isUserOp);
+            }
+            else {
+                const tx = await walletCtx.wallet.sendTransaction({
+                    to: unsignedTx.to,
+                    data: unsignedTx.data,
+                    value: BigInt(record.amountWei),
+                    gasLimit: GAS_LIMIT,
+                });
+                // Persist the tx hash BEFORE waiting: if we crash mid-confirmation the
+                // resume path re-runs /tasks/index with this hash instead of re-funding.
+                updateSpend(record.idempotencyKey, { stage: 'funded', txHash: tx.hash });
+                txHash = tx.hash;
+                await tx.wait();
+            }
         }
         // stage 'funded' (fresh or resumed): index against the verified receipt.
-        // /a2a/tasks/index itself polls for the receipt server-side.
+        // /a2a/tasks/index polls both chains for the receipt server-side, and with
+        // isUserOp it skips the (always-null) receipt lookup and scans logs for the
+        // TaskCreated event instead — that is how the user-op case is resolved.
         await api('POST', '/api/v1/a2a/tasks/index', {
             txHash,
+            isUserOp: record.isUserOp ?? false,
             taskHash: record.taskHash,
             verificationMode: record.verificationMode,
             verificationCriteria: record.verificationCriteria,
@@ -106,7 +337,7 @@ export function registerRentTools(server, cfg, walletCtx) {
             publicBrief: record.privacy === 'public' ? record.publicBrief : undefined,
         });
         updateSpend(record.idempotencyKey, { stage: 'indexed' });
-        return { taskHash: record.taskHash, txHash: txHash };
+        return { taskHash: record.taskHash, txHash: txHash, gas: record.gas };
     }
     async function pollPosted(taskHash, waitSeconds) {
         const deadline = Date.now() + Math.min(60, Math.max(0, waitSeconds)) * 1000;
@@ -130,7 +361,7 @@ export function registerRentTools(server, cfg, walletCtx) {
     // ── rent_service ──────────────────────────────────────────────────────────
     server.registerTool('rent_service', {
         title: 'Rent an Agent Service',
-        description: 'Hire a listed agent service for one call: encrypts your prompt locally (unless privacy=public), funds escrow from your local wallet, and pins the task to the provider agent. TWO-STEP: first call returns a price quote + quoteId; re-call with confirm=true and that quoteId to actually spend. Requires a unique idempotencyKey (safe to retry with the same key — it resumes, never double-pays).',
+        description: 'Hire a listed agent service for one call: encrypts your prompt locally (unless privacy=public), funds escrow, and pins the task to the provider agent. Escrow is USDC on Base via the gas-sponsored relay when the backend settles there (no private key needed), else native 0G from the local wallet — see wallet_status. TWO-STEP: first call returns a price quote + quoteId; re-call with confirm=true and that quoteId to actually spend. Requires a unique idempotencyKey (safe to retry with the same key — it resumes, never double-pays).',
         inputSchema: {
             serviceId: z.number().int().positive().describe('Service id from browse_services / get_service'),
             prompt: z.string().min(1).max(100_000).describe('What you want the agent to do'),
@@ -142,9 +373,10 @@ export function registerRentTools(server, cfg, walletCtx) {
         },
         annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async ({ serviceId, prompt, idempotencyKey, privacy, confirm, quoteId, waitSeconds }) => {
-        const w = requireWallet();
-        if ('error' in w)
-            return w.error;
+        const f = await requireFunding();
+        if ('error' in f)
+            return f.error;
+        const { s, payFrom } = f;
         // Resume path — this key already spent (or partially spent).
         const existing = getSpend(idempotencyKey);
         if (existing) {
@@ -166,15 +398,29 @@ export function registerRentTools(server, cfg, walletCtx) {
         if (!isPublic && !service.agent_public_key) {
             return fail('NO_AGENT_PUBKEY', 'This service\'s agent has no encryption public key — only privacy=public calls are possible');
         }
+        // price_raw is stored in the settlement token's base units (the backend
+        // compares it against the on-chain amount as-is), so it is 6-decimal
+        // USDC on Base and 18-decimal 0G otherwise — format it that way.
+        const priceRaw = BigInt(service.price_raw);
+        // A service priced in 18-decimal units on a 6-decimal chain would quote
+        // as a trillion USDC and relay an approve for it before createTask
+        // failed. The backend converts such prices since migration 31, but an
+        // older backend may still serve one. 1,000,000 USDC per call is far
+        // above any real listing — refuse.
+        if (s.mode === 'base' && priceRaw > 1000000n * 10n ** 6n) {
+            return fail('PRICE_UNITS_SUSPECT', `service ${serviceId} lists price_raw=${priceRaw} which is ${formatUnits(priceRaw, 6)} USDC — this looks like an 18-decimal 0G price on a USDC chain. Not sending. Re-list the service in USDC base units.`);
+        }
+        const price = formatUnits(priceRaw, s.decimals);
         if (!confirm) {
-            const balance = await w.provider.getBalance(w.wallet.address).catch(() => null);
-            const quote = createQuote('rent', { serviceId, price0G: formatEther(service.price_raw) });
+            const quote = createQuote('rent', { serviceId, price, currency: s.symbol });
             return ok({
                 quote: {
                     service: { id: service.id, name: service.name, agent: service.agent_address },
-                    price0G: formatEther(service.price_raw),
-                    payFrom: w.wallet.address,
-                    walletBalance0G: balance === null ? null : formatEther(balance),
+                    price,
+                    currency: s.symbol,
+                    settlement: s.mode,
+                    payFrom,
+                    walletBalance: await payFromBalance(s, payFrom),
                     privacy: isPublic ? 'public' : 'private',
                     quoteId: quote.quoteId,
                 },
@@ -217,9 +463,11 @@ export function registerRentTools(server, cfg, walletCtx) {
                 wrappedKeys,
                 publicBrief: isPublic ? prompt.slice(0, 4000) : undefined,
                 verificationMode: 'auto',
-                verificationCriteria: { min_length: 1 },
+                verificationCriteria: RENTAL_VERIFICATION_CRITERIA,
                 requiredCapabilities: [],
                 amountWei: String(service.price_raw),
+                settlement: s.mode,
+                token: s.mode === 'base' ? s.usdcAddress : ZERO_TOKEN,
                 durationSecs: 3600,
                 createdAt: new Date().toISOString(),
                 updatedAt: new Date().toISOString(),
@@ -232,7 +480,7 @@ export function registerRentTools(server, cfg, walletCtx) {
         catch (err) {
             const code = err.code;
             if (code === 'NOT_TASK_AGENT') {
-                return fail(code, 'The API key\'s owner wallet does not match the funding wallet (BLINDMARKET_PRIVATE_KEY). Mint an sk_ key while signed in with the funding wallet. The escrow is funded but unindexed — retry with the same idempotencyKey after fixing the key, or cancel on-chain for a refund.');
+                return fail(code, 'The API key\'s owner wallet does not match the wallet that funded escrow. On 0G, mint an sk_ key while signed in with the BLINDMARKET_PRIVATE_KEY wallet; on Base the relay signs from the key\'s own wallet, so this means the key was rotated mid-spend. The escrow is funded but unindexed — retry with the same idempotencyKey after fixing the key, or use cancel_task for a refund.');
             }
             return fail(code ?? 'RENT_FAILED', err.message);
         }
@@ -240,10 +488,11 @@ export function registerRentTools(server, cfg, walletCtx) {
     // ── post_task ─────────────────────────────────────────────────────────────
     server.registerTool('post_task', {
         title: 'Post a Task to the Open Market',
-        description: 'Post a task any matching agent can pick up: encrypts the brief locally and wraps its key to every registered matching executor (or posts it in plaintext with privacy=public), then funds escrow from your local wallet. TWO-STEP quote/confirm like rent_service; requires a unique idempotencyKey.',
+        description: 'Post a task any matching agent can pick up: encrypts the brief locally and wraps its key to every registered matching executor (or posts it in plaintext with privacy=public), then funds escrow. Escrow is USDC on Base via the gas-sponsored relay when the backend settles there (no private key needed), else native 0G from the local wallet — see wallet_status. TWO-STEP quote/confirm like rent_service; requires a unique idempotencyKey.',
         inputSchema: {
             instructions: z.string().min(1).max(100_000).describe('The task brief'),
-            amount0G: z.string().regex(/^\d+(\.\d+)?$/).describe('Escrow amount in 0G (e.g. "2.5") — paid to the worker (90%) on verified completion'),
+            amount: z.string().regex(/^\d+(\.\d+)?$/).optional().describe('Escrow amount in the settlement token (e.g. "2.5" — USDC on Base, 0G on 0G) — paid to the worker (90%) on verified completion'),
+            amount0G: z.string().regex(/^\d+(\.\d+)?$/).optional().describe('Deprecated alias of `amount` kept for existing callers — same meaning, same units as the settlement token'),
             idempotencyKey: z.string().min(8).max(128).describe('Unique key for this spend — reuse it on retries'),
             capabilities: z.array(z.string()).optional().describe('Optional capability tags to route to matching agents first; empty = every agent'),
             durationSeconds: z.number().int().min(3600).max(90 * 24 * 3600).optional().describe('Deadline seconds from now (default 86400 = 24h)'),
@@ -252,10 +501,11 @@ export function registerRentTools(server, cfg, walletCtx) {
             quoteId: z.string().optional().describe('From the quote step'),
         },
         annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true },
-    }, async ({ instructions, amount0G, idempotencyKey, capabilities, durationSeconds, privacy, confirm, quoteId }) => {
-        const w = requireWallet();
-        if ('error' in w)
-            return w.error;
+    }, async ({ instructions, amount, amount0G, idempotencyKey, capabilities, durationSeconds, privacy, confirm, quoteId }) => {
+        const f = await requireFunding();
+        if ('error' in f)
+            return f.error;
+        const { s, payFrom } = f;
         const existing = getSpend(idempotencyKey);
         if (existing) {
             if (existing.stage === 'indexed') {
@@ -269,15 +519,26 @@ export function registerRentTools(server, cfg, walletCtx) {
             }
         }
         const isPublic = privacy === 'public';
-        const amountWei = parseEther(amount0G);
+        const amountStr = amount ?? amount0G;
+        if (!amountStr) {
+            return fail('AMOUNT_REQUIRED', `Pass \`amount\` — the escrow in ${s.symbol} (e.g. "2.5").`);
+        }
+        let amountWei;
+        try {
+            amountWei = parseUnits(amountStr, s.decimals);
+        }
+        catch {
+            return fail('AMOUNT_INVALID', `"${amountStr}" is not a valid ${s.symbol} amount — at most ${s.decimals} decimal places.`);
+        }
         if (!confirm) {
-            const balance = await w.provider.getBalance(w.wallet.address).catch(() => null);
-            const quote = createQuote('post', { amount0G });
+            const quote = createQuote('post', { amount: amountStr, currency: s.symbol });
             return ok({
                 quote: {
-                    escrow0G: amount0G,
-                    payFrom: w.wallet.address,
-                    walletBalance0G: balance === null ? null : formatEther(balance),
+                    escrow: amountStr,
+                    currency: s.symbol,
+                    settlement: s.mode,
+                    payFrom,
+                    walletBalance: await payFromBalance(s, payFrom),
                     privacy: isPublic ? 'public' : 'private',
                     capabilities: capabilities ?? [],
                     quoteId: quote.quoteId,
@@ -333,6 +594,8 @@ export function registerRentTools(server, cfg, walletCtx) {
                 verificationCriteria: { min_length: 10, pass_threshold: 60 },
                 requiredCapabilities: capabilities ?? [],
                 amountWei: amountWei.toString(),
+                settlement: s.mode,
+                token: s.mode === 'base' ? s.usdcAddress : ZERO_TOKEN,
                 durationSecs: durationSeconds ?? 86400,
                 createdAt: new Date().toISOString(),
                 updatedAt: new Date().toISOString(),
@@ -344,7 +607,7 @@ export function registerRentTools(server, cfg, walletCtx) {
         catch (err) {
             const code = err.code;
             if (code === 'NOT_TASK_AGENT') {
-                return fail(code, 'The API key\'s owner wallet does not match the funding wallet (BLINDMARKET_PRIVATE_KEY). Mint an sk_ key while signed in with the funding wallet. The escrow is funded but unindexed — retry with the same idempotencyKey after fixing the key, or cancel on-chain for a refund.');
+                return fail(code, 'The API key\'s owner wallet does not match the wallet that funded escrow. On 0G, mint an sk_ key while signed in with the BLINDMARKET_PRIVATE_KEY wallet; on Base the relay signs from the key\'s own wallet, so this means the key was rotated mid-spend. The escrow is funded but unindexed — retry with the same idempotencyKey after fixing the key, or use cancel_task for a refund.');
             }
             return fail(code ?? 'POST_FAILED', err.message);
         }
@@ -359,5 +622,527 @@ export function registerRentTools(server, cfg, walletCtx) {
         },
         annotations: { readOnlyHint: true, openWorldHint: true },
     }, async ({ taskHash, waitSeconds }) => ok(await pollPosted(taskHash, waitSeconds ?? 30)));
+    // ── cancel_task / claim_timeout ───────────────────────────────────────────
+    //
+    // The two ways escrow comes back to the poster. BlindEscrow splits them by
+    // task status and they are NOT interchangeable — calling the wrong one
+    // reverts on-chain:
+    //
+    //   Funded (0)                        → cancelTask, no deadline required
+    //   Assigned/Submitted/Verified (1-3) → claimTimeout, deadline must have passed
+    //   Disputed (6)                      → claimTimeout, but only once
+    //                                       DISPUTE_WINDOW has elapsed
+    //
+    // So the quote step reads the live status first and refuses a path the
+    // contract would reject, rather than letting the caller burn gas to find out.
+    //
+    // Both send a transaction, so both carry the same quote/confirm +
+    // idempotencyKey treatment as post_task. Here the ledger's job is to stop a
+    // retry from broadcasting a SECOND refund tx while the first is still
+    // unconfirmed — the first would land and the second would revert.
+    //
+    // Chain note: the backend resolves which chain holds the task
+    // (resolveTaskChainById) and builds the unsigned tx for it; this side only
+    // decides who signs — the local wallet on 0G, the Privy relay on Base — and
+    // verifies the tx targets the escrow that mode expects before sending
+    // (verifyTarget). Task state is read from the chain the mode names, not
+    // from GET /tasks/:id, which is bound to the 0G escrow.
+    const STATUS_NAMES = ['Funded', 'Assigned', 'Submitted', 'Verified', 'Completed', 'Cancelled', 'Disputed'];
+    function statusName(status) {
+        return STATUS_NAMES[status] ?? `Unknown(${status})`;
+    }
+    /** Resolve a task id-or-hash to its live on-chain state.
+     *
+     *  GET /api/v1/tasks/:id accepts either form — but it reads the 0G escrow
+     *  only (escrowService.getTask is bound to the 0G contract), so on Base its
+     *  struct is for whatever 0G task happens to share the id. In Base mode we
+     *  use it just to turn a hash into an id, then read the struct from the
+     *  Base escrow ourselves over the read-only provider. */
+    async function loadTask(s, task) {
+        if (s.mode !== 'base') {
+            return api('GET', `/api/v1/tasks/${encodeURIComponent(task)}`);
+        }
+        // Base: the escrow is the authority, and we can read it directly. Only ask
+        // the backend when we need a hash resolved to an id — that endpoint makes
+        // several Redis round trips and is the slowest thing in this path, so a
+        // numeric id must not pay for it.
+        let taskId;
+        if (/^\d+$/.test(task)) {
+            taskId = task;
+        }
+        else {
+            const viaBackend = await api('GET', `/api/v1/tasks/${encodeURIComponent(task)}`);
+            taskId = viaBackend.taskId;
+        }
+        const escrow = new Contract(s.escrowAddress, ESCROW_READ_ABI, s.provider);
+        const t = await escrow.getTask(BigInt(taskId));
+        if (String(t.agent).toLowerCase() === ZERO_TOKEN) {
+            const e = new Error(`task ${taskId} does not exist on the Base escrow ${s.escrowAddress} — it is probably a 0G task; handle it with BLINDMARKET_SETTLEMENT=0g`);
+            e.code = 'TASK_NOT_ON_BASE';
+            throw e;
+        }
+        return {
+            taskId,
+            taskHash: String(t.taskHash),
+            status: Number(t.status),
+            amount: String(t.amount),
+            deadline: String(t.deadline),
+            token: String(t.token),
+            submissionAttempts: Number(t.submissionAttempts),
+            decimals: s.decimals,
+        };
+    }
+    /** Amount formatted against the task's OWN decimals — a Base task settles in
+     *  USDC (6), not the wallet's native 18. */
+    function refundAmount(detail) {
+        return formatUnits(BigInt(detail.amount), detail.decimals ?? 18);
+    }
+    /** The refund has landed when the task reads Cancelled on-chain. Checking
+     *  state rather than a receipt is what makes a relayed user-op decidable
+     *  (there is no receipt to poll), and it is a cheap truth check for the
+     *  local-signing path too. */
+    async function waitCancelled(s, taskId) {
+        for (let i = 0; i < 30; i++) {
+            const detail = await loadTask(s, String(taskId)).catch(() => null);
+            if (detail && Number(detail.status) === 5)
+                return;
+            await new Promise((r) => setTimeout(r, 3000));
+        }
+        const e = new Error(`task ${taskId} still not Cancelled on-chain after 90s — retry with the same idempotencyKey to keep waiting`);
+        e.code = 'REFUND_PENDING';
+        throw e;
+    }
+    /** Broadcast the refund and wait for it — the shared tail of both tools.
+     *  Resumable: a record past 'created' waits on the tx it already saved.
+     *  Same two paths as fundAndIndex: local wallet on 0G, Privy relay on Base.
+     *  The backend resolves which chain holds the task and builds the tx for
+     *  it; this only decides who signs. */
+    async function sendRefund(record) {
+        const s = await settlement();
+        const taskId = record.taskId;
+        let { txHash } = record;
+        if (record.settlement && record.settlement !== s.mode) {
+            const e = new Error(`refund ${record.idempotencyKey} started on ${record.settlement} but the backend now settles on ${s.mode} — finish it from the web app`);
+            e.code = 'SETTLEMENT_CHANGED';
+            throw e;
+        }
+        if (record.stage === 'created') {
+            const route = record.kind === 'cancel' ? 'cancel' : 'timeout';
+            const { unsignedTx } = await api('POST', `/api/v1/tasks/${taskId}/${route}`);
+            // The backend resolves the chain that holds the task and builds for it;
+            // the tx carries no chainId. If that chain is not the one this mode
+            // broadcasts on, stop here — relaying a 0G refund onto Base lands on an
+            // address with no escrow and burns the gas.
+            await verifyTarget(s, unsignedTx.to, `${route}Task`);
+            if (s.mode === 'base') {
+                const { hash, isUserOp, gas } = await relaySend(s, { to: unsignedTx.to, data: unsignedTx.data });
+                // Persist BEFORE waiting, same reasoning as the 0G branch below.
+                updateSpend(record.idempotencyKey, { stage: 'sent', txHash: hash, isUserOp, gas });
+                record.gas = gas;
+                txHash = hash;
+                record.isUserOp = isUserOp;
+                await waitRelayed(s, hash, isUserOp);
+            }
+            else {
+                const tx = await walletCtx.wallet.sendTransaction({
+                    to: unsignedTx.to,
+                    data: unsignedTx.data,
+                    gasLimit: GAS_LIMIT,
+                });
+                // Persist the hash BEFORE waiting, same reasoning as fundAndIndex: a
+                // crash mid-confirmation must resume onto THIS tx, not broadcast another.
+                updateSpend(record.idempotencyKey, { stage: 'sent', txHash: tx.hash });
+                txHash = tx.hash;
+                await tx.wait();
+            }
+        }
+        else if (txHash) {
+            if (s.mode === 'base')
+                await waitRelayed(s, txHash, record.isUserOp ?? false);
+            else
+                await walletCtx.provider.waitForTransaction(txHash);
+        }
+        else {
+            throw new Error(`Spend record ${record.idempotencyKey} is at stage '${record.stage}' with no txHash — cannot resume safely`);
+        }
+        await waitCancelled(s, taskId);
+        updateSpend(record.idempotencyKey, { stage: 'confirmed' });
+        return { taskId, txHash: txHash, gas: record.gas };
+    }
+    /** Shared resume arm: an idempotencyKey that has already moved. The kind
+     *  guard matters — the ledger is one namespace shared with rent/post, and
+     *  resuming a 'post' record through the refund path would wait on the FUNDING
+     *  tx and then mark that record confirmed, corrupting it. */
+    async function resumeRefund(existing, kind) {
+        if (existing.kind !== kind) {
+            return fail('IDEMPOTENCY_KEY_REUSED', `idempotencyKey "${existing.idempotencyKey}" already belongs to a '${existing.kind}' spend (task ${existing.taskId ?? existing.taskHash}). Use a fresh key for this refund.`);
+        }
+        if (existing.stage === 'confirmed') {
+            return ok({
+                resumed: true,
+                taskId: existing.taskId,
+                txHash: existing.txHash,
+                hint: 'Already refunded — this idempotencyKey completed earlier.',
+            });
+        }
+        try {
+            return ok({ resumed: true, ...(await sendRefund(existing)) });
+        }
+        catch (err) {
+            return fail(err.code ?? 'RESUME_FAILED', err.message);
+        }
+    }
+    server.registerTool('cancel_task', {
+        title: 'Cancel a Task and Reclaim Escrow',
+        description: 'Reclaim the escrow on a task you posted that has NOT been assigned to a worker (status Funded). Works immediately — no deadline wait. For a task that was assigned but never delivered, use claim_timeout instead. TWO-STEP quote/confirm; requires a unique idempotencyKey.',
+        inputSchema: {
+            task: z.string().min(1).describe('Task id (e.g. "51") or the 0x task hash returned by post_task'),
+            idempotencyKey: z.string().min(8).max(128).describe('Unique key for this refund — reuse it on retries'),
+            confirm: z.boolean().optional().describe('Set true (with quoteId) to send the transaction'),
+            quoteId: z.string().optional().describe('From the quote step'),
+        },
+        annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ task, idempotencyKey, confirm, quoteId }) => {
+        const f = await requireFunding();
+        if ('error' in f)
+            return f.error;
+        const { s, payFrom } = f;
+        const existing = getSpend(idempotencyKey);
+        if (existing)
+            return resumeRefund(existing, 'cancel');
+        let detail;
+        try {
+            detail = await loadTask(s, task);
+        }
+        catch (err) {
+            return fail(err.code ?? 'TASK_LOOKUP_FAILED', err.message);
+        }
+        const status = Number(detail.status);
+        if (status !== 0) {
+            const alt = status >= 1 && status <= 3
+                ? ' Use claim_timeout instead, once the deadline has passed.'
+                : ' The escrow is already settled — nothing to reclaim.';
+            return fail('WRONG_REFUND_PATH', `Task ${detail.taskId} is ${statusName(status)}, and cancelTask only accepts Funded tasks.${alt}`);
+        }
+        if (!confirm) {
+            const quote = createQuote('cancel', { taskId: detail.taskId });
+            return ok({
+                quote: {
+                    action: 'cancelTask',
+                    taskId: detail.taskId,
+                    status: statusName(status),
+                    refund: refundAmount(detail),
+                    refundTo: payFrom,
+                    settlement: s.mode,
+                    quoteId: quote.quoteId,
+                },
+                next: `Re-call cancel_task with confirm=true, quoteId="${quote.quoteId}", and the SAME idempotencyKey to send it.`,
+            });
+        }
+        if (!quoteId || !consumeQuote(quoteId, 'cancel')) {
+            return fail('QUOTE_REQUIRED', 'Get a quote first (call without confirm), then re-call with confirm=true and the returned quoteId (quotes are single-use and expire after 10 minutes)');
+        }
+        try {
+            const record = {
+                idempotencyKey,
+                kind: 'cancel',
+                stage: 'created',
+                settlement: s.mode,
+                taskId: Number(detail.taskId),
+                taskHash: detail.taskHash,
+                amountWei: detail.amount,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+            };
+            putSpend(record);
+            const done = await sendRefund(record);
+            return ok({ ...done, refunded: refundAmount(detail), hint: 'Escrow returned to the posting wallet.' });
+        }
+        catch (err) {
+            return fail(err.code ?? 'CANCEL_FAILED', err.message);
+        }
+    });
+    server.registerTool('claim_timeout', {
+        title: 'Reclaim Escrow After the Deadline',
+        description: 'Reclaim the escrow on a task that WAS assigned but never completed, once its deadline has passed (status Assigned, Submitted, or Verified-failed). For a task no worker ever picked up, use cancel_task instead — it needs no deadline. TWO-STEP quote/confirm; requires a unique idempotencyKey.',
+        inputSchema: {
+            task: z.string().min(1).describe('Task id (e.g. "51") or the 0x task hash returned by post_task'),
+            idempotencyKey: z.string().min(8).max(128).describe('Unique key for this refund — reuse it on retries'),
+            confirm: z.boolean().optional().describe('Set true (with quoteId) to send the transaction'),
+            quoteId: z.string().optional().describe('From the quote step'),
+        },
+        annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ task, idempotencyKey, confirm, quoteId }) => {
+        const f = await requireFunding();
+        if ('error' in f)
+            return f.error;
+        const { s, payFrom } = f;
+        const existing = getSpend(idempotencyKey);
+        if (existing)
+            return resumeRefund(existing, 'timeout');
+        let detail;
+        try {
+            detail = await loadTask(s, task);
+        }
+        catch (err) {
+            return fail(err.code ?? 'TASK_LOOKUP_FAILED', err.message);
+        }
+        const status = Number(detail.status);
+        if (status === 0) {
+            return fail('WRONG_REFUND_PATH', `Task ${detail.taskId} is Funded — claimTimeout reverts on Funded tasks because no worker was ever assigned. Use cancel_task, which works right now with no deadline wait.`);
+        }
+        if (status === 4 || status === 5) {
+            return fail('NOTHING_TO_REFUND', `Task ${detail.taskId} is ${statusName(status)} — the escrow is already settled.`);
+        }
+        const deadline = BigInt(detail.deadline);
+        const now = BigInt(Math.floor(Date.now() / 1000));
+        if (now < deadline) {
+            return fail('DEADLINE_NOT_REACHED', `Task ${detail.taskId} is still live until ${new Date(Number(deadline) * 1000).toISOString()} — claimTimeout reverts before then.`);
+        }
+        if (!confirm) {
+            const quote = createQuote('timeout', { taskId: detail.taskId });
+            return ok({
+                quote: {
+                    action: 'claimTimeout',
+                    taskId: detail.taskId,
+                    status: statusName(status),
+                    deadlinePassed: new Date(Number(deadline) * 1000).toISOString(),
+                    refund: refundAmount(detail),
+                    refundTo: payFrom,
+                    settlement: s.mode,
+                    // DISPUTE_WINDOW is enforced on-chain and disputedAt is not exposed
+                    // here, so a disputed task can still revert after this quote.
+                    ...(status === 6 ? { note: 'Task is Disputed — this only succeeds once the on-chain DISPUTE_WINDOW has elapsed since the dispute was raised, otherwise it reverts with DisputeWindowActive.' } : {}),
+                    quoteId: quote.quoteId,
+                },
+                next: `Re-call claim_timeout with confirm=true, quoteId="${quote.quoteId}", and the SAME idempotencyKey to send it.`,
+            });
+        }
+        if (!quoteId || !consumeQuote(quoteId, 'timeout')) {
+            return fail('QUOTE_REQUIRED', 'Get a quote first (call without confirm), then re-call with confirm=true and the returned quoteId (quotes are single-use and expire after 10 minutes)');
+        }
+        try {
+            const record = {
+                idempotencyKey,
+                kind: 'timeout',
+                stage: 'created',
+                settlement: s.mode,
+                taskId: Number(detail.taskId),
+                taskHash: detail.taskHash,
+                amountWei: detail.amount,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+            };
+            putSpend(record);
+            const done = await sendRefund(record);
+            return ok({ ...done, refunded: refundAmount(detail), hint: 'Escrow returned to the posting wallet.' });
+        }
+        catch (err) {
+            return fail(err.code ?? 'TIMEOUT_CLAIM_FAILED', err.message);
+        }
+    });
+    // ── Executor side (Base) ─────────────────────────────────────────────────
+    //
+    // accept_task (tools.ts) already assigns you on-chain: the backend awaits
+    // marketplaceAssign inside POST /accept. What was missing is everything
+    // after: the worker must sign submitEvidence itself (onlyWorker), and the
+    // platform worker (backend/agents/worker.js) only carries a 0G signer, so
+    // a Base task could be accepted but never delivered. These two tools close
+    // that gap for an MCP executor whose wallet is a Privy relay wallet — no
+    // local key, gas negotiated by the backend like every other relayed send.
+    /** Poll the escrow until the task reads `want`, or give up. */
+    async function waitStatus(s, taskId, want, label) {
+        let last = -1;
+        for (let i = 0; i < 30; i++) {
+            last = Number((await loadTask(s, taskId)).status);
+            if (last === want)
+                return last;
+            await new Promise((r) => setTimeout(r, 3000));
+        }
+        const e = new Error(`task ${taskId} still reads ${statusName(last)} after 90s waiting for ${label} — re-call complete_task to resume from the chain's state`);
+        e.code = 'STATE_PENDING';
+        throw e;
+    }
+    server.registerTool('fetch_brief', {
+        title: 'Fetch a Task Brief',
+        description: "Download a task's brief by rootHash (accept_task returns it). Public briefs come back as text. For a PRIVATE brief pass the wrappedKey accept_task returned: it is decrypted with BLINDMARKET_PRIVATE_KEY, which must be the key whose public half you registered (wallet_status shows it as executorPublicKey).",
+        inputSchema: {
+            rootHash: z.string().min(32).max(80).describe('rootHash from accept_task or list_open_tasks'),
+            wrappedKey: z.string().optional().describe('ECIES-wrapped AES key from accept_task (hex, no 0x). Required for private briefs.'),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async ({ rootHash, wrappedKey }) => {
+        try {
+            // Buffer.from(x, 'hex') stops silently at the first bad char, so a
+            // pasted "0x…" or a truncated blob would otherwise surface as
+            // WRONG_KEY after a storage round-trip. Validate first.
+            // ECIES blob = 65-byte ephemeral pubkey + 12 IV + 16 tag + ciphertext.
+            const keyHex = wrappedKey?.replace(/^0x/i, '');
+            if (keyHex !== undefined && (!/^[0-9a-fA-F]+$/.test(keyHex) || keyHex.length % 2 !== 0 || keyHex.length < (65 + 12 + 16 + 1) * 2)) {
+                return fail('INVALID_WRAPPED_KEY', 'wrappedKey must be the full hex ECIES blob from accept_task (even length, at least 94 bytes). Pass it exactly as returned.');
+            }
+            const { blob } = await api('GET', `/api/v1/storage/${encodeURIComponent(rootHash)}`);
+            const buf = Buffer.from(blob, 'base64');
+            if (keyHex !== undefined) {
+                if (!walletCtx) {
+                    return fail('NO_WALLET', 'A private brief is decrypted with BLINDMARKET_PRIVATE_KEY — set it to the key whose public half you registered as executor.');
+                }
+                let aesKey;
+                try {
+                    aesKey = eciesDecrypt(Buffer.from(keyHex, 'hex'), walletCtx.wallet.privateKey);
+                }
+                catch (e) {
+                    return fail('WRONG_KEY', `Could not unwrap the brief key with the local wallet ${walletCtx.wallet.address}: ${e.message}. The poster wrapped it to the pubkey on your executor registration — wallet_status shows the pubkey this process derives; they must match.`);
+                }
+                let brief;
+                try {
+                    brief = aesDecrypt(buf, aesKey).toString('utf8');
+                }
+                catch (e) {
+                    // The key unwrapped fine, so the BLOB is the problem: a public
+                    // (plaintext) brief passed with a wrappedKey, or the wrong rootHash.
+                    return fail('BRIEF_DECRYPT_FAILED', `The wrapped key unwrapped, but the blob at ${rootHash} did not decrypt with it: ${e.message}. If the task is public, call fetch_brief without wrappedKey; otherwise check the rootHash came from the same accept_task response.`);
+                }
+                return ok({ rootHash, bytes: buf.length, brief, decrypted: true });
+            }
+            const text = buf.toString('utf8');
+            if (text.includes('�')) {
+                return fail('ENCRYPTED_BRIEF', 'This brief is encrypted (private task). Re-call fetch_brief with the wrappedKey from accept_task.');
+            }
+            return ok({ rootHash, bytes: buf.length, brief: text });
+        }
+        catch (err) {
+            return fail(err.code ?? 'BRIEF_FETCH_FAILED', err.message);
+        }
+    });
+    server.registerTool('complete_task', {
+        title: 'Deliver a Task Result and Settle',
+        description: 'Executor side, after accept_task: submits your result, sends submitEvidence from YOUR wallet (Base: through the backend relay, gas in USDC; 0G: signed locally with BLINDMARKET_PRIVATE_KEY), then asks the backend to verify and release the escrow to you. This is the ONLY delivery tool — there is no separate submit step. If an earlier call died between submitting and broadcasting (task stuck "submitted" off-chain, Assigned on-chain), re-calling heals it via the /rebroadcast endpoint. If the last verification FAILED, calling this again resubmits — the contract allows up to 3 attempts before the deadline. Safe to re-call: it resumes from whatever stage the escrow shows.',
+        inputSchema: {
+            task: z.string().regex(/^0x[0-9a-fA-F]{64}$/).describe('The 0x task hash — A2A tasks are addressed by hash, not by numeric id'),
+            output: z.string().min(1).max(200_000).describe('Your result. Verification judges this text (auto mode scores it against the poster\'s criteria).'),
+        },
+        annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ task, output }) => {
+        const f = await requireFunding();
+        if ('error' in f)
+            return f.error;
+        const { s, payFrom } = f;
+        // requireFunding returns an error on 0G without a wallet, so walletCtx is
+        // non-null whenever s.mode is '0g' from here on.
+        let detail;
+        try {
+            detail = await loadTask(s, task);
+        }
+        catch (err) {
+            return fail(err.code ?? 'TASK_LOOKUP_FAILED', err.message);
+        }
+        // 0 Funded · 1 Assigned · 2 Submitted · 3 Verified · 4 Completed · 5 Cancelled · 6 Disputed
+        let status = Number(detail.status);
+        if (status === 0) {
+            return fail('NOT_ASSIGNED', `Task ${detail.taskId} is still Funded — call accept_task("${task}") first; the backend assigns you on-chain as part of accept.`);
+        }
+        // Verified(3) = the last round FAILED and the escrow is still locked. The
+        // contract lets the worker submitEvidence again from here, up to
+        // MAX_SUBMISSION_ATTEMPTS (3) and before the deadline. The backend's
+        // /submit enforces all three on-chain gates; check them here too so the
+        // caller gets the reason instead of a relayed revert.
+        const isRetry = status === 3;
+        // The contract reverts DeadlineReached from Assigned as well as from a
+        // retry. With an explicit gasLimit ethers skips estimateGas, so a
+        // predictable revert would be mined and charged — refuse it here.
+        if ((status === 1 || isRetry) && BigInt(Math.floor(Date.now() / 1000)) >= BigInt(detail.deadline)) {
+            return fail('DEADLINE_REACHED', `Task ${detail.taskId} is past its deadline — no further submissions are accepted on-chain. The poster can reclaim the escrow with claim_timeout.`);
+        }
+        if (isRetry) {
+            const attempts = detail.submissionAttempts ?? 0;
+            if (attempts >= 3) {
+                return fail('MAX_ATTEMPTS_REACHED', `Task ${detail.taskId} has used all 3 submission attempts (${attempts}/3). The escrow stays locked until the poster reclaims it after the deadline.`);
+            }
+        }
+        if (status >= 4) {
+            return ok({ taskId: detail.taskId, taskHash: detail.taskHash, onChainStatus: statusName(status), hint: 'Already settled — nothing to do.' });
+        }
+        let submitTxHash;
+        let gas;
+        let healed = false;
+        try {
+            if (status === 1 || isRetry) {
+                let sub;
+                try {
+                    sub = await api('POST', `/api/v1/a2a/tasks/${task}/submit`, { resultData: { output } });
+                }
+                catch (err) {
+                    // Stranded 'submitted': /submit flips the off-chain state when the
+                    // tx is BUILT, so an earlier call that died before broadcasting
+                    // leaves the chain at Assigned(1) while /submit refuses a rebuild.
+                    // /rebroadcast rebuilds the same tx from the stored result — the
+                    // FIRST output is what gets delivered, not this call's.
+                    if (err.code !== 'INVALID_STATE' || status !== 1)
+                        throw err;
+                    sub = await api('POST', `/api/v1/a2a/tasks/${task}/rebroadcast`);
+                    healed = true;
+                }
+                const tx = sub.unsignedSubmitEvidence;
+                await verifyTarget(s, tx.to, 'submitEvidence');
+                if (s.mode === 'base') {
+                    const sent = await relaySend(s, { to: tx.to, data: tx.data });
+                    submitTxHash = sent.hash;
+                    gas = sent.gas;
+                    await waitRelayed(s, sent.hash, sent.isUserOp);
+                }
+                else {
+                    // submitEvidence is onlyWorker: the backend built the tx for the
+                    // API key's wallet (tx.from). If BLINDMARKET_PRIVATE_KEY is a
+                    // different wallet the tx reverts on-chain — with gasLimit set,
+                    // that revert is mined and paid for. Refuse before sending.
+                    if (tx.from && tx.from.toLowerCase() !== walletCtx.wallet.address.toLowerCase()) {
+                        return fail('WALLET_MISMATCH', `The backend assigned this task to ${tx.from} (the wallet behind BLINDMARKET_API_KEY), but BLINDMARKET_PRIVATE_KEY is ${walletCtx.wallet.address}. submitEvidence is worker-only — set the private key of ${tx.from}.`);
+                    }
+                    // 0G: sign locally, exactly as fundAndIndex does for createTask.
+                    // The backend pins chainId onto the tx; ethers refuses to send it
+                    // if this wallet's provider is on a different network — the guard
+                    // against a Base tx reaching a 0G signer.
+                    const tx0g = await walletCtx.wallet.sendTransaction({
+                        to: tx.to, data: tx.data, gasLimit: GAS_LIMIT,
+                        ...(tx.chainId !== undefined ? { chainId: tx.chainId } : {}),
+                    });
+                    submitTxHash = tx0g.hash;
+                    await tx0g.wait();
+                }
+                status = await waitStatus(s, detail.taskId, 2, 'Submitted');
+            }
+            // Backend runs the verification for this task's mode and, on a pass,
+            // sends completeVerification from the marketplace signer — which is
+            // what releases the USDC to payFrom. The call awaits that tx.
+            const fin = await api('POST', `/api/v1/a2a/tasks/${task}/finalize`);
+            const after = await loadTask(s, detail.taskId);
+            const done = Number(after.status) === 4;
+            return ok({
+                taskId: detail.taskId,
+                taskHash: detail.taskHash,
+                submitTxHash,
+                gas,
+                ...(healed ? { rebroadcast: true, note: 'An earlier submission for this task never reached the chain; its stored result was re-broadcast. The output passed to THIS call was not used.' } : {}),
+                verification: fin.verificationResult ?? null,
+                backendStatus: fin.status,
+                onChainStatus: statusName(Number(after.status)),
+                paidTo: done ? payFrom : undefined,
+                submissionAttempts: after.submissionAttempts,
+                hint: done
+                    ? `Escrow released: ${formatUnits(BigInt(after.amount), after.decimals ?? 6)} ${s.mode === 'base' ? 'USDC' : '0G'} minus the marketplace fee is now in ${payFrom}.`
+                    : fin.awaitingPosterApproval
+                        ? 'Manual-verification task: the poster must approve via verify_task before the escrow releases.'
+                        : `Verification did not pass (${(fin.verificationResult?.reasons ?? []).join('; ') || 'no reasons given'}). ` +
+                            ((after.submissionAttempts ?? 0) < 3
+                                ? `Revise and call complete_task again — ${3 - (after.submissionAttempts ?? 0)} attempt(s) left before the deadline.`
+                                : 'No attempts left; the escrow stays locked until the poster reclaims it.'),
+            });
+        }
+        catch (err) {
+            return fail(err.code ?? 'COMPLETE_FAILED', err.message);
+        }
+    });
+    return { settlement };
 }
 //# sourceMappingURL=rent.js.map