@blindmarket/mcp-server 0.3.6 → 0.5.0

package/dist/rent.js

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-import { Contract, Interface, formatUnits, parseUnits } from 'ethers';
-import { aesDecrypt, aesEncrypt, eciesDecrypt, eciesEncrypt, generateAesKey, sha256Hex } from './crypto.js';
+import { Contract, Interface, JsonRpcProvider, formatUnits, parseUnits } from 'ethers';
+import { aesDecrypt, aesEncrypt, derivePublicKeyHex, eciesDecrypt, eciesEncrypt, generateAesKey, sha256Hex } from './crypto.js';
 import { createQuote, consumeQuote, getSpend, putSpend, updateSpend } from './state.js';
-import { createSettlementResolver } from './settlement.js';
+import { createSettlementResolver, isErc20Settlement, rpcFor, rpcEnvName, } 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.
@@ -93,10 +93,16 @@ export function registerRentTools(server, cfg, walletCtx) {
         }
         return json.data;
     }
-    const settlement = createSettlementResolver({ apiBase: cfg.apiBase ?? 'https://api.blindmarket.xyz', api });
+    const settlement = createSettlementResolver({
+        apiBase: cfg.apiBase ?? 'https://api.blindmarket.xyz',
+        api,
+        localWallet: walletCtx?.wallet.address,
+    });
     /** 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. */
+     *  On a relay chain (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. On an ERC-20 chain without a relay (Arc) discovery only
+     *  succeeds with the local wallet, already checked to be the key's owner. */
     async function requireFunding() {
         let s;
         try {
@@ -105,26 +111,62 @@ export function registerRentTools(server, cfg, walletCtx) {
         catch (err) {
             return { error: fail(err.code ?? 'SETTLEMENT_UNKNOWN', err.message) };
         }
-        if (s.mode === 'base')
+        if (isErc20Settlement(s))
             return { s, payFrom: s.payFrom };
         if (!walletCtx) {
             return { error: fail('NO_WALLET', 'Spending on 0G needs a local funding wallet — set BLINDMARKET_PRIVATE_KEY (see wallet_status)') };
         }
+        // The escrow address is compared before every send, but not the chain:
+        // a testnet backend's escrow address, paid on the mainnet RPC, is some
+        // other account there. A backend that names its 0G chain id settles it.
+        if (s.chainId !== undefined && walletCtx.chainId !== s.chainId) {
+            return {
+                error: fail('CHAIN_MISMATCH', `The backend settles 0G on chain ${s.chainId}, but BLINDMARKET_PRIVATE_KEY signs on chain ${walletCtx.chainId} (BLINDMARKET_RPC_URL / BLINDMARKET_CHAIN_ID). Native value sent there would not reach this backend's escrow. Point both at chain ${s.chainId}.`),
+            };
+        }
         return { s, payFrom: walletCtx.wallet.address };
     }
+    /** A new escrow is funded where POST /api/v1/tasks builds: the backend's
+     *  posting chain. A process forced onto another chain (to finish or refund
+     *  tasks already there) cannot post. Unknown on an older backend. */
+    async function notPostingChain(s) {
+        let posting = s.postingChain;
+        // Forced to 0G, discovery never asked the backend. Ask now, before a quote:
+        // a backend that posts elsewhere refuses the native-0G createTask only
+        // after the brief is uploaded and its hash claimed.
+        if (posting === undefined && s.mode === '0g') {
+            try {
+                const res = await fetch(`${cfg.apiBase}/health/settlement`, { signal: AbortSignal.timeout(15_000) });
+                const json = await res.json();
+                if (json?.success && typeof json.data?.postingChain === 'string')
+                    posting = json.data.postingChain;
+            }
+            catch { /* an older backend or a blip: keep the old behaviour, the escrow check still guards the send */ }
+        }
+        if (posting === undefined || s.mode === posting)
+            return null;
+        const e = new Error(`This process settles on ${s.mode} (BLINDMARKET_SETTLEMENT), but the backend posts new tasks on ${posting}, so a new escrow can only be funded there. Unset BLINDMARKET_SETTLEMENT (or set it to ${posting}) to post; ${s.mode} stays usable for tasks already on it.`);
+        e.code = 'NOT_POSTING_CHAIN';
+        return e;
+    }
     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);
+    function settlementToken(s) {
+        return new Contract(s.token.address, ERC20, s.provider);
+    }
+    /** The local wallet on a no-relay ERC-20 chain, over that chain's RPC
+     *  (checked at discovery to serve the chain the backend names). */
+    function localSigner(s) {
+        return walletCtx.wallet.connect(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)
+            const raw = isErc20Settlement(s)
+                ? await settlementToken(s).balanceOf(payFrom)
                 : await walletCtx.provider.getBalance(payFrom);
             return formatUnits(raw, s.decimals);
         }
@@ -136,19 +178,22 @@ export function registerRentTools(server, cfg, walletCtx) {
      *  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. */
+     *  relay chain's address on the 0G RPC, or a 0G refund is relayed onto
+     *  another chain. 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;
+        const expected = 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.'));
+                (s.escrowChains
+                    ? `This task is escrowed on another chain — set BLINDMARKET_SETTLEMENT to the chain that holds it (this backend has escrows on ${s.escrowChains.join(', ')}; 0G needs a local key), or use the web app.`
+                    : s.payment === 'relay-erc20'
+                        ? '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;
         }
@@ -191,6 +236,20 @@ export function registerRentTools(server, cfg, walletCtx) {
         // default it applies to this body: user-pays.
         return { hash: r.hash, isUserOp: r.isUserOp === true, gas: r.gas ?? 'user-pays' };
     }
+    /** Send a tx on an ERC-20 settlement: through the relay, or signed by the
+     *  local wallet on a chain the relay does not serve. Either way the caller
+     *  persists the hash before waiting (waitRelayed polls the chain's own RPC
+     *  for a plain hash, which a local send always is). `nonce` pins a local
+     *  send right after one this process made: an RPC can answer the next nonce
+     *  lookup from before the earlier tx landed. */
+    async function sendErc20(s, tx, nonce) {
+        if (s.payment === 'relay-erc20')
+            return relaySend(s, tx);
+        // No gasLimit: estimation runs first, so a predictable revert (a stale
+        // allowance, a passed deadline) fails here without being mined and paid for.
+        const sent = await localSigner(s).sendTransaction({ to: tx.to, data: tx.data, ...(nonce !== undefined ? { nonce } : {}) });
+        return { hash: sent.hash, isUserOp: false, nonce: sent.nonce };
+    }
     /** 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 —
@@ -202,7 +261,7 @@ export function registerRentTools(server, cfg, walletCtx) {
             const receipt = await s.provider.getTransactionReceipt(hash).catch(() => null);
             if (receipt) {
                 if (receipt.status === 0) {
-                    const e = new Error(`relayed tx ${hash} reverted`);
+                    const e = new Error(`tx ${hash} reverted`);
                     e.code = 'TX_REVERTED';
                     throw e;
                 }
@@ -210,21 +269,26 @@ export function registerRentTools(server, cfg, walletCtx) {
             }
             await new Promise((r) => setTimeout(r, 3000));
         }
-        const e = new Error(`relayed tx ${hash} not confirmed after 90s — retry with the same idempotencyKey to resume`);
+        const e = new Error(`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. */
+    /** ERC-20 chains: createTask pulls the token 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.
+     *  Returns the nonce the createTask should use when this call sent a local
+     *  approve, else undefined. */
     async function ensureAllowance(s, record) {
         const need = BigInt(record.amountWei);
-        const token = usdc(s);
+        const token = settlementToken(s);
         if ((await token.allowance(s.payFrom, s.escrowAddress)) >= need)
-            return;
+            return undefined;
+        let nextNonce;
         const approve = async () => {
             const data = ERC20.encodeFunctionData('approve', [s.escrowAddress, need]);
-            const { hash } = await relaySend(s, { to: s.usdcAddress, data });
+            const { hash, nonce } = await sendErc20(s, { to: s.token.address, data });
+            if (nonce !== undefined)
+                nextNonce = nonce + 1;
             // Persist BEFORE waiting: a crash here must resume into the poll below.
             updateSpend(record.idempotencyKey, { stage: 'approved', approveTxHash: hash });
             record.stage = 'approved';
@@ -241,47 +305,53 @@ export function registerRentTools(server, cfg, walletCtx) {
         if (record.stage === 'created') {
             await approve();
             if (await settled())
-                return;
+                return nextNonce;
         }
         // 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;
+            return nextNonce;
         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`);
+            return nextNonce;
+        const e = new Error(`${s.symbol} allowance still below ${formatUnits(need, s.decimals)} after two approves (last ${record.approveTxHash}) — check ${s.payFrom}'s ${s.symbol} 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.
      *
-     *  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. */
+     *  Two funding paths, chosen by `payment`:
+     *    local-native — native 0G from the local wallet, signed and sent here.
+     *    relay-erc20  — the ERC-20 (USDC on Base) 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 s = await settlement();
         let { txHash } = record;
-        // 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;
-        }
+        // Nothing left to sign once the escrow is funded: /a2a/tasks/index finds
+        // the receipt on whichever chain holds it. So a funded spend finishes
+        // even when settlement cannot be discovered right now, or has moved.
         if (record.stage === 'created' || record.stage === 'approved') {
-            if (s.mode === 'base')
-                await ensureAllowance(s, record);
-            const { unsignedTx } = await api('POST', '/api/v1/tasks', {
+            const s = await settlement();
+            // 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 this process now settles on ${s.mode}. ` +
+                    `Nothing was funded yet (stage ${record.stage}): start a new spend with a new idempotencyKey, or set BLINDMARKET_SETTLEMENT=${record.settlement} to finish this one.`);
+                e.code = 'SETTLEMENT_CHANGED';
+                throw e;
+            }
+            const refused = await notPostingChain(s);
+            if (refused)
+                throw refused;
+            const nonce = isErc20Settlement(s) ? await ensureAllowance(s, record) : undefined;
+            const { unsignedTx, chain: builtChain, chainId: builtChainId } = await api('POST', '/api/v1/tasks', {
                 taskHash: record.taskHash,
-                token: s.mode === 'base' ? s.usdcAddress : ZERO_TOKEN,
+                token: isErc20Settlement(s) ? s.token.address : ZERO_TOKEN,
                 amount: record.amountWei,
                 locationZone: 'global',
                 duration: String(record.durationSecs ?? 3600),
@@ -292,11 +362,20 @@ export function registerRentTools(server, cfg, walletCtx) {
                 rootHash: record.rootHash,
                 wrappedKeys: record.privacy === 'public' ? undefined : record.wrappedKeys,
             });
-            // Either branch: the tx must target the escrow this mode expects. On
-            // Base that is also the escrow the allowance above was granted to.
+            // Either branch: the tx must target the escrow this mode expects. On a
+            // relay chain that is also the escrow the allowance above was granted to.
+            // A chain-aware backend also names the chain it built for (older ones
+            // return only the tx, and are checked by address alone, as before).
+            if (s.postingChain !== undefined && ((builtChain !== undefined && builtChain !== s.mode) ||
+                (builtChainId !== undefined && s.chainId !== undefined && Number(builtChainId) !== s.chainId))) {
+                settlement.invalidate();
+                const e = new Error(`backend built createTask for ${builtChain ?? '?'} (chain ${builtChainId ?? '?'}) but this process settles on ${s.mode} (chain ${s.chainId ?? '?'}) — re-run and discovery will re-check`);
+                e.code = 'ESCROW_MISMATCH';
+                throw e;
+            }
             await verifyTarget(s, unsignedTx.to, 'createTask');
-            if (s.mode === 'base') {
-                const { hash, isUserOp, gas } = await relaySend(s, { to: unsignedTx.to, data: unsignedTx.data });
+            if (isErc20Settlement(s)) {
+                const { hash, isUserOp, gas } = await sendErc20(s, { to: unsignedTx.to, data: unsignedTx.data }, nonce);
                 // Persist BEFORE waiting, same reasoning as the 0G branch below.
                 updateSpend(record.idempotencyKey, { stage: 'funded', txHash: hash, isUserOp, gas });
                 record.gas = gas;
@@ -310,6 +389,8 @@ export function registerRentTools(server, cfg, walletCtx) {
                     data: unsignedTx.data,
                     value: BigInt(record.amountWei),
                     gasLimit: GAS_LIMIT,
+                    // ethers refuses to send when its provider is on another chain.
+                    ...(s.chainId !== undefined ? { chainId: s.chainId } : {}),
                 });
                 // 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.
@@ -361,7 +442,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, 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).',
+        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 paid on the backend\'s posting chain: USDC on Arc signed by the local wallet (BLINDMARKET_PRIVATE_KEY, which must own BLINDMARKET_API_KEY; gas is also USDC), USDC on Base through the backend relay (no private key needed), or native 0G from the local wallet. wallet_status shows which. 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'),
@@ -373,11 +454,8 @@ export function registerRentTools(server, cfg, walletCtx) {
         },
         annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async ({ serviceId, prompt, idempotencyKey, privacy, confirm, quoteId, waitSeconds }) => {
-        const f = await requireFunding();
-        if ('error' in f)
-            return f.error;
-        const { s, payFrom } = f;
-        // Resume path — this key already spent (or partially spent).
+        // Resume path — this key already spent (or partially spent). Checked
+        // before settlement: a funded spend finishes without it.
         const existing = getSpend(idempotencyKey);
         if (existing) {
             if (existing.stage === 'indexed') {
@@ -393,6 +471,13 @@ export function registerRentTools(server, cfg, walletCtx) {
                 return fail(err.code ?? 'RESUME_FAILED', err.message);
             }
         }
+        const f = await requireFunding();
+        if ('error' in f)
+            return f.error;
+        const { s, payFrom } = f;
+        const offPosting = await notPostingChain(s);
+        if (offPosting)
+            return fail(offPosting.code, offPosting.message);
         const service = await api('GET', `/api/v1/marketplace/services/${serviceId}`);
         const isPublic = privacy === 'public';
         if (!isPublic && !service.agent_public_key) {
@@ -405,10 +490,10 @@ export function registerRentTools(server, cfg, walletCtx) {
         // 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
+        // older backend may still serve one. 1,000,000 tokens 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.`);
+        if (s.decimals < 18 && priceRaw > 1000000n * 10n ** BigInt(s.decimals)) {
+            return fail('PRICE_UNITS_SUSPECT', `service ${serviceId} lists price_raw=${priceRaw} which is ${formatUnits(priceRaw, s.decimals)} ${s.symbol} — this looks like an 18-decimal 0G price on a ${s.symbol} chain. Not sending. Re-list the service in ${s.symbol} base units.`);
         }
         const price = formatUnits(priceRaw, s.decimals);
         if (!confirm) {
@@ -467,7 +552,7 @@ export function registerRentTools(server, cfg, walletCtx) {
                 requiredCapabilities: [],
                 amountWei: String(service.price_raw),
                 settlement: s.mode,
-                token: s.mode === 'base' ? s.usdcAddress : ZERO_TOKEN,
+                token: isErc20Settlement(s) ? s.token.address : ZERO_TOKEN,
                 durationSecs: 3600,
                 createdAt: new Date().toISOString(),
                 updatedAt: new Date().toISOString(),
@@ -480,7 +565,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 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, 'The API key\'s owner wallet does not match the wallet that funded escrow. When this process signs (0G, Arc), mint an sk_ key while signed in with the BLINDMARKET_PRIVATE_KEY wallet; on a relay chain (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);
         }
@@ -488,7 +573,7 @@ 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. 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.',
+        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 paid on the backend\'s posting chain: USDC on Arc signed by the local wallet (BLINDMARKET_PRIVATE_KEY, which must own BLINDMARKET_API_KEY; gas is also USDC), USDC on Base through the backend relay (no private key needed), or native 0G from the local wallet. wallet_status shows which. TWO-STEP quote/confirm like rent_service; requires a unique idempotencyKey.',
         inputSchema: {
             instructions: z.string().min(1).max(100_000).describe('The task brief'),
             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'),
@@ -502,10 +587,7 @@ export function registerRentTools(server, cfg, walletCtx) {
         },
         annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, 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;
+        // Checked before settlement: a funded spend finishes without it.
         const existing = getSpend(idempotencyKey);
         if (existing) {
             if (existing.stage === 'indexed') {
@@ -518,6 +600,13 @@ export function registerRentTools(server, cfg, walletCtx) {
                 return fail(err.code ?? 'RESUME_FAILED', err.message);
             }
         }
+        const f = await requireFunding();
+        if ('error' in f)
+            return f.error;
+        const { s, payFrom } = f;
+        const offPosting = await notPostingChain(s);
+        if (offPosting)
+            return fail(offPosting.code, offPosting.message);
         const isPublic = privacy === 'public';
         const amountStr = amount ?? amount0G;
         if (!amountStr) {
@@ -595,7 +684,7 @@ export function registerRentTools(server, cfg, walletCtx) {
                 requiredCapabilities: capabilities ?? [],
                 amountWei: amountWei.toString(),
                 settlement: s.mode,
-                token: s.mode === 'base' ? s.usdcAddress : ZERO_TOKEN,
+                token: isErc20Settlement(s) ? s.token.address : ZERO_TOKEN,
                 durationSecs: durationSeconds ?? 86400,
                 createdAt: new Date().toISOString(),
                 updatedAt: new Date().toISOString(),
@@ -607,7 +696,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 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, 'The API key\'s owner wallet does not match the wallet that funded escrow. When this process signs (0G, Arc), mint an sk_ key while signed in with the BLINDMARKET_PRIVATE_KEY wallet; on a relay chain (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);
         }
@@ -643,7 +732,8 @@ export function registerRentTools(server, cfg, walletCtx) {
     //
     // 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
+    // decides who signs — the local wallet on 0G, the Privy relay on a relay
+    // chain (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.
@@ -653,32 +743,55 @@ export function registerRentTools(server, cfg, walletCtx) {
     }
     /** 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. */
+     *  GET /api/v1/tasks/:id accepts either form — but older backends read the
+     *  0G escrow only (escrowService.getTask was bound to the 0G contract), so
+     *  on a relay chain its struct is for whatever 0G task happens to share the
+     *  id. On a relay chain we use it just to turn a hash into an id, then read
+     *  the struct from that chain's escrow ourselves over the read-only
+     *  provider. */
     async function loadTask(s, task) {
-        if (s.mode !== 'base') {
-            return api('GET', `/api/v1/tasks/${encodeURIComponent(task)}`);
+        /** The backend said the task is on another chain: its id means a different task here. */
+        const onOtherChain = (taskId, chain) => {
+            const label = s.chain === 'base' ? 'Base' : s.chain;
+            const e = new Error(`task ${taskId} is a ${chain} task, and this process settles on ${label} — handle it with BLINDMARKET_SETTLEMENT=${chain}`);
+            // The code names the chain; on Base it is the TASK_NOT_ON_BASE it always was.
+            e.code = `TASK_NOT_ON_${s.chain.toUpperCase().replace(/-/g, '_')}`;
+            return e;
+        };
+        if (!isErc20Settlement(s)) {
+            const detail = await api('GET', `/api/v1/tasks/${encodeURIComponent(task)}`);
+            if (detail.chain && detail.chain !== s.chain)
+                throw onOtherChain(detail.taskId, detail.chain);
+            return detail;
         }
-        // Base: the escrow is the authority, and we can read it directly. Only ask
+        // Relay chain: 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;
+        let backendChain;
         if (/^\d+$/.test(task)) {
             taskId = task;
         }
         else {
             const viaBackend = await api('GET', `/api/v1/tasks/${encodeURIComponent(task)}`);
             taskId = viaBackend.taskId;
+            backendChain = viaBackend.chain;
+            // The same id can exist on this chain's escrow too (another task of the
+            // same poster): reading it would act on the wrong task.
+            if (backendChain && backendChain !== s.chain)
+                throw onOtherChain(taskId, backendChain);
         }
         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';
+            const label = s.chain === 'base' ? 'Base' : s.chain;
+            const hint = s.escrowChains
+                ? `it is on another chain; set BLINDMARKET_SETTLEMENT to the one that holds it (this backend has escrows on ${s.escrowChains.join(', ')})`
+                : 'it is probably a 0G task; handle it with BLINDMARKET_SETTLEMENT=0g';
+            const e = new Error(`task ${taskId} does not exist on the ${label} escrow ${s.escrowAddress} — ${hint}`);
+            // The code names the chain; on Base it is the TASK_NOT_ON_BASE it always was.
+            e.code = `TASK_NOT_ON_${s.chain.toUpperCase().replace(/-/g, '_')}`;
             throw e;
         }
         return {
@@ -692,8 +805,8 @@ export function registerRentTools(server, cfg, walletCtx) {
             decimals: s.decimals,
         };
     }
-    /** Amount formatted against the task's OWN decimals — a Base task settles in
-     *  USDC (6), not the wallet's native 18. */
+    /** Amount formatted against the task's OWN decimals — a relay-chain task
+     *  settles in its ERC-20 (USDC: 6), not the wallet's native 18. */
     function refundAmount(detail) {
         return formatUnits(BigInt(detail.amount), detail.decimals ?? 18);
     }
@@ -714,7 +827,7 @@ export function registerRentTools(server, cfg, walletCtx) {
     }
     /** 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.
+     *  Same two paths as fundAndIndex: local wallet on 0G, Privy relay on a relay chain.
      *  The backend resolves which chain holds the task and builds the tx for
      *  it; this only decides who signs. */
     async function sendRefund(record) {
@@ -722,20 +835,22 @@ export function registerRentTools(server, cfg, walletCtx) {
         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`);
+            const e = new Error(`refund ${record.idempotencyKey} started on ${record.settlement} but this process now settles on ${s.mode} — set BLINDMARKET_SETTLEMENT=${record.settlement} to finish it, or 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}`);
+            // Task ids repeat across chains: name this one (the backend knows
+            // 'base' and 'arc'; a 0G task is resolved by ownership as before).
+            const { unsignedTx } = await api('POST', `/api/v1/tasks/${taskId}/${route}`, isErc20Settlement(s) ? { chain: s.mode } : undefined);
             // 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.
+            // broadcasts on, stop here — relaying a 0G refund onto another chain
+            // 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 });
+            if (isErc20Settlement(s)) {
+                const { hash, isUserOp, gas } = await sendErc20(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;
@@ -748,6 +863,7 @@ export function registerRentTools(server, cfg, walletCtx) {
                     to: unsignedTx.to,
                     data: unsignedTx.data,
                     gasLimit: GAS_LIMIT,
+                    ...(s.chainId !== undefined ? { chainId: s.chainId } : {}),
                 });
                 // Persist the hash BEFORE waiting, same reasoning as fundAndIndex: a
                 // crash mid-confirmation must resume onto THIS tx, not broadcast another.
@@ -757,7 +873,7 @@ export function registerRentTools(server, cfg, walletCtx) {
             }
         }
         else if (txHash) {
-            if (s.mode === 'base')
+            if (isErc20Settlement(s))
                 await waitRelayed(s, txHash, record.isUserOp ?? false);
             else
                 await walletCtx.provider.waitForTransaction(txHash);
@@ -767,7 +883,28 @@ export function registerRentTools(server, cfg, walletCtx) {
         }
         await waitCancelled(s, taskId);
         updateSpend(record.idempotencyKey, { stage: 'confirmed' });
-        return { taskId, txHash: txHash, gas: record.gas };
+        return { taskId, txHash: txHash, gas: record.gas, listingClosed: await confirmRefund(s, taskId, txHash, record.isUserOp ?? false) };
+    }
+    /** Tell the backend the refund landed (POST /tasks/:id/confirm-tx): it
+     *  checks the receipt and takes the task off the market, which otherwise
+     *  keeps listing it as open until its deadline. Best effort, since the
+     *  money has already moved. A relayed user-op hash has no receipt to check. */
+    async function confirmRefund(s, taskId, txHash, isUserOp) {
+        if (isUserOp)
+            return false;
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            try {
+                await api('POST', `/api/v1/tasks/${taskId}/confirm-tx`, { txHash, ...(isErc20Settlement(s) ? { chain: s.mode } : {}) });
+                return true;
+            }
+            catch (err) {
+                // The backend's RPC can lag the receipt this side just saw.
+                if (err.code !== 'NOT_CONFIRMED' || attempt === 3)
+                    return false;
+                await new Promise((r) => setTimeout(r, 3000));
+            }
+        }
+        return false;
     }
     /** Shared resume arm: an idempotencyKey that has already moved. The kind
      *  guard matters — the ledger is one namespace shared with rent/post, and
@@ -1029,7 +1166,7 @@ export function registerRentTools(server, cfg, walletCtx) {
             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.
+        // non-null whenever s.payment is 'local-native' from here on.
         let detail;
         try {
             detail = await loadTask(s, task);
@@ -1085,12 +1222,22 @@ export function registerRentTools(server, cfg, walletCtx) {
                 }
                 const tx = sub.unsignedSubmitEvidence;
                 await verifyTarget(s, tx.to, 'submitEvidence');
-                if (s.mode === 'base') {
+                if (s.payment === 'relay-erc20') {
                     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 if (s.payment === 'local-erc20') {
+                    // Signed locally over this chain's RPC, like the 0G branch below
+                    // but with gas estimated: a revert fails here, unpaid.
+                    if (tx.from && tx.from.toLowerCase() !== s.payFrom.toLowerCase()) {
+                        return fail('WALLET_MISMATCH', `The backend assigned this task to ${tx.from} (the wallet behind BLINDMARKET_API_KEY), but BLINDMARKET_PRIVATE_KEY is ${s.payFrom}. submitEvidence is worker-only — set the private key of ${tx.from}.`);
+                    }
+                    const sent = await sendErc20(s, { to: tx.to, data: tx.data });
+                    submitTxHash = sent.hash;
+                    await waitRelayed(s, sent.hash, false);
+                }
                 else {
                     // submitEvidence is onlyWorker: the backend built the tx for the
                     // API key's wallet (tx.from). If BLINDMARKET_PRIVATE_KEY is a
@@ -1130,7 +1277,7 @@ export function registerRentTools(server, cfg, walletCtx) {
                 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}.`
+                    ? `Escrow released: ${formatUnits(BigInt(after.amount), after.decimals ?? s.decimals)} ${s.symbol} 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'}). ` +
@@ -1143,6 +1290,215 @@ export function registerRentTools(server, cfg, walletCtx) {
             return fail(err.code ?? 'COMPLETE_FAILED', err.message);
         }
     });
+    // ── deploy_agent ──────────────────────────────────────────────────────────
+    /** The env var each provider's API key is read from, so the key never passes through the conversation. */
+    const PROVIDER_KEY_ENV = {
+        openai: 'OPENAI_API_KEY',
+        anthropic: 'ANTHROPIC_API_KEY',
+        groq: 'GROQ_API_KEY',
+        gemini: 'GEMINI_API_KEY',
+    };
+    const coded = (code, message) => Object.assign(new Error(message), { code });
+    /** The local wallet on `chain`, over BLINDMARKET_<CHAIN>_RPC_URL (else a
+     *  public RPC for that chain id), checked against the chain id the backend
+     *  names, and against `expectChainId` (the fee terms') when given. */
+    async function walletOn(chain, expectChainId) {
+        const res = await fetch(`${cfg.apiBase}/health/bridge`, { signal: AbortSignal.timeout(30_000) });
+        const bridge = await res.json().catch(() => ({}));
+        const entry = (bridge?.data ?? bridge)?.chains?.find((c) => c.chain === chain);
+        const chainId = Number(entry?.chainId);
+        if (!Number.isInteger(chainId) || chainId <= 0)
+            throw coded('SETTLEMENT_UNKNOWN', `The backend lists no chain id for ${chain}.`);
+        if (expectChainId !== undefined && expectChainId !== chainId) {
+            throw coded('SETTLEMENT_UNKNOWN', `The deploy fee is on chain ${expectChainId} but the backend lists ${chain} as chain ${chainId}. Nothing was paid.`);
+        }
+        const envName = rpcEnvName(chain);
+        const rpcUrl = rpcFor(chain, chainId, process.env);
+        if (!rpcUrl)
+            throw coded('RPC_UNKNOWN', `No RPC known for ${chain} (chainId ${chainId}) — set ${envName}.`);
+        const provider = new JsonRpcProvider(rpcUrl, chainId, { staticNetwork: true });
+        const served = Number(BigInt(await provider.send('eth_chainId', [])));
+        if (served !== chainId)
+            throw coded('WRONG_RPC', `${envName} serves chain ${served}, not ${chain} (${chainId}). Nothing was paid.`);
+        return walletCtx.wallet.connect(provider);
+    }
+    server.registerTool('deploy_agent', {
+        title: 'Deploy a Hosted Agent',
+        description: "Deploy a hosted agent that runs on BlindMarket and takes tasks, owned by the API key's wallet. Deploying costs a fee (1 USDC on Arc on production), paid as one USDC transfer on Arc from the local wallet (BLINDMARKET_PRIVATE_KEY), which must be the API key's owner. The model provider's key is read from this server's environment (OPENAI_API_KEY, ANTHROPIC_API_KEY, GROQ_API_KEY or GEMINI_API_KEY; none for 0g-compute), never passed as an argument. TWO-STEP quote/confirm like post_task; requires a unique idempotencyKey, and a retry with the same key never pays twice.",
+        inputSchema: {
+            name: z.string().min(1).max(80).describe('Agent name'),
+            instructions: z.string().min(1).max(100_000).describe("The agent's instructions: what it does and how"),
+            provider: z.enum(['openai', 'anthropic', 'groq', 'gemini', '0g-compute']).describe("LLM provider. '0g-compute' needs no API key: inference is billed to the agent's own wallet"),
+            model: z.string().min(1).describe('Model id, e.g. gpt-4o-mini or claude-sonnet-4-5'),
+            skillSlugs: z.array(z.string()).max(10).optional().describe('Public skills to install at deploy, by slug'),
+            idempotencyKey: z.string().min(8).max(128).describe('Unique key for this deploy — reuse it on retries'),
+            confirm: z.boolean().optional().describe('Set true (with quoteId) to pay the fee and deploy'),
+            quoteId: z.string().optional().describe('From the quote step'),
+        },
+        annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ name, instructions, provider, model, skillSlugs, idempotencyKey, confirm, quoteId }) => {
+        if (!walletCtx) {
+            return fail('NO_WALLET', 'deploy_agent pays the fee from, and encrypts the agent key to, the local wallet — set BLINDMARKET_PRIVATE_KEY to the key of the wallet that owns BLINDMARKET_API_KEY.');
+        }
+        let apiKey = '';
+        if (provider !== '0g-compute') {
+            const envName = PROVIDER_KEY_ENV[provider];
+            apiKey = process.env[envName] ?? '';
+            if (!apiKey)
+                return fail('PROVIDER_KEY_MISSING', `Set ${envName} in this server's environment: the agent calls ${provider} with it. It is read there so it never passes through the conversation.`);
+        }
+        const body = {
+            name, instructions, provider, model, apiKey,
+            capabilities: [],
+            skillSlugs: skillSlugs ?? [],
+            // The agent's private key is encrypted to the local wallet's key.
+            ownerPublicKey: derivePublicKeyHex(walletCtx.wallet.privateKey),
+        };
+        const summary = (a) => ({ agentId: a.id, name: a.name, walletAddress: a.walletAddress, started: a.started === true });
+        /** POST /agents/deploy, asking again while the backend has not seen the fee confirm. */
+        const deploy = async (feeTxHash) => {
+            for (let attempt = 1;; attempt++) {
+                try {
+                    return await api('POST', '/api/v1/agents/deploy', feeTxHash ? { ...body, feeTxHash } : body);
+                }
+                catch (err) {
+                    if (err.code !== 'DEPLOY_FEE_NOT_FOUND' || attempt >= 3)
+                        throw err;
+                    await new Promise((r) => setTimeout(r, Number(process.env.BLINDMARKET_DEPLOY_POLL_MS ?? 5000)));
+                }
+            }
+        };
+        /** The deploy's own checks, run before anything is quoted or paid. A
+         *  backend without the route (404) is not checked here; the deploy
+         *  still checks before it takes the fee. */
+        const validate = async () => {
+            try {
+                await api('POST', '/api/v1/agents/deploy/validate', body);
+                return null;
+            }
+            catch (err) {
+                const code = err.code;
+                if (code === undefined && /failed: 404$/.test(err.message))
+                    return null;
+                return fail(code ?? 'DEPLOY_INVALID', `${err.message}. Nothing was paid.`);
+            }
+        };
+        const paidNote = () => {
+            const rec = getSpend(idempotencyKey);
+            return rec?.stage === 'sent' && rec.txHash
+                ? ` The fee is paid (${rec.txHash}): retry with the SAME idempotencyKey to deploy without paying again.`
+                : '';
+        };
+        const existing = getSpend(idempotencyKey);
+        if (existing && existing.kind !== 'deploy') {
+            return fail('IDEMPOTENCY_KEY_IN_USE', `idempotencyKey ${idempotencyKey} belongs to a ${existing.kind} spend — use a new key for this deploy.`);
+        }
+        if (existing?.stage === 'confirmed') {
+            return ok({ resumed: true, agentId: existing.agentId, feeTxHash: existing.txHash, hint: 'Already deployed with this idempotencyKey.' });
+        }
+        if (existing?.stage === 'sent' && existing.txHash) {
+            // Paid before: finish the deploy with that payment.
+            try {
+                const agent = await deploy(existing.txHash);
+                updateSpend(idempotencyKey, { stage: 'confirmed', agentId: agent.id });
+                return ok({ resumed: true, ...summary(agent), feeTxHash: existing.txHash });
+            }
+            catch (err) {
+                return fail(err.code ?? 'DEPLOY_FAILED', `${err.message}.${paidNote()}`);
+            }
+        }
+        let terms;
+        try {
+            terms = await api('GET', '/api/v1/agents/deploy-fee');
+        }
+        catch (err) {
+            return fail(err.code ?? 'DEPLOY_FEE_UNKNOWN', err.message);
+        }
+        if (terms.required && terms.method !== 'transfer') {
+            return fail('UNSUPPORTED_FEE_METHOD', 'This backend takes the deploy fee through AgentFactory only, which this server does not pay. Deploy from the web app.');
+        }
+        const fee = terms.required ? terms : null;
+        const feeText = fee ? `${formatUnits(BigInt(fee.amountRaw), fee.decimals).replace(/\.0$/, '')} USDC` : 'none';
+        if (!confirm) {
+            const invalid = await validate();
+            if (invalid)
+                return invalid;
+            let walletBalance;
+            if (fee) {
+                try {
+                    const w = await walletOn(fee.chain, fee.chainId);
+                    const bal = await new Contract(fee.token, ['function balanceOf(address) view returns (uint256)'], w).balanceOf(w.address);
+                    walletBalance = formatUnits(bal, fee.decimals);
+                }
+                catch (err) {
+                    if (['RPC_UNKNOWN', 'WRONG_RPC', 'SETTLEMENT_UNKNOWN'].includes(err.code ?? '')) {
+                        return fail(err.code, err.message);
+                    }
+                }
+            }
+            const quote = createQuote('deploy', { name, provider, model, fee: feeText });
+            return ok({
+                quote: {
+                    agent: { name, provider, model, skills: skillSlugs ?? [] },
+                    fee: feeText,
+                    chain: fee?.chain,
+                    payTo: fee?.recipient,
+                    payFrom: walletCtx.wallet.address,
+                    walletBalance,
+                    quoteId: quote.quoteId,
+                },
+                next: `Re-call deploy_agent with confirm=true, quoteId="${quote.quoteId}", and the SAME idempotencyKey to ${fee ? 'pay the fee and ' : ''}deploy.`,
+            });
+        }
+        if (!quoteId || !consumeQuote(quoteId, 'deploy')) {
+            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 now = new Date().toISOString();
+            let feeTxHash;
+            if (fee) {
+                // The backend counts a fee only from the API key's owner: check before paying.
+                const { address: owner } = await api('GET', '/api/v1/api-keys/whoami');
+                if (String(owner).toLowerCase() !== walletCtx.wallet.address.toLowerCase()) {
+                    return fail('OWNER_MISMATCH', `BLINDMARKET_API_KEY belongs to ${owner} but BLINDMARKET_PRIVATE_KEY is ${walletCtx.wallet.address}. Nothing was paid: the backend counts a deploy fee only from the API key's owner.`);
+                }
+                const invalid = await validate();
+                if (invalid)
+                    return invalid;
+                const w = await walletOn(fee.chain, fee.chainId);
+                putSpend({ idempotencyKey, kind: 'deploy', stage: 'created', settlement: fee.chain, token: fee.token, amountWei: fee.amountRaw, createdAt: now, updatedAt: now });
+                const data = new Interface(['function transfer(address to, uint256 amount) returns (bool)'])
+                    .encodeFunctionData('transfer', [fee.recipient, BigInt(fee.amountRaw)]);
+                const tx = await w.sendTransaction({ to: fee.token, data });
+                // Recorded the moment it is broadcast: a retry resumes from here and never pays twice.
+                updateSpend(idempotencyKey, { stage: 'sent', txHash: tx.hash });
+                try {
+                    await tx.wait();
+                }
+                catch (err) {
+                    if (err.code === 'CALL_EXCEPTION') {
+                        updateSpend(idempotencyKey, { stage: 'created', txHash: undefined });
+                        return fail('FEE_REVERTED', `The fee transfer ${tx.hash} reverted, so nothing was paid. Check the wallet's USDC on ${fee.chain} and retry.`);
+                    }
+                    // Not confirmed yet: the backend waits for the receipt itself.
+                }
+                feeTxHash = tx.hash;
+            }
+            else {
+                putSpend({ idempotencyKey, kind: 'deploy', stage: 'created', createdAt: now, updatedAt: now });
+            }
+            const agent = await deploy(feeTxHash);
+            updateSpend(idempotencyKey, { stage: 'confirmed', agentId: agent.id });
+            return ok({
+                ...summary(agent),
+                feeTxHash,
+                hint: agent.started ? 'The agent is running.' : 'The agent was created but did not start — start it with start_agent.',
+            });
+        }
+        catch (err) {
+            return fail(err.code ?? 'DEPLOY_FAILED', `${err.message}.${paidNote()}`);
+        }
+    });
     return { settlement };
 }
 //# sourceMappingURL=rent.js.map