@0xmonaco/core 1.1.6 → 1.1.8

package/dist/api/sweeper/hyperevm.js

@@ -0,0 +1,282 @@
+/**
+ * USDC deposits from HyperEVM to a Sei deposit address.
+ *
+ * The wallet burns its Circle USDC on HyperEVM through Circle's
+ * TokenMessengerV2, naming the Sei deposit address as the mint recipient and
+ * attaching Circle's forwarding hook, so Circle mints on Sei
+ * (developers.circle.com/cctp/concepts/forwarding-service). The hub sweeps the
+ * mint like any deposit made straight to the address, so nothing of Monaco's
+ * runs on HyperEVM. The wallet pays HYPE for the approval and burn.
+ */
+import { BaseError, ChainMismatchError, createPublicClient, createWalletClient, encodeFunctionData, http, keccak256, pad, parseAbi, } from "viem";
+import { APIError, ContractError } from "../../errors";
+import { SEI_CCTP_DOMAIN } from "./hypercore";
+/** HyperEVM's CCTP domain: where the burn happens. */
+const HYPEREVM_CCTP_DOMAIN = 19;
+/**
+ * The standard lane. From HyperEVM it attests in about a block (Circle's
+ * table: ~5 seconds) and carries no protocol fee, so `maxFee` is Circle's
+ * forwarding fee alone.
+ */
+const CCTP_STANDARD_FINALITY = 2000;
+/** Circle's static version-0 forwarding hook: "cctp-forward", version 0, no extra data. */
+const FORWARD_HOOK = "0x636374702d666f72776172640000000000000000000000000000000000000000";
+/** How long to wait for a HyperEVM receipt; small blocks land every second. */
+const RECEIPT_TIMEOUT_MS = 60_000;
+/** EIP-1193 / EIP-3085: the wallet does not know the requested chain. */
+const UNRECOGNIZED_CHAIN = 4902;
+const ERC20_ABI = parseAbi([
+    "function balanceOf(address) view returns (uint256)",
+    "function allowance(address,address) view returns (uint256)",
+    "function approve(address,uint256) returns (bool)",
+]);
+const TOKEN_MESSENGER_ABI = parseAbi([
+    "function depositForBurnWithHook(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken, bytes32 destinationCaller, uint256 maxFee, uint32 minFinalityThreshold, bytes hookData)",
+]);
+function hyperEvmPublicClient(network) {
+    return createPublicClient({ chain: network.hyperEvm, transport: http(), pollingInterval: 1_000 });
+}
+/**
+ * Circle's forwarding fee for a HyperEVM-to-Sei transfer on the standard lane,
+ * at Circle's "high" level. Every forwarded transfer we sent was charged its
+ * whole `maxFee`, so the quote is used as is rather than padded; and a
+ * `maxFee` below the forwarding fee would leave the mint unforwarded, so the
+ * top of Circle's range is the safe choice.
+ */
+export async function quoteForwardFee(network) {
+    const endpoint = `${network.irisUrl}/v2/burn/USDC/fees/${HYPEREVM_CCTP_DOMAIN}/${SEI_CCTP_DOMAIN}?forward=true`;
+    let response;
+    try {
+        response = await fetch(endpoint);
+    }
+    catch (error) {
+        throw new APIError("Network request to Circle's fee API failed", { endpoint, cause: error instanceof Error ? error : new Error(String(error)) });
+    }
+    const text = await response.text().catch(() => "");
+    if (!response.ok) {
+        throw new APIError(`Circle's fee API answered ${response.status}`, { endpoint, statusCode: response.status, responseBody: text.slice(0, 500) });
+    }
+    let quotes;
+    try {
+        quotes = JSON.parse(text);
+    }
+    catch {
+        quotes = undefined;
+    }
+    const standard = Array.isArray(quotes)
+        ? quotes.find((quote) => quote.finalityThreshold === CCTP_STANDARD_FINALITY)
+        : undefined;
+    const fee = standard?.forwardFee?.high;
+    if (typeof fee !== "number" || !Number.isSafeInteger(fee) || fee < 0) {
+        throw new APIError("Circle's fee API returned no forwarding fee for HyperEVM to Sei", {
+            endpoint,
+            statusCode: response.status,
+            responseBody: text.slice(0, 500),
+        });
+    }
+    return BigInt(fee);
+}
+export async function readHyperEvmAccount(network, address) {
+    const client = hyperEvmPublicClient(network);
+    const [usdc, allowance, gas] = await Promise.all([
+        client.readContract({ address: network.hyperEvmUsdc, abi: ERC20_ABI, functionName: "balanceOf", args: [address] }),
+        client.readContract({ address: network.hyperEvmUsdc, abi: ERC20_ABI, functionName: "allowance", args: [address, network.tokenMessenger] }),
+        client.getBalance({ address }),
+    ]);
+    return { usdc, allowance, gas };
+}
+/**
+ * A wallet client that sends on HyperEVM, and how to hand the wallet back.
+ *
+ * A local account signs for HyperEVM through a client of its own on the public
+ * HyperEVM RPC. A browser or embedded wallet is switched to HyperEVM — added
+ * first when it does not know the chain — and switched back to the chain it
+ * was on afterwards, since the SDK expects it on Sei.
+ */
+async function onHyperEvm(walletClient, network) {
+    const account = walletClient.account;
+    if (!account) {
+        throw new Error("onHyperEvm needs a wallet client with an account");
+    }
+    if (account.type === "local") {
+        return { client: createWalletClient({ account, chain: network.hyperEvm, transport: http() }), restore: async () => { } };
+    }
+    const home = walletClient.chain;
+    try {
+        await walletClient.switchChain({ id: network.hyperEvm.id });
+    }
+    catch (error) {
+        if (!(error instanceof BaseError) || !error.walk((cause) => cause.code === UNRECOGNIZED_CHAIN)) {
+            throw error;
+        }
+        await walletClient.addChain({ chain: network.hyperEvm });
+        await walletClient.switchChain({ id: network.hyperEvm.id });
+    }
+    return {
+        client: walletClient,
+        restore: async () => {
+            if (home) {
+                // Best effort: the deposit's outcome does not depend on it.
+                await walletClient.switchChain({ id: home.id }).catch(() => undefined);
+            }
+        },
+    };
+}
+/**
+ * Approve (when the allowance is short) and burn `amount` of the wallet's
+ * HyperEVM USDC to `recipient` on Sei, with Circle forwarding the mint.
+ *
+ * Decided failures — nothing was burned — throw as they are: a wallet's
+ * refusal, a failure before the burn was broadcast, and a `ContractError` for
+ * a reverted, cancelled or replaced approval or burn. A burn that may have
+ * been broadcast but whose outcome cannot be read is an unknown outcome: the
+ * `APIError` carries `retryable: false` and, when known, the burn's hash,
+ * because calling again burns a second time. An approval in that state stays
+ * retryable, since the next call re-reads the allowance.
+ */
+export async function burnToSei(params) {
+    const { walletClient, network, amount, recipient, maxFee, allowance } = params;
+    const account = walletClient.account;
+    if (!account) {
+        throw new Error("burnToSei needs a wallet client with an account");
+    }
+    const publicClient = hyperEvmPublicClient(network);
+    const { client, restore } = await onHyperEvm(walletClient, network);
+    try {
+        let approveTxHash;
+        if (allowance < amount) {
+            const approval = encodeFunctionData({ abi: ERC20_ABI, functionName: "approve", args: [network.tokenMessenger, amount] });
+            const sent = await send(client, account, network, { to: network.hyperEvmUsdc, data: approval }).catch((error) => {
+                throw error instanceof AmbiguousSend ? error.cause : error;
+            });
+            approveTxHash = await settle(publicClient, sent, "approval", network.hyperEvmUsdc);
+        }
+        const burn = encodeFunctionData({
+            abi: TOKEN_MESSENGER_ABI,
+            functionName: "depositForBurnWithHook",
+            args: [
+                amount,
+                SEI_CCTP_DOMAIN,
+                pad(recipient, { size: 32 }),
+                network.hyperEvmUsdc,
+                // Any caller may mint on Sei; Circle's forwarder does.
+                pad("0x", { size: 32 }),
+                maxFee,
+                CCTP_STANDARD_FINALITY,
+                FORWARD_HOOK,
+            ],
+        });
+        let burnSent;
+        try {
+            burnSent = await send(client, account, network, { to: network.tokenMessenger, data: burn });
+        }
+        catch (error) {
+            throw error instanceof AmbiguousSend ? unknownBurnOutcome(error.hash, error.cause, network) : error;
+        }
+        let burnTxHash;
+        try {
+            burnTxHash = await settle(publicClient, burnSent, "burn", network.tokenMessenger);
+        }
+        catch (error) {
+            throw error instanceof ContractError ? error : unknownBurnOutcome(burnSent, error, network);
+        }
+        return { approveTxHash, burnTxHash };
+    }
+    finally {
+        await restore();
+    }
+}
+/**
+ * EIP-1193 errors a wallet answers without broadcasting anything: the user
+ * rejected the request (4001), the account or method is not authorized (4100)
+ * or not supported (4200), or the wallet is disconnected (4900, 4901).
+ */
+const WALLET_REFUSALS = new Set([4001, 4100, 4200, 4900, 4901]);
+/** A send that may or may not have reached the network. `hash` is known when the SDK signed it. */
+class AmbiguousSend extends Error {
+    hash;
+    cause;
+    constructor(hash, cause) {
+        super("The transaction may have been broadcast");
+        this.hash = hash;
+        this.cause = cause;
+    }
+}
+/**
+ * Broadcast one HyperEVM call.
+ *
+ * A local account's transaction is prepared and signed here, so its hash is
+ * known before the broadcast; a failed broadcast may still have reached the
+ * network, so it is an {@link AmbiguousSend} carrying that hash. A failure
+ * while preparing (a revert in gas estimation, say) sent nothing and passes
+ * through. A wallet's refusal, or a wallet on the wrong chain, is decided and
+ * passes through too; any other wallet failure may follow a broadcast, so it
+ * is ambiguous.
+ */
+async function send(client, account, network, call) {
+    if (account.type === "local") {
+        const request = await client.prepareTransactionRequest({ account, chain: network.hyperEvm, ...call });
+        const serializedTransaction = await client.signTransaction(request);
+        const hash = keccak256(serializedTransaction);
+        try {
+            await client.sendRawTransaction({ serializedTransaction });
+        }
+        catch (error) {
+            throw new AmbiguousSend(hash, error);
+        }
+        return hash;
+    }
+    try {
+        return await client.sendTransaction({ account, chain: network.hyperEvm, ...call });
+    }
+    catch (error) {
+        const refused = error instanceof BaseError &&
+            Boolean(error.walk((cause) => cause instanceof ChainMismatchError || WALLET_REFUSALS.has(cause.code)));
+        if (refused) {
+            throw error;
+        }
+        throw new AmbiguousSend(undefined, error);
+    }
+}
+/**
+ * Wait for a sent call's receipt and settle it. viem follows a transaction
+ * the wallet replaced: a repriced one (the same call at a new fee) settles as
+ * its mined replacement's hash, while a cancelled or otherwise replaced one
+ * never ran, so it is a decided failure, as is a revert. A receipt that
+ * cannot be read throws viem's error.
+ */
+async function settle(publicClient, hash, what, contract) {
+    let replacement;
+    const receipt = await publicClient.waitForTransactionReceipt({
+        hash,
+        timeout: RECEIPT_TIMEOUT_MS,
+        onReplaced: (replaced) => {
+            replacement = replaced;
+        },
+    });
+    if (replacement && replacement.reason !== "repriced") {
+        // The SDK's transaction never ran; a "replaced" one was swapped for a
+        // different transaction, whose effects are the wallet's own.
+        const message = replacement.reason === "cancelled"
+            ? `The HyperEVM ${what} was cancelled in the wallet; it did not run`
+            : `The HyperEVM ${what} was replaced in the wallet by a different transaction (${receipt.transactionHash}); the ${what} did not run`;
+        throw new ContractError(message, { transactionHash: receipt.transactionHash, contractAddress: contract });
+    }
+    if (receipt.status !== "success") {
+        throw new ContractError(`The HyperEVM ${what} reverted; nothing was burned`, { transactionHash: receipt.transactionHash, contractAddress: contract });
+    }
+    return receipt.transactionHash;
+}
+function unknownBurnOutcome(burnTxHash, cause, network) {
+    const error = new APIError(burnTxHash
+        ? `The HyperEVM burn ${burnTxHash} may have been sent, but its outcome could not be read`
+        : "The wallet failed after it may have broadcast the HyperEVM burn", {
+        endpoint: network.hyperEvm.rpcUrls.default.http[0],
+        ...(burnTxHash ? { responseBody: { burnTxHash } } : {}),
+        cause: cause instanceof Error ? cause : new Error(String(cause)),
+    });
+    error.retryable = false;
+    error.suggestion =
+        "The burn may have landed. Do not call depositFromHyperEvm again, which burns a second time: check the wallet's HyperEVM activity, or sdk.sweeper.listDeposits once it is minted on Sei.";
+    return error;
+}

package/dist/api/vault/api.d.ts

@@ -187,6 +187,30 @@ export declare class VaultAPIImpl extends BaseAPI implements VaultAPI {
      * ```
      */
     deposit(assetId: string, amount: bigint, autoWait?: boolean, target?: DepositTarget, options?: DepositOptions): Promise<TransactionResult>;
+    /**
+     * Sends a withdrawal's `executeWithdrawal` calldata through the wallet and,
+     * with `autoWait`, waits for it.
+     *
+     * Gas is `EXECUTE_WITHDRAWAL_GAS_HEADROOM_PERCENT` over the node's estimate.
+     * A revert at the estimate throws `WithdrawalRateLimitedError` for the vault's
+     * rate limit, else `ContractError`. A withdrawal that passed its estimate can
+     * still revert on-chain when another withdrawal drains the limit first: if
+     * `minedRateLimitRevert` finds the rate limit behind the revert, this throws
+     * `WithdrawalRateLimitedError` (with the transaction hash) instead of
+     * returning `"failed"`. Every error keeps the index for `retryWithdrawal`.
+     */
+    private executeWithdrawalOnChain;
+    /**
+     * The vault's `WithdrawalRateLimited` revert of a mined, reverted
+     * `executeWithdrawal`, if that is why it reverted.
+     *
+     * Exact where the node serves `debug_traceTransaction`: the transaction's
+     * own trace carries the revert it hit at its position in the block. A node
+     * without it gets a best-effort replay of the call at the end of the block,
+     * which misses a limit a later transaction in the same block refilled (the
+     * caller then sees `"failed"`).
+     */
+    private minedRateLimitRevert;
     /**
      * Polls `GET /api/v1/withdrawals/{index}` until the gateway can serve the
      * `executeWithdrawal` calldata, then returns it with the vault address.
@@ -242,6 +266,8 @@ export declare class VaultAPIImpl extends BaseAPI implements VaultAPI {
      *   transaction plus `withdrawalIndex`; on poll-timeout or `autoWait=false`
      *   returns `{ withdrawalIndex, status: "awaiting_proof" }`.
      * @throws {APIError} When the asset is not found or the initiate request is rejected
+     * @throws {WithdrawalRateLimitedError} When the vault's withdrawal rate limit
+     *   refuses the withdrawal; the index stays valid for `retryWithdrawal`
      * @throws {ContractError} When the on-chain submission fails
      * @throws {InvalidConfigError} When wallet account is not available
      *
@@ -293,6 +319,8 @@ export declare class VaultAPIImpl extends BaseAPI implements VaultAPI {
      * @returns Promise resolving to a [`WithdrawResult`]: the submitted transaction
      *   plus `withdrawalIndex`, or `{ withdrawalIndex, status: "awaiting_proof" }`
      *   if the proof did not arrive within the poll window.
+     * @throws {WithdrawalRateLimitedError} When the vault's withdrawal rate limit
+     *   still refuses the withdrawal; retry again later
      * @throws {ContractError} When the on-chain submission fails
      * @throws {InvalidConfigError} When wallet account is not available
      */

package/dist/api/vault/api.js

@@ -25,8 +25,8 @@
  */
 import { CONTRACT_ABIS, encodeDepositApplicationData } from "@0xmonaco/contracts";
 import { ApproveTokenSchema, DepositSchema, validate, WithdrawSchema } from "@0xmonaco/types";
-import { erc20Abi } from "viem";
-import { APIError, ContractError, InvalidConfigError } from "../../errors";
+import { decodeErrorResult, erc20Abi } from "viem";
+import { APIError, ContractError, InvalidConfigError, WithdrawalRateLimitedError } from "../../errors";
 import { BaseAPI } from "../base";
 /**
  * Default delay between polls while waiting for a withdrawal's proof. The proof
@@ -43,6 +43,68 @@ const DEFAULT_WITHDRAWAL_POLL_INTERVAL_MS = 500;
  */
 const DEFAULT_WITHDRAWAL_TIMEOUT_MS = 300_000;
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * Gas headroom over the node's estimate for `executeWithdrawal`, in percent.
+ * Its cost moves with state between estimate and inclusion: while the token
+ * has a withdrawal rate limit, the vault writes the limit's offset once its
+ * level has refilled past the max, which an estimate taken in the same second
+ * as the previous write does not pay for. On dev the bare estimate ran a
+ * withdrawal out of gas (148,971 sent, 152,101 needed).
+ */
+const EXECUTE_WITHDRAWAL_GAS_HEADROOM_PERCENT = 20n;
+/** The vault's revert for a withdrawal over the token's withdrawal rate limit. */
+const WITHDRAWAL_RATE_LIMITED_ABI = [
+    {
+        type: "error",
+        name: "WithdrawalRateLimited",
+        inputs: [
+            { name: "token", type: "address" },
+            { name: "available", type: "uint256" },
+            { name: "amount", type: "uint256" },
+        ],
+    },
+];
+/**
+ * The vault's `WithdrawalRateLimited` revert, when that is what a failed
+ * `executeWithdrawal` submission carries. viem leaves the revert data on the RPC
+ * error a few causes down, as hex or wrapped in `{ data }` depending on the node.
+ */
+function decodeWithdrawalRateLimited(error) {
+    let current = error;
+    for (let depth = 0; current && depth < 16; depth++) {
+        const raw = current.data;
+        const data = raw !== null && typeof raw === "object" ? raw.data : raw;
+        if (typeof data === "string" && data.startsWith("0x")) {
+            try {
+                // viem also decodes Solidity's built-in Error(string) and
+                // Panic(uint256) against any ABI: only the rate limit's own error counts.
+                const decoded = decodeErrorResult({ abi: WITHDRAWAL_RATE_LIMITED_ABI, data: data });
+                if (decoded.errorName === "WithdrawalRateLimited") {
+                    const [token, available, amount] = decoded.args;
+                    return { token, available, amount };
+                }
+            }
+            catch {
+                // Some other revert.
+            }
+        }
+        current = current.cause;
+    }
+    return undefined;
+}
+/**
+ * The error for a failed `executeWithdrawal` submission: a
+ * `WithdrawalRateLimitedError` when the vault's rate limit refused it, else a
+ * `ContractError`. Both keep the withdrawal index for `retryWithdrawal`.
+ */
+function executeWithdrawalError(action, withdrawalIndex, vaultAddress, error) {
+    const cause = error instanceof Error ? error : undefined;
+    const rateLimited = decodeWithdrawalRateLimited(error);
+    if (rateLimited) {
+        return new WithdrawalRateLimitedError(withdrawalIndex, { ...rateLimited, contractAddress: vaultAddress, cause });
+    }
+    return new ContractError(`Failed to ${action} executeWithdrawal for withdrawal ${withdrawalIndex}: ${error instanceof Error ? error.message : "unknown error"}`, { cause });
+}
 /**
  * Encode the on-chain `applicationData` for a deposit.
  *
@@ -339,6 +401,72 @@ export class VaultAPIImpl extends BaseAPI {
         };
         return await this.waitForTransaction(txResult, autoWait);
     }
+    /**
+     * Sends a withdrawal's `executeWithdrawal` calldata through the wallet and,
+     * with `autoWait`, waits for it.
+     *
+     * Gas is `EXECUTE_WITHDRAWAL_GAS_HEADROOM_PERCENT` over the node's estimate.
+     * A revert at the estimate throws `WithdrawalRateLimitedError` for the vault's
+     * rate limit, else `ContractError`. A withdrawal that passed its estimate can
+     * still revert on-chain when another withdrawal drains the limit first: if
+     * `minedRateLimitRevert` finds the rate limit behind the revert, this throws
+     * `WithdrawalRateLimitedError` (with the transaction hash) instead of
+     * returning `"failed"`. Every error keeps the index for `retryWithdrawal`.
+     */
+    async executeWithdrawalOnChain(action, withdrawalIndex, vaultAddress, calldata, walletClient, account, autoWait) {
+        const request = { account, to: vaultAddress, data: calldata };
+        let hash;
+        try {
+            const estimate = await this.publicClient.estimateGas(request);
+            hash = await walletClient.sendTransaction({
+                ...request,
+                chain: this.chain,
+                gas: estimate + (estimate * EXECUTE_WITHDRAWAL_GAS_HEADROOM_PERCENT) / 100n,
+            });
+        }
+        catch (error) {
+            throw executeWithdrawalError(action, withdrawalIndex, vaultAddress, error);
+        }
+        const nonce = account.getNonce ? await account.getNonce() : 0n;
+        const settled = await this.waitForTransaction({ hash, status: "pending", nonce }, autoWait);
+        if (settled.status === "failed" && settled.receipt) {
+            const rateLimited = await this.minedRateLimitRevert(hash, request, settled.receipt.blockNumber);
+            if (rateLimited) {
+                throw new WithdrawalRateLimitedError(withdrawalIndex, { ...rateLimited, contractAddress: vaultAddress, transactionHash: hash });
+            }
+        }
+        return { ...settled, withdrawalIndex };
+    }
+    /**
+     * The vault's `WithdrawalRateLimited` revert of a mined, reverted
+     * `executeWithdrawal`, if that is why it reverted.
+     *
+     * Exact where the node serves `debug_traceTransaction`: the transaction's
+     * own trace carries the revert it hit at its position in the block. A node
+     * without it gets a best-effort replay of the call at the end of the block,
+     * which misses a limit a later transaction in the same block refilled (the
+     * caller then sees `"failed"`).
+     */
+    async minedRateLimitRevert(hash, request, blockNumber) {
+        const traceRequest = this.publicClient.request;
+        let trace;
+        try {
+            trace = (await traceRequest({ method: "debug_traceTransaction", params: [hash, { tracer: "callTracer" }] }));
+        }
+        catch {
+            trace = undefined;
+        }
+        if (trace) {
+            return decodeWithdrawalRateLimited({ data: trace.output });
+        }
+        try {
+            await this.publicClient.call({ ...request, blockNumber });
+            return undefined;
+        }
+        catch (error) {
+            return decodeWithdrawalRateLimited(error);
+        }
+    }
     /**
      * Polls `GET /api/v1/withdrawals/{index}` until the gateway can serve the
      * `executeWithdrawal` calldata, then returns it with the vault address.
@@ -422,6 +550,8 @@ export class VaultAPIImpl extends BaseAPI {
      *   transaction plus `withdrawalIndex`; on poll-timeout or `autoWait=false`
      *   returns `{ withdrawalIndex, status: "awaiting_proof" }`.
      * @throws {APIError} When the asset is not found or the initiate request is rejected
+     * @throws {WithdrawalRateLimitedError} When the vault's withdrawal rate limit
+     *   refuses the withdrawal; the index stays valid for `retryWithdrawal`
      * @throws {ContractError} When the on-chain submission fails
      * @throws {InvalidConfigError} When wallet account is not available
      *
@@ -492,26 +622,7 @@ export class VaultAPIImpl extends BaseAPI {
         }
         const { vaultAddress, calldata } = poll;
         // 3. Submit the calldata on-chain through the connected wallet.
-        let hash;
-        try {
-            hash = await this.walletClient.sendTransaction({
-                to: vaultAddress,
-                data: calldata,
-                account: walletAccount,
-                chain: this.chain,
-            });
-        }
-        catch (error) {
-            throw new ContractError(`Failed to submit executeWithdrawal for withdrawal ${withdrawalIndex}: ${error instanceof Error ? error.message : "unknown error"}`, { cause: error instanceof Error ? error : undefined });
-        }
-        const nonce = walletAccount.getNonce ? await walletAccount.getNonce() : 0n;
-        const txResult = {
-            hash,
-            status: "pending",
-            nonce,
-        };
-        const settled = await this.waitForTransaction(txResult, autoWait);
-        return { ...settled, withdrawalIndex };
+        return await this.executeWithdrawalOnChain("submit", withdrawalIndex, vaultAddress, calldata, this.walletClient, walletAccount, autoWait);
     }
     /**
      * Submits (or resubmits) a previously-initiated withdrawal on-chain.
@@ -536,6 +647,8 @@ export class VaultAPIImpl extends BaseAPI {
      * @returns Promise resolving to a [`WithdrawResult`]: the submitted transaction
      *   plus `withdrawalIndex`, or `{ withdrawalIndex, status: "awaiting_proof" }`
      *   if the proof did not arrive within the poll window.
+     * @throws {WithdrawalRateLimitedError} When the vault's withdrawal rate limit
+     *   still refuses the withdrawal; retry again later
      * @throws {ContractError} When the on-chain submission fails
      * @throws {InvalidConfigError} When wallet account is not available
      */
@@ -554,26 +667,7 @@ export class VaultAPIImpl extends BaseAPI {
             return { withdrawalIndex, status: "awaiting_proof" };
         }
         const { vaultAddress, calldata } = poll;
-        let hash;
-        try {
-            hash = await this.walletClient.sendTransaction({
-                to: vaultAddress,
-                data: calldata,
-                account: walletAccount,
-                chain: this.chain,
-            });
-        }
-        catch (error) {
-            throw new ContractError(`Failed to resubmit executeWithdrawal for withdrawal ${withdrawalIndex}: ${error instanceof Error ? error.message : "unknown error"}`, { cause: error instanceof Error ? error : undefined });
-        }
-        const nonce = walletAccount.getNonce ? await walletAccount.getNonce() : 0n;
-        const txResult = {
-            hash,
-            status: "pending",
-            nonce,
-        };
-        const settled = await this.waitForTransaction(txResult, autoWait);
-        return { ...settled, withdrawalIndex };
+        return await this.executeWithdrawalOnChain("resubmit", withdrawalIndex, vaultAddress, calldata, this.walletClient, walletAccount, autoWait);
     }
     /**
      * Retrieves the user's token balance in the vault.

package/dist/api/websocket/websocket.js

@@ -445,6 +445,18 @@ function parseRfqSideViewEventData(raw) {
         ...(estimatedMonacoFee !== undefined && { estimatedMonacoFee }),
         ...(estimatedBuilderFee !== undefined && { estimatedBuilderFee }),
         ...(estimatedTotalFee !== undefined && { estimatedTotalFee }),
+        ...(raw.book != null && { book: parseRfqBookComparisonEventData(raw.book) }),
+    };
+}
+function parseRfqBookComparisonEventData(raw) {
+    if (!isRecord(raw)) {
+        throw new Error("Invalid RFQ view: a book comparison must be an object");
+    }
+    return {
+        vwap: readString(raw, "vwap"),
+        grossVwap: readString(raw, "grossVwap"),
+        asOfMs: readSequence(raw, "asOfMs"),
+        levels: readSequence(raw, "levels"),
     };
 }
 /** An optional wire integer that may be negative; absent or `null` is `undefined`. */
@@ -508,7 +520,7 @@ function parseRfqFillEventData(raw) {
         ...(builderFee !== undefined && { builderFee }),
     };
 }
-/** Parse the taker's outcome. Nothing filled leaves `vwap` absent and `fills` empty. */
+/** Parse the taker's outcome. Nothing filled leaves `vwap` and `allInVwap` absent and `fills` empty. */
 function parseRfqOutcomeEventData(raw) {
     if (!isRecord(raw)) {
         throw new Error("Invalid RFQ outcome: outcome must be an object");
@@ -517,11 +529,13 @@ function parseRfqOutcomeEventData(raw) {
         throw new Error("Invalid RFQ outcome: fills must be an array");
     }
     const vwap = readOptionalDecimalString(raw, "vwap");
+    const allInVwap = readOptionalDecimalString(raw, "allInVwap");
     return {
         executedQuantity: readString(raw, "executedQuantity"),
         unfilledQuantity: readString(raw, "unfilledQuantity"),
         ...(vwap !== undefined && { vwap }),
         fills: raw.fills.map(parseRfqFillEventData),
+        ...(allInVwap !== undefined && { allInVwap }),
     };
 }
 /** Parse an RFQ's end. Only the taker's push carries `outcome`. */
@@ -624,6 +638,21 @@ function parseAccountEvent(rawData) {
         data: parseAccountEventData(rawData.data),
     };
 }
+/** The frame's 24h volume split by source, or undefined when the frame omits it. */
+function parseDailyVolumeBySource(raw) {
+    if (raw === undefined || raw === null) {
+        return undefined;
+    }
+    if (!isRecord(raw)) {
+        throw new Error("Invalid market stats event: daily_volume_by_source must be an object");
+    }
+    return {
+        orderBookBaseTokenVolume: readString(raw, "orderBookBaseTokenVolume"),
+        rfqBaseTokenVolume: readString(raw, "rfqBaseTokenVolume"),
+        orderBookQuoteTokenVolume: readOptionalString(raw, "orderBookQuoteTokenVolume"),
+        rfqQuoteTokenVolume: readOptionalString(raw, "rfqQuoteTokenVolume"),
+    };
+}
 function parseMarketStatsData(raw) {
     if (!isRecord(raw)) {
         throw new Error("Invalid market stats event: data must be an object");
@@ -647,6 +676,7 @@ function parseMarketStatsData(raw) {
         dailyPriceHigh: readOptionalString(data, "dailyPriceHigh"),
         dailyPriceChange: readOptionalString(data, "dailyPriceChange"),
         dailyPriceChangePercent: readOptionalString(data, "dailyPriceChangePercent"),
+        dailyVolumeBySource: parseDailyVolumeBySource(data.dailyVolumeBySource),
         currentFundingRate: readOptionalString(data, "currentFundingRate"),
         fundingRate: readOptionalString(data, "fundingRate"),
         fundingTimestamp: readOptionalNumber(data, "fundingTimestamp"),

package/dist/errors/errors.d.ts

@@ -385,3 +385,47 @@ export declare class ContractError extends MonacoCoreError {
     });
     toJSON(): Record<string, unknown>;
 }
+/**
+ * Error thrown when the vault refuses a withdrawal because it exceeds the
+ * token's withdrawal rate limit (the contract's `WithdrawalRateLimited`
+ * revert).
+ *
+ * The vault caps how much withdrawals against recently confirmed roots can pay
+ * out at once, per token, and refills that allowance over time. A refused
+ * withdrawal is not lost: its balance is already debited and its index stays
+ * valid. Retry it with `sdk.vault.retryWithdrawal(withdrawalIndex)` once the
+ * limit has refilled, or once the withdrawal's root is a day old, when the limit
+ * no longer applies to it.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await sdk.vault.withdraw(assetId, amount);
+ * } catch (error) {
+ *   if (error instanceof WithdrawalRateLimitedError) {
+ *     // Keep error.withdrawalIndex and retry later.
+ *     console.log(`${error.available} of ${error.amount} can be paid out now`);
+ *   }
+ * }
+ * ```
+ */
+export declare class WithdrawalRateLimitedError extends ContractError {
+    /** The refused withdrawal's index; pass it to `retryWithdrawal`. */
+    readonly withdrawalIndex: number;
+    /** The limited token's address (WSEI's for native withdrawals). */
+    readonly token: string;
+    /** What the limit lets withdrawals pay out now, in the token's raw units. */
+    readonly available: bigint;
+    /** The withdrawal's amount, in the token's raw units. */
+    readonly amount: bigint;
+    constructor(withdrawalIndex: number, details: {
+        token: string;
+        available: bigint;
+        amount: bigint;
+        contractAddress?: string;
+        /** Set when the withdrawal was mined and reverted on-chain. */
+        transactionHash?: string;
+        cause?: Error;
+    });
+    toJSON(): Record<string, unknown>;
+}