perp-cli 0.12.17 → 0.14.1

package/dist/exchanges/arcus/spot-chain.js

@@ -0,0 +1,241 @@
+/**
+ * Robinhood Chain reads/txs for Arcus spot (design §12.4 #7), over
+ * `VenueNetworkConfig.rpcUrl` with ethers.
+ *
+ * Permit2 allowance logic ported from @arcus-xyz/arcus-spot-sdk@1.0.2
+ * (src/permits.ts) — Copyright Arcus, Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0). Changes: viem → ethers; the
+ * SDK's last-resort EIP-2612 domain guess (`version() ?? "1"` without a
+ * DOMAIN_SEPARATOR match) is replaced by an error (SSOT Rule #2).
+ */
+import { AbiCoder, Interface, JsonRpcProvider, Network, Signature, Transaction, keccak256, toUtf8Bytes } from "ethers";
+import { PerpError, orderOutcomeUnknown, sendFailure } from "../../errors.js";
+import { MULTICALL3_ADDRESS, PERMIT2_ADDRESS } from "./spot-router.js";
+/** Approve receipt wait. */
+export const ARCUS_APPROVE_RECEIPT_TIMEOUT_MS = 120_000;
+/** Gas-limit headroom over eth_estimateGas for the approve tx (also used for the ETH balance check). */
+const APPROVE_GAS_HEADROOM_PCT = 20n;
+/** Multicall3 aggregate3 batch size. */
+const MULTICALL_BATCH = 150;
+export const MAX_UINT256 = (1n << 256n) - 1n;
+const erc20 = new Interface([
+    "function balanceOf(address) view returns (uint256)",
+    "function allowance(address owner, address spender) view returns (uint256)",
+    "function approve(address spender, uint256 amount) returns (bool)",
+    "function name() view returns (string)",
+    "function version() view returns (string)",
+    "function nonces(address owner) view returns (uint256)",
+    "function DOMAIN_SEPARATOR() view returns (bytes32)",
+    "function eip712Domain() view returns (bytes1 fields, string name, string version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] extensions)",
+    "event Transfer(address indexed from, address indexed to, uint256 value)",
+]);
+const multicall3 = new Interface([
+    "function aggregate3((address target, bool allowFailure, bytes callData)[] calls) payable returns ((bool success, bytes returnData)[] returnData)",
+]);
+const TRANSFER_TOPIC = erc20.getEvent("Transfer").topicHash;
+const EIP712_DOMAIN_TYPEHASH = keccak256(toUtf8Bytes("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"));
+/** ethers error shapes that mean "the contract reverted / returned nothing" (vs. transport failure). */
+function isContractRevert(e) {
+    const code = e?.code;
+    return code === "CALL_EXCEPTION" || code === "BAD_DATA";
+}
+export class ArcusSpotChain {
+    rpcUrl;
+    chainId;
+    provider;
+    chainChecked = false;
+    constructor(rpcUrl, chainId) {
+        this.rpcUrl = rpcUrl;
+        this.chainId = chainId;
+        const net = Network.from(chainId);
+        this.provider = new JsonRpcProvider(rpcUrl, net, { staticNetwork: net });
+    }
+    /** Fails if the RPC serves a different chain than the venue's signing chain. */
+    async ready() {
+        if (this.chainChecked)
+            return;
+        const id = BigInt(await this.provider.send("eth_chainId", []));
+        if (id !== BigInt(this.chainId)) {
+            throw new PerpError("EXCHANGE_ERROR", `RPC ${this.rpcUrl} serves chainId ${id}, expected ${this.chainId}`, { exchange: "arcus" });
+        }
+        this.chainChecked = true;
+    }
+    async call(to, data) {
+        await this.ready();
+        return this.provider.call({ to, data });
+    }
+    async nativeBalance(owner) {
+        await this.ready();
+        return this.provider.getBalance(owner);
+    }
+    /**
+     * balanceOf(owner) for each token via Multicall3. Returns null for a target
+     * that answered with no data (no contract deployed — e.g. a wrapped token the
+     * factory has not created yet); a reverted call throws.
+     */
+    async erc20Balances(owner, tokens) {
+        await this.ready();
+        const out = [];
+        const data = erc20.encodeFunctionData("balanceOf", [owner]);
+        for (let i = 0; i < tokens.length; i += MULTICALL_BATCH) {
+            const batch = tokens.slice(i, i + MULTICALL_BATCH);
+            const raw = await this.provider.call({
+                to: MULTICALL3_ADDRESS,
+                data: multicall3.encodeFunctionData("aggregate3", [batch.map(t => ({ target: t, allowFailure: true, callData: data }))]),
+            });
+            const [results] = multicall3.decodeFunctionResult("aggregate3", raw);
+            results.forEach((r, j) => {
+                if (!r.success) {
+                    throw new PerpError("EXCHANGE_ERROR", `balanceOf reverted on token ${batch[j]}`, { exchange: "arcus" });
+                }
+                out.push(r.returnData === "0x" ? null : erc20.decodeFunctionResult("balanceOf", r.returnData)[0]);
+            });
+        }
+        return out;
+    }
+    async permit2Allowance(token, owner) {
+        const raw = await this.call(token, erc20.encodeFunctionData("allowance", [owner, PERMIT2_ADDRESS]));
+        return erc20.decodeFunctionResult("allowance", raw)[0];
+    }
+    /** EIP-2612 nonce, or null when the token has no `nonces()` (not EIP-2612 → approve tx needed). */
+    async eip2612Nonce(token, owner) {
+        try {
+            const raw = await this.call(token, erc20.encodeFunctionData("nonces", [owner]));
+            if (raw === "0x")
+                return null;
+            return erc20.decodeFunctionResult("nonces", raw)[0];
+        }
+        catch (e) {
+            if (isContractRevert(e))
+                return null;
+            throw e;
+        }
+    }
+    /**
+     * EIP-712 domain the token verifies permits with: EIP-5267 `eip712Domain()`,
+     * else a `version()` / "1" / "2" candidate that reproduces DOMAIN_SEPARATOR().
+     * Nothing verifiable → throws (no guessing).
+     */
+    async eip2612Domain(token) {
+        try {
+            const raw = await this.call(token, erc20.encodeFunctionData("eip712Domain", []));
+            if (raw !== "0x") {
+                const d = erc20.decodeFunctionResult("eip712Domain", raw);
+                const name = d[1];
+                const version = d[2];
+                if (name && version)
+                    return { name, version };
+            }
+        }
+        catch (e) {
+            if (!isContractRevert(e))
+                throw e;
+        }
+        const name = erc20.decodeFunctionResult("name", await this.call(token, erc20.encodeFunctionData("name", [])))[0];
+        let versionFn = null;
+        try {
+            const raw = await this.call(token, erc20.encodeFunctionData("version", []));
+            if (raw !== "0x")
+                versionFn = erc20.decodeFunctionResult("version", raw)[0];
+        }
+        catch (e) {
+            if (!isContractRevert(e))
+                throw e;
+        }
+        const sepRaw = await this.call(token, erc20.encodeFunctionData("DOMAIN_SEPARATOR", []));
+        const onchain = erc20.decodeFunctionResult("DOMAIN_SEPARATOR", sepRaw)[0].toLowerCase();
+        const candidates = [...new Set([versionFn, "1", "2"].filter((v) => typeof v === "string" && v.length > 0))];
+        const coder = AbiCoder.defaultAbiCoder();
+        for (const version of candidates) {
+            const sep = keccak256(coder.encode(["bytes32", "bytes32", "bytes32", "uint256", "address"], [EIP712_DOMAIN_TYPEHASH, keccak256(toUtf8Bytes(name)), keccak256(toUtf8Bytes(version)), BigInt(this.chainId), token]));
+            if (sep.toLowerCase() === onchain)
+                return { name, version };
+        }
+        throw new PerpError("NOT_IMPLEMENTED", `Cannot determine the EIP-2612 domain of token ${token} (no eip712Domain(), no DOMAIN_SEPARATOR match)`, {
+            exchange: "arcus",
+            remediation: `Approve Permit2 (${PERMIT2_ADDRESS}) for this token from your wallet, then retry`,
+        });
+    }
+    /**
+     * Send `approve(Permit2, MAX_UINT256)` from `owner`, signed via `signTx`
+     * (master key), after checking the native ETH balance covers
+     * gasLimit × maxFeePerGas. Waits for a successful receipt.
+     */
+    async approvePermit2(token, owner, signTx) {
+        await this.ready();
+        const data = erc20.encodeFunctionData("approve", [PERMIT2_ADDRESS, MAX_UINT256]);
+        const estimate = await this.provider.estimateGas({ from: owner, to: token, data });
+        const gasLimit = estimate + (estimate * APPROVE_GAS_HEADROOM_PCT) / 100n;
+        const fee = await this.provider.getFeeData();
+        if (fee.maxFeePerGas === null || fee.maxPriorityFeePerGas === null) {
+            throw new PerpError("EXCHANGE_ERROR", `RPC ${this.rpcUrl} returned no EIP-1559 fee data`, { exchange: "arcus" });
+        }
+        const cost = gasLimit * fee.maxFeePerGas;
+        const eth = await this.provider.getBalance(owner);
+        if (eth <= cost) {
+            throw new PerpError("INSUFFICIENT_BALANCE", `Permit2 approve needs up to ${cost} wei of Robinhood Chain ETH for gas; wallet ${owner} has ${eth}`, {
+                exchange: "arcus",
+                remediation: `Fund ${owner} with ETH on Robinhood Chain (chainId ${this.chainId}), then retry`,
+            });
+        }
+        const nonce = await this.provider.getTransactionCount(owner, "pending");
+        const tx = Transaction.from({
+            type: 2, chainId: BigInt(this.chainId), nonce, to: token, data, value: 0n, gasLimit,
+            maxFeePerGas: fee.maxFeePerGas, maxPriorityFeePerGas: fee.maxPriorityFeePerGas,
+        });
+        tx.signature = Signature.from(await signTx(tx));
+        if (tx.from?.toLowerCase() !== owner.toLowerCase()) {
+            throw new PerpError("SIGNATURE_FAILED", `Approve tx recovered signer ${tx.from}, expected ${owner}`, { exchange: "arcus" });
+        }
+        // Once broadcast, the approve's outcome is unknown until mined: a broadcast transport failure,
+        // a receipt read failure or a receipt timeout → ORDER_PENDING (never the retryable TIMEOUT,
+        // which callers re-type as "not sent"). No connection at all → definitely not sent.
+        const signedHash = tx.hash;
+        const pendingRemediation = (hash) => `Do NOT send another approve; wait for ${hash ?? "the approve tx"} to confirm (check the wallet's Robinhood Chain transactions), then retry the swap`;
+        let sent;
+        try {
+            sent = await this.provider.broadcastTransaction(tx.serialized);
+        }
+        catch (e) {
+            throw sendFailure("arcus", `Permit2 approve tx ${signedHash ?? ""}`.trim(), e, pendingRemediation(signedHash));
+        }
+        let receipt;
+        try {
+            receipt = await this.provider.waitForTransaction(sent.hash, 1, ARCUS_APPROVE_RECEIPT_TIMEOUT_MS);
+        }
+        catch (e) {
+            if (e.code !== "TIMEOUT") {
+                throw orderOutcomeUnknown("arcus", `Permit2 approve tx ${sent.hash}`, e, pendingRemediation(sent.hash));
+            }
+            receipt = null;
+        }
+        if (receipt === null) {
+            throw new PerpError("ORDER_PENDING", `Permit2 approve tx ${sent.hash} not mined within ${ARCUS_APPROVE_RECEIPT_TIMEOUT_MS / 1000}s`, {
+                exchange: "arcus",
+                txHash: sent.hash,
+                remediation: pendingRemediation(sent.hash),
+            });
+        }
+        if (receipt.status !== 1) {
+            throw new PerpError("EXCHANGE_ERROR", `Permit2 approve tx ${sent.hash} reverted`, { exchange: "arcus" });
+        }
+        return sent.hash;
+    }
+    /** ERC-20 Transfer logs in a mined tx (null when the RPC has no receipt for it). */
+    async transfersIn(txHash) {
+        await this.ready();
+        const receipt = await this.provider.getTransactionReceipt(txHash);
+        if (receipt === null)
+            return null;
+        const transfers = [];
+        for (const log of receipt.logs) {
+            if (log.topics[0] !== TRANSFER_TOPIC || log.topics.length !== 3)
+                continue;
+            const ev = erc20.parseLog({ topics: [...log.topics], data: log.data });
+            if (ev === null)
+                continue;
+            transfers.push({ token: log.address, from: ev.args[0], to: ev.args[1], amount: ev.args[2] });
+        }
+        return { status: receipt.status, transfers };
+    }
+}

package/dist/exchanges/arcus/spot-router.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Arcus Spot Router HTTP client + wire types (design §12, §12.4 #7).
+ *
+ * Ported from @arcus-xyz/arcus-spot-sdk@1.0.2 (src/client.ts, src/types.ts,
+ * src/chains.ts) — Copyright Arcus, licensed under the Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0). Changes: viem removed, only
+ * the "arcus" venue shapes kept, errors mapped to PerpError.
+ *
+ * Endpoints (router.spot.arcus.xyz): GET /v1/tokens, /v1/price, /v1/quote,
+ * /v1/status; POST /v1/submit. No API key is sent — the router served
+ * /tokens, /price and /quote without one (verified 2026-10-01). Whether
+ * /submit needs one is unverified; a 401/403 on submit is reported as
+ * NOT_IMPLEMENTED (no key storage exists, SSOT Rule #3).
+ */
+import { PerpError } from "../../errors.js";
+import type { Network } from "../venue-types.js";
+/** Canonical Permit2 (same address on every chain). */
+export declare const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+/** Multicall3 — `eth_getCode` non-empty on RH mainnet and testnet (verified 2026-10-01). */
+export declare const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+/** `/tokens` sentinel for the chain's native asset. */
+export declare const NATIVE_TOKEN_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+export interface ArcusSpotDeployment {
+    routerUrl: string;
+    chainId: number;
+    /** Permit2 spender bound in every arcus-venue intent (SDK chains.ts). */
+    arcusSettlement: string;
+}
+export declare const ARCUS_SPOT_DEPLOYMENTS: Record<Network, ArcusSpotDeployment>;
+/** Per-request HTTP timeout (SDK default). */
+export declare const ARCUS_ROUTER_TIMEOUT_MS = 15000;
+export interface RouterToken {
+    chainId: number;
+    address: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    source: string;
+    category: string;
+    verified: boolean;
+    /** Canonical wrapped (placeholder) token for RFQ fallback fills; null/absent = none. */
+    wrappedTokenAddress?: string | null;
+}
+export interface RouteFee {
+    amount: string;
+    token: string;
+    type: string;
+    bps?: number;
+    amountUsd?: number;
+}
+export interface PriceEntry {
+    venue: string;
+    /** Net of fees, buy-token base units. */
+    buyAmount: string;
+    sellAmount: string;
+    fees: RouteFee[];
+}
+export interface PriceResponse {
+    recommended: string;
+    venue: string;
+    referencePrice: string | null;
+    all: PriceEntry[];
+}
+export interface Eip712TypedData {
+    domain: Record<string, unknown>;
+    types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>;
+    primaryType: string;
+    message: Record<string, unknown>;
+}
+export interface TakerIntent {
+    taker: string;
+    takerSellToken: string;
+    takerBuyToken: string;
+    sellAmount: string;
+    minBuyAmount: string;
+    allowWrapped: boolean;
+    nonce: string;
+    deadline: string;
+}
+export interface TakerIntentTypedData extends Eip712TypedData {
+    message: {
+        permitted: {
+            token: string;
+            amount: string;
+        };
+        spender: string;
+        nonce: string;
+        deadline: string;
+        witness: TakerIntent;
+    };
+}
+export interface ArcusQuoteEntry extends PriceEntry {
+    venue: "arcus";
+    expiry: number;
+    toSign: TakerIntentTypedData;
+    arcus: {
+        minAmountOut: string;
+    };
+}
+export interface QuoteResponse {
+    recommended: string;
+    venue: string;
+    all: Array<PriceEntry & {
+        toSign?: unknown;
+    }>;
+}
+/** EIP-2612 permit folded into SwapShell.permits[] (SDK types.ts `Permit`). */
+export interface Permit {
+    token: string;
+    value: string;
+    deadline: string;
+    v: number;
+    r: string;
+    s: string;
+}
+export interface ArcusSignedQuote {
+    venue: "arcus";
+    chainId: number;
+    taker: string;
+    typedData: TakerIntentTypedData;
+    signature: string;
+    permits?: Permit[];
+}
+export interface ArcusSubmitResponse {
+    venue: string;
+    txHash: string;
+    status: string;
+    maker?: string;
+    wrapped?: boolean;
+    settledToken?: string;
+    orderId?: string;
+}
+export type RouterStatus = "pending" | "submitted" | "confirmed" | "failed" | "unknown";
+export interface StatusResponse {
+    venue: string;
+    status: RouterStatus;
+    txHash?: string | null;
+    reason?: string | null;
+    errorCode?: string | null;
+    swap?: unknown;
+}
+/** HTTP-level router failure (non-2xx). `routerCode` is the router's error code when it sent one. */
+export declare class RouterHttpError extends PerpError {
+    readonly status: number;
+    readonly routerCode: string | null;
+    readonly body: unknown;
+    readonly retryAfter: string | null;
+    constructor(message: string, status: number, routerCode: string | null, body: unknown, retryAfter: string | null);
+}
+export declare class ArcusSpotRouter {
+    readonly deployment: ArcusSpotDeployment;
+    constructor(deployment: ArcusSpotDeployment);
+    private url;
+    private request;
+    /**
+     * Idempotent GET. A 429 is waited out per the server's Retry-After (logged to
+     * stderr, at most MAX_RATE_LIMIT_WAITS times, each ≤ MAX_RETRY_AFTER_S);
+     * beyond that → RATE_LIMITED. Never used for POST /submit.
+     */
+    private get;
+    tokens(): Promise<RouterToken[]>;
+    price(sellToken: string, buyToken: string, sellAmount: bigint): Promise<PriceResponse>;
+    quote(p: {
+        sellToken: string;
+        buyToken: string;
+        sellAmount: bigint;
+        taker: string;
+        slippageBps: number;
+    }): Promise<QuoteResponse>;
+    /** Single attempt — never retried (a resend could double-execute). Throws RouterHttpError / PerpError. */
+    submit(body: ArcusSignedQuote): Promise<ArcusSubmitResponse>;
+    status(id: string): Promise<StatusResponse>;
+    statusUrl(id: string): string;
+}

package/dist/exchanges/arcus/spot-router.js

@@ -0,0 +1,183 @@
+/**
+ * Arcus Spot Router HTTP client + wire types (design §12, §12.4 #7).
+ *
+ * Ported from @arcus-xyz/arcus-spot-sdk@1.0.2 (src/client.ts, src/types.ts,
+ * src/chains.ts) — Copyright Arcus, licensed under the Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0). Changes: viem removed, only
+ * the "arcus" venue shapes kept, errors mapped to PerpError.
+ *
+ * Endpoints (router.spot.arcus.xyz): GET /v1/tokens, /v1/price, /v1/quote,
+ * /v1/status; POST /v1/submit. No API key is sent — the router served
+ * /tokens, /price and /quote without one (verified 2026-10-01). Whether
+ * /submit needs one is unverified; a 401/403 on submit is reported as
+ * NOT_IMPLEMENTED (no key storage exists, SSOT Rule #3).
+ */
+import { PerpError } from "../../errors.js";
+/** Canonical Permit2 (same address on every chain). */
+export const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+/** Multicall3 — `eth_getCode` non-empty on RH mainnet and testnet (verified 2026-10-01). */
+export const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+/** `/tokens` sentinel for the chain's native asset. */
+export const NATIVE_TOKEN_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+export const ARCUS_SPOT_DEPLOYMENTS = {
+    mainnet: {
+        routerUrl: "https://router.spot.arcus.xyz/v1",
+        chainId: 4663,
+        arcusSettlement: "0x006102b16A04c20306A28b652745D3973D7D24fa",
+    },
+    testnet: {
+        routerUrl: "https://router.spot.testnet.arcus.xyz/v1",
+        chainId: 46630,
+        arcusSettlement: "0xE8D8b187754D8a5Ca4Ea4E77Cd01506f9332A773",
+    },
+};
+/** Per-request HTTP timeout (SDK default). */
+export const ARCUS_ROUTER_TIMEOUT_MS = 15_000;
+/** Longest Retry-After (seconds) a GET waits out before failing with RATE_LIMITED. */
+const MAX_RETRY_AFTER_S = 60;
+/** Rate-limit waits per GET before failing with RATE_LIMITED. */
+const MAX_RATE_LIMIT_WAITS = 2;
+/** Router codes meaning the trade is below the router's minimum size/fee. */
+const BELOW_MINIMUM_CODES = new Set(["TRADE_NOTIONAL_BELOW_MINIMUM", "TRADE_BELOW_MINIMUM_FEE"]);
+/** HTTP-level router failure (non-2xx). `routerCode` is the router's error code when it sent one. */
+export class RouterHttpError extends PerpError {
+    status;
+    routerCode;
+    body;
+    retryAfter;
+    constructor(message, status, routerCode, body, retryAfter) {
+        super(status === 429 ? "RATE_LIMITED" : routerCode !== null && BELOW_MINIMUM_CODES.has(routerCode) ? "SIZE_TOO_SMALL" : "EXCHANGE_ERROR", message, { exchange: "arcus", httpStatus: status, routerCode });
+        this.status = status;
+        this.routerCode = routerCode;
+        this.body = body;
+        this.retryAfter = retryAfter;
+        this.name = "RouterHttpError";
+    }
+}
+function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
+function routerErrorMessage(body) {
+    if (!body || typeof body !== "object")
+        return { code: null, message: typeof body === "string" && body ? body : null };
+    const b = body;
+    const code = typeof b.code === "string" ? b.code : null;
+    const error = typeof b.error === "string" ? b.error : null;
+    const details = Array.isArray(b.details)
+        ? b.details
+            .map(d => {
+            const item = d;
+            const v = typeof item.venue === "string" ? item.venue : "upstream";
+            const c = typeof item.error?.code === "string" ? item.error.code : null;
+            const m = typeof item.error?.message === "string" ? item.error.message : null;
+            return `${v}: ${[c, m].filter(Boolean).join(" ")}`;
+        })
+            .join("; ")
+        : null;
+    return { code, message: [error ?? code, details].filter(Boolean).join(" — ") || null };
+}
+export class ArcusSpotRouter {
+    deployment;
+    constructor(deployment) {
+        this.deployment = deployment;
+    }
+    url(path, params) {
+        const u = new URL(`${this.deployment.routerUrl}/${path}`);
+        for (const [k, v] of Object.entries(params))
+            u.searchParams.set(k, v);
+        return u.toString();
+    }
+    async request(method, url, body) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), ARCUS_ROUTER_TIMEOUT_MS);
+        let res;
+        try {
+            res = await fetch(url, {
+                method,
+                headers: body === undefined ? undefined : { "Content-Type": "application/json" },
+                body: body === undefined ? undefined : JSON.stringify(body),
+                signal: controller.signal,
+            });
+        }
+        catch (e) {
+            const aborted = controller.signal.aborted;
+            throw new PerpError(aborted ? "TIMEOUT" : "EXCHANGE_UNREACHABLE", `Arcus router ${method} ${url} ${aborted ? `timed out after ${ARCUS_ROUTER_TIMEOUT_MS}ms` : `failed: ${e instanceof Error ? e.message : String(e)}`}`, { exchange: "arcus" });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        const text = await res.text();
+        let parsed = null;
+        if (text) {
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                parsed = text;
+            }
+        }
+        if (!res.ok) {
+            const { code, message } = routerErrorMessage(parsed);
+            throw new RouterHttpError(`Arcus router ${method} ${new URL(url).pathname} → HTTP ${res.status}${message ? `: ${message}` : ""}`, res.status, code, parsed, res.headers.get("retry-after"));
+        }
+        return parsed;
+    }
+    /**
+     * Idempotent GET. A 429 is waited out per the server's Retry-After (logged to
+     * stderr, at most MAX_RATE_LIMIT_WAITS times, each ≤ MAX_RETRY_AFTER_S);
+     * beyond that → RATE_LIMITED. Never used for POST /submit.
+     */
+    async get(path, params) {
+        const url = this.url(path, params);
+        for (let waits = 0;; waits++) {
+            try {
+                return await this.request("GET", url, undefined);
+            }
+            catch (e) {
+                if (!(e instanceof RouterHttpError) || e.status !== 429)
+                    throw e;
+                const ra = e.retryAfter === null ? Number.NaN : Number(e.retryAfter);
+                if (!Number.isFinite(ra) || ra < 0 || ra > MAX_RETRY_AFTER_S || waits >= MAX_RATE_LIMIT_WAITS) {
+                    throw new PerpError("RATE_LIMITED", `Arcus router rate limit on /${path} (Retry-After: ${Number.isFinite(ra) ? `${ra}s` : "none"})`, {
+                        exchange: "arcus",
+                        remediation: "Wait a minute and retry",
+                    });
+                }
+                console.error(`[arcus-spot] router rate-limited on /${path}; waiting ${ra}s (Retry-After)`);
+                await sleep(ra * 1000);
+            }
+        }
+    }
+    async tokens() {
+        const rows = await this.get("tokens", { chainId: String(this.deployment.chainId) });
+        if (!Array.isArray(rows))
+            throw new PerpError("EXCHANGE_ERROR", "Arcus router /tokens did not return a list", { exchange: "arcus" });
+        return rows;
+    }
+    async price(sellToken, buyToken, sellAmount) {
+        return this.get("price", {
+            chainId: String(this.deployment.chainId), sellToken, buyToken, sellAmount: sellAmount.toString(),
+        });
+    }
+    async quote(p) {
+        return this.get("quote", {
+            chainId: String(this.deployment.chainId),
+            sellToken: p.sellToken,
+            buyToken: p.buyToken,
+            sellAmount: p.sellAmount.toString(),
+            taker: p.taker,
+            slippageBps: String(p.slippageBps),
+            allowWrapped: "false", // §12.4 #7 — never accept a wrapped placeholder
+        });
+    }
+    /** Single attempt — never retried (a resend could double-execute). Throws RouterHttpError / PerpError. */
+    async submit(body) {
+        return this.request("POST", `${this.deployment.routerUrl}/submit`, body);
+    }
+    async status(id) {
+        return this.get("status", { venue: "arcus", id, chainId: String(this.deployment.chainId) });
+    }
+    statusUrl(id) {
+        return this.url("status", { venue: "arcus", id, chainId: String(this.deployment.chainId) });
+    }
+}