@0xmonaco/core 0.8.11 → 0.8.15

package/dist/api/vault/api.js

@@ -28,6 +28,17 @@ import { ApproveTokenSchema, DepositSchema, validate, WithdrawSchema } from "@0x
 import { erc20Abi, zeroAddress } from "viem";
 import { APIError, ContractError, InvalidConfigError } from "../../errors";
 import { BaseAPI } from "../base";
+/** Default delay between polls while waiting for a withdrawal's proof. */
+const DEFAULT_WITHDRAWAL_POLL_INTERVAL_MS = 5_000;
+/**
+ * Default total wait for a withdrawal's proof (5 minutes). A withdrawal's merkle
+ * proof only lands after its root is confirmed on-chain, which on a healthy
+ * pipeline takes ~20s but can lag behind a brief proposer hiccup; the previous
+ * 60s tripped too eagerly. On timeout the SDK returns `awaiting_proof` rather
+ * than throwing, so the caller never loses the index — it just retries later.
+ */
+const DEFAULT_WITHDRAWAL_TIMEOUT_MS = 300_000;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /**
  * Encode the on-chain `applicationData` for a deposit.
  *
@@ -304,21 +315,80 @@ export class VaultAPIImpl extends BaseAPI {
         return await this.waitForTransaction(txResult, autoWait);
     }
     /**
-     * Initiates a withdrawal through the API Gateway and submits the resulting
-     * pre-signed calldata on-chain via the connected wallet.
+     * Polls `GET /api/v1/withdrawals/{index}` until the gateway can serve the
+     * `executeWithdrawal` calldata, then returns it with the vault address.
+     *
+     * The calldata only exists once the withdrawal's root is confirmed on-chain
+     * and its merkle proof is persisted. Until then the gateway returns 404 (the
+     * row is written asynchronously by the persistor after `initiate`) or 409
+     * (the proof is not confirmed yet); both are transient for a freshly-allocated
+     * index, so we retry on each until ready or the timeout elapses.
      *
-     * The gateway allocates a `withdrawalIndex` via the matching engine and returns
-     * ABI-encoded calldata for `executeSignedWithdrawal(...)` signed by the
-     * server-side `WITHDRAWAL_SIGNER`. The user's wallet pays gas to submit it,
-     * but the contract authenticates against the embedded signature — not the
-     * `msg.sender`. The connected wallet's address is sent as the on-chain
-     * `destination`.
+     * Returns `null` when the timeout elapses before the proof is available — the
+     * index is still valid and the balance already debited, so callers surface
+     * this as `awaiting_proof` (with the index intact) rather than as a thrown
+     * error that would strand the index. Only non-transient errors (anything
+     * other than 404/409) throw.
+     *
+     * @throws {APIError} On non-transient errors while polling.
+     */
+    async pollWithdrawalCalldata(withdrawalIndex, retry) {
+        const pollIntervalMs = retry?.pollIntervalMs ?? DEFAULT_WITHDRAWAL_POLL_INTERVAL_MS;
+        const timeoutMs = retry?.timeoutMs ?? DEFAULT_WITHDRAWAL_TIMEOUT_MS;
+        const deadline = Date.now() + timeoutMs;
+        for (;;) {
+            try {
+                const { vaultAddress, calldata } = await this.makePublicRequest(`/api/v1/withdrawals/${withdrawalIndex}`);
+                // Ready: non-empty calldata. (Defensively treat an empty/`0x` body as
+                // not-ready too, though the gateway returns an error in that case.)
+                if (calldata && calldata !== "0x") {
+                    return { vaultAddress, calldata };
+                }
+            }
+            catch (error) {
+                // 404 (row not persisted yet) and 409 (proof not confirmed yet) are
+                // transient for a valid index — keep polling. Anything else is fatal.
+                const isTransient = error instanceof APIError && (error.statusCode === 404 || error.statusCode === 409);
+                if (!isTransient) {
+                    throw error;
+                }
+            }
+            if (Date.now() + pollIntervalMs > deadline) {
+                // Timed out waiting for the proof. Signal not-ready; the caller keeps the
+                // index and retries later rather than losing it inside a thrown error.
+                return null;
+            }
+            await sleep(pollIntervalMs);
+        }
+    }
+    /**
+     * Initiates a withdrawal through the API Gateway, waits for its on-chain
+     * confirmation, then submits the resulting `executeWithdrawal` calldata via
+     * the connected wallet.
+     *
+     * The gateway allocates a `withdrawalIndex` via the matching engine and debits
+     * the balance immediately, but the executable calldata needs the withdrawal's
+     * merkle proof, which only exists once its root is confirmed on-chain. This
+     * method polls until the calldata is available (see `retry`), then submits it.
+     * The connected wallet pays gas; the contract authorises the withdrawal
+     * against the merkle proof embedded in the calldata. The wallet's address is
+     * sent as the on-chain `destination`.
+     *
+     * If the proof does not become available within the poll window, this method
+     * does NOT throw — it returns `{ withdrawalIndex, status: "awaiting_proof" }`
+     * with nothing submitted on-chain. The balance is already debited, so losing
+     * the index would strand the funds; the caller keeps it and finishes the
+     * withdrawal later with `retryWithdrawal(withdrawalIndex)`.
      *
      * @param assetId - The asset identifier (UUID) to withdraw
      * @param amount - The raw token amount to withdraw (as bigint)
      * @param autoWait - Whether to automatically wait for transaction confirmation (defaults to true)
-     * @returns Promise resolving to `{ withdrawalIndex, transaction }`
-     * @throws {APIError} When the asset is not found or the request is rejected
+     * @param sourceOrRetry - Source ledger (`"spot"` or `"margin"`) or legacy retry options
+     * @param retry - Polling cadence/timeout while waiting for the proof when a source is supplied
+     * @returns Promise resolving to a [`WithdrawResult`]: on success the submitted
+     *   transaction plus `withdrawalIndex`; on poll-timeout `{ withdrawalIndex,
+     *   status: "awaiting_proof" }`.
+     * @throws {APIError} When the asset is not found or the initiate request is rejected
      * @throws {ContractError} When the on-chain submission fails
      * @throws {InvalidConfigError} When wallet account is not available
      *
@@ -330,18 +400,23 @@ export class VaultAPIImpl extends BaseAPI {
      *   parseUnits("50", 6),
      * );
      * console.log(`Withdrawal index: ${result.withdrawalIndex}`);
-     * console.log(`Tx hash: ${result.hash}, status: ${result.status}`);
+     * if (result.status === "awaiting_proof") {
+     *   // Proof not ready yet — balance already debited. Finish later:
+     *   await vaultAPI.retryWithdrawal(result.withdrawalIndex);
+     * } else {
+     *   console.log(`Tx hash: ${result.hash}, status: ${result.status}`);
+     * }
      *
-     * // Or skip auto-waiting and finalise later
+     * // Custom polling (check every 10s, wait up to an hour)
      * const result = await vaultAPI.withdraw(
      *   "123e4567-e89b-12d3-a456-426614174000",
      *   parseUnits("50", 6),
-     *   false,
+     *   true,
+     *   { pollIntervalMs: 10_000, timeoutMs: 3_600_000 },
      * );
-     * const receipt = await sdk.waitForTransaction(result.hash);
      * ```
      */
-    async withdraw(assetId, amount, autoWait = true) {
+    async withdraw(assetId, amount, autoWait = true, sourceOrRetry, retry) {
         if (!this.walletClient) {
             throw new InvalidConfigError("Wallet client not set. Connect a wallet first.", "walletClient");
         }
@@ -350,21 +425,33 @@ export class VaultAPIImpl extends BaseAPI {
             throw new InvalidConfigError("No account available in wallet client", "account");
         }
         const destination = walletAccount.address.toLowerCase();
-        validate(WithdrawSchema, { assetId, amount, destination, autoWait });
-        // 1. Gateway allocates withdrawal_index + returns pre-signed
-        // executeSignedWithdrawal calldata along with the vault address to send
-        // it to. Sourcing the vault address from this response (instead of
-        // GET /applications/config) keeps the calldata + target contract in
-        // lockstep and avoids an extra round-trip.
-        const { withdrawal_index: withdrawalIndex, vault_address: vaultAddress, calldata, } = await this.makeAuthenticatedRequest("/api/v1/withdrawals", {
+        const source = typeof sourceOrRetry === "string" ? sourceOrRetry : "spot";
+        const retryOptions = typeof sourceOrRetry === "string" ? retry : sourceOrRetry;
+        validate(WithdrawSchema, { assetId, amount, destination, autoWait, source });
+        // 1. Gateway allocates the withdrawalIndex and debits the balance. No
+        // executable calldata yet — it needs the merkle proof, available only once
+        // the withdrawal root is confirmed on-chain.
+        const { withdrawalIndex } = await this.makeAuthenticatedRequest("/api/v1/withdrawals", {
             method: "POST",
             body: JSON.stringify({
-                asset_id: assetId,
+                assetId: assetId,
                 amount: amount.toString(),
                 destination,
+                source,
             }),
         });
-        // 2. Submit the calldata on-chain through the connected wallet.
+        // 2. Poll for the executeWithdrawal calldata until the proof is confirmed.
+        // The vault address comes back with it, keeping calldata + target contract
+        // in lockstep.
+        const poll = await this.pollWithdrawalCalldata(withdrawalIndex, retryOptions);
+        if (!poll) {
+            // Proof not available within the poll window. The balance is already
+            // debited and the index is valid; return it (without submitting anything
+            // on-chain) so the caller can finish later via retryWithdrawal(index).
+            return { withdrawalIndex, status: "awaiting_proof" };
+        }
+        const { vaultAddress, calldata } = poll;
+        // 3. Submit the calldata on-chain through the connected wallet.
         let hash;
         try {
             hash = await this.walletClient.sendTransaction({
@@ -375,7 +462,7 @@ export class VaultAPIImpl extends BaseAPI {
             });
         }
         catch (error) {
-            throw new ContractError(`Failed to submit executeSignedWithdrawal for withdrawal ${withdrawalIndex}: ${error instanceof Error ? error.message : "unknown error"}`, { cause: error instanceof Error ? error : undefined });
+            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 = {
@@ -387,25 +474,32 @@ export class VaultAPIImpl extends BaseAPI {
         return { ...settled, withdrawalIndex };
     }
     /**
-     * Retries a previously-initiated withdrawal whose on-chain submission never
-     * landed — e.g. the wallet rejected the tx, the page reloaded before the
-     * receipt came back, or a stuck mempool entry needs resending.
+     * Submits (or resubmits) a previously-initiated withdrawal on-chain.
      *
-     * Re-fetches the same `executeSignedWithdrawal` calldata the gateway
-     * generated when the withdrawal was initiated, then submits it through the
-     * connected wallet. Does NOT initiate a new withdrawal — the matching engine
-     * already debited the balance and allocated the index. The contract is
-     * idempotent against double-submission of a settled withdrawal: it will
-     * revert once the index is consumed on-chain.
+     * Use this when the original `withdraw()` could not complete — e.g. the proof
+     * was not yet confirmed within its polling window, the wallet rejected the tx,
+     * the page reloaded before the receipt came back, or a stuck mempool entry
+     * needs resending. Polls `GET /withdrawals/{index}` for the
+     * `executeWithdrawal` calldata (retrying while it is not yet confirmed), then
+     * submits it through the connected wallet. Does NOT initiate a new withdrawal
+     * — the matching engine already debited the balance and allocated the index.
+     * The contract is idempotent against double-submission of a settled
+     * withdrawal: it reverts once the index is consumed on-chain.
+     *
+     * Like `withdraw()`, if the proof is still unavailable within the poll window
+     * this returns `{ withdrawalIndex, status: "awaiting_proof" }` instead of
+     * throwing, so the caller can simply retry again later.
      *
      * @param withdrawalIndex - The index returned by the original `withdraw()` call
      * @param autoWait - Whether to await on-chain confirmation (defaults to true)
-     * @returns Promise resolving to `{ withdrawalIndex, ...transaction }`
-     * @throws {APIError} When the index doesn't exist
+     * @param retry - Polling cadence/timeout while waiting for the proof
+     * @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 {ContractError} When the on-chain submission fails
      * @throws {InvalidConfigError} When wallet account is not available
      */
-    async retryWithdrawal(withdrawalIndex, autoWait = true) {
+    async retryWithdrawal(withdrawalIndex, autoWait = true, retry) {
         if (!this.walletClient) {
             throw new InvalidConfigError("Wallet client not set. Connect a wallet first.", "walletClient");
         }
@@ -413,7 +507,13 @@ export class VaultAPIImpl extends BaseAPI {
         if (!walletAccount) {
             throw new InvalidConfigError("No account available in wallet client", "account");
         }
-        const { vault_address: vaultAddress, calldata } = await this.makePublicRequest(`/api/v1/withdrawals/${withdrawalIndex}`);
+        const poll = await this.pollWithdrawalCalldata(withdrawalIndex, retry);
+        if (!poll) {
+            // Still not confirmed on-chain within the poll window — return the index
+            // so the caller can retry again later, rather than throwing.
+            return { withdrawalIndex, status: "awaiting_proof" };
+        }
+        const { vaultAddress, calldata } = poll;
         let hash;
         try {
             hash = await this.walletClient.sendTransaction({
@@ -424,7 +524,7 @@ export class VaultAPIImpl extends BaseAPI {
             });
         }
         catch (error) {
-            throw new ContractError(`Failed to resubmit executeSignedWithdrawal for withdrawal ${withdrawalIndex}: ${error instanceof Error ? error.message : "unknown error"}`, { cause: error instanceof Error ? error : undefined });
+            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 = {

package/dist/api/whitelist/api.d.ts

@@ -8,8 +8,8 @@
  *
  * @example
  * ```typescript
- * const { message, user_id } = await sdk.whitelist.submit({
- *   wallet_address: "0x...",
+ * const { message, userId } = await sdk.whitelist.submit({
+ *   walletAddress: "0x...",
  *   email: "user@example.com",
  * });
  * ```

package/dist/api/whitelist/api.js

@@ -8,8 +8,8 @@
  *
  * @example
  * ```typescript
- * const { message, user_id } = await sdk.whitelist.submit({
- *   wallet_address: "0x...",
+ * const { message, userId } = await sdk.whitelist.submit({
+ *   walletAddress: "0x...",
  *   email: "user@example.com",
  * });
  * ```

package/dist/api/withdrawals/api.d.ts

@@ -1,15 +1,18 @@
-import type { InitiateWithdrawalRequest, WithdrawalResponse, WithdrawalsAPI } from "@0xmonaco/types";
+import type { InitiateWithdrawalRequest, ListPendingWithdrawalsParams, ListPendingWithdrawalsResponse, WithdrawalResponse, WithdrawalsAPI } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 /**
  * Low-level withdrawals client.
  *
  * `initiateWithdrawal` debits the caller's balance via the matching engine and
- * returns the target vault address plus pre-signed `executeSignedWithdrawal`
- * calldata; `getWithdrawal` re-fetches that calldata for a previously-initiated
- * index. Neither submits on-chain — use the high-level vault API for the flow
- * that also broadcasts the transaction.
+ * allocates a `withdrawalIndex` (its `calldata` is empty — the proof is not
+ * available until the withdrawal root is confirmed on-chain). `getWithdrawal`
+ * returns the `executeWithdrawal` calldata once that proof is ready, and throws
+ * an `APIError` (404 not-persisted-yet / 409 not-confirmed-yet) while it is not.
+ * Neither submits on-chain — use the high-level vault API, which polls for the
+ * calldata and broadcasts the transaction.
  */
 export declare class WithdrawalsAPIImpl extends BaseAPI implements WithdrawalsAPI {
     initiateWithdrawal(request: InitiateWithdrawalRequest): Promise<WithdrawalResponse>;
     getWithdrawal(withdrawalIndex: number): Promise<WithdrawalResponse>;
+    listPendingWithdrawals(params?: ListPendingWithdrawalsParams): Promise<ListPendingWithdrawalsResponse>;
 }

package/dist/api/withdrawals/api.js

@@ -4,19 +4,22 @@ import { perpRoutes } from "../perp";
  * Low-level withdrawals client.
  *
  * `initiateWithdrawal` debits the caller's balance via the matching engine and
- * returns the target vault address plus pre-signed `executeSignedWithdrawal`
- * calldata; `getWithdrawal` re-fetches that calldata for a previously-initiated
- * index. Neither submits on-chain — use the high-level vault API for the flow
- * that also broadcasts the transaction.
+ * allocates a `withdrawalIndex` (its `calldata` is empty — the proof is not
+ * available until the withdrawal root is confirmed on-chain). `getWithdrawal`
+ * returns the `executeWithdrawal` calldata once that proof is ready, and throws
+ * an `APIError` (404 not-persisted-yet / 409 not-confirmed-yet) while it is not.
+ * Neither submits on-chain — use the high-level vault API, which polls for the
+ * calldata and broadcasts the transaction.
  */
 export class WithdrawalsAPIImpl extends BaseAPI {
     async initiateWithdrawal(request) {
         return this.makeAuthenticatedRequest(perpRoutes.withdrawals.initiate(), {
             method: "POST",
             body: JSON.stringify({
-                asset_id: request.assetId,
+                assetId: request.assetId,
                 amount: request.amount,
                 destination: request.destination,
+                source: request.source ?? "spot",
             }),
         });
     }
@@ -24,4 +27,9 @@ export class WithdrawalsAPIImpl extends BaseAPI {
         // Public lookup — no auth required.
         return this.makePublicRequest(perpRoutes.withdrawals.byIndex(withdrawalIndex));
     }
+    async listPendingWithdrawals(params) {
+        // The gateway serves camelCase (the REST wire format), which matches the
+        // public surface, so the response is returned directly with no remapping.
+        return this.makeAuthenticatedRequest(perpRoutes.withdrawals.list({ page: params?.page, pageSize: params?.pageSize }));
+    }
 }

package/dist/coverage.d.ts

@@ -5,6 +5,7 @@ export declare const COVERED: {
     batch_cancel_all: string;
     batch_cancel_all_by_pair: string;
     batch_cancel_orders: string;
+    batch_close_all_positions: string;
     batch_create_orders: string;
     batch_replace_orders: string;
     cancel_conditional_order: string;
@@ -36,6 +37,8 @@ export declare const COVERED: {
     get_portfolio_stats: string;
     get_position: string;
     get_position_risk: string;
+    get_parent_margin_account_movements: string;
+    get_parent_margin_account_summary: string;
     get_screener: string;
     get_sub_account_limits: string;
     get_trade_by_id: string;
@@ -48,6 +51,7 @@ export declare const COVERED: {
     get_user_trades: string;
     get_withdrawal: string;
     initiate_withdrawal: string;
+    list_pending_withdrawals: string;
     list_application_balances: string;
     list_application_movements: string;
     list_application_orders: string;
@@ -68,13 +72,16 @@ export declare const COVERED: {
     replace_order: string;
     revoke_delegated_agent: string;
     revoke_session: string;
-    simulate_auto_margin_order_risk: string;
+    simulate_risk_bucket_order_risk: string;
     simulate_fees: string;
     simulate_order_risk: string;
+    simulate_parent_margin_order_risk: string;
     submit_whitelist: string;
+    transfer_collateral_from_parent_margin_account: string;
     transfer_collateral_from_margin_account: string;
-    transfer_collateral_to_auto_margin_account: string;
     transfer_collateral_to_margin_account: string;
+    transfer_collateral_to_parent_margin_account: string;
+    transfer_collateral_to_risk_bucket: string;
     update_sub_account_limit: string;
     upsert_delegated_agent: string;
     verify_signature: string;

package/dist/coverage.js

@@ -5,6 +5,7 @@ export const COVERED = {
     batch_cancel_all: "batchCancelAll",
     batch_cancel_all_by_pair: "batchCancelAll (with tradingPairId)",
     batch_cancel_orders: "batchCancel",
+    batch_close_all_positions: "batchCloseAllPositions",
     batch_create_orders: "batchCreate",
     batch_replace_orders: "batchReplace",
     cancel_conditional_order: "cancelConditionalOrder",
@@ -36,6 +37,8 @@ export const COVERED = {
     get_portfolio_stats: "getPortfolioStats",
     get_position: "getPosition",
     get_position_risk: "getPositionRisk",
+    get_parent_margin_account_movements: "getParentMarginAccountMovements",
+    get_parent_margin_account_summary: "getParentMarginAccountSummary",
     get_screener: "getScreener",
     get_sub_account_limits: "subAccounts.getLimits",
     get_trade_by_id: "getTradeById",
@@ -48,6 +51,7 @@ export const COVERED = {
     get_user_trades: "getUserTrades",
     get_withdrawal: "getWithdrawal",
     initiate_withdrawal: "initiateWithdrawal",
+    list_pending_withdrawals: "listPendingWithdrawals",
     list_application_balances: "listApplicationBalances",
     list_application_movements: "listApplicationMovements",
     list_application_orders: "listApplicationOrders",
@@ -68,13 +72,16 @@ export const COVERED = {
     replace_order: "replaceOrder",
     revoke_delegated_agent: "revokeDelegatedAgent",
     revoke_session: "revokeSession",
-    simulate_auto_margin_order_risk: "simulateAutoMarginOrderRisk",
+    simulate_risk_bucket_order_risk: "simulateRiskBucketOrderRisk",
     simulate_fees: "simulateFees",
     simulate_order_risk: "simulateOrderRisk",
+    simulate_parent_margin_order_risk: "simulateParentMarginOrderRisk",
     submit_whitelist: "whitelist.submit",
+    transfer_collateral_from_parent_margin_account: "transferCollateralFromParentMarginAccount",
     transfer_collateral_from_margin_account: "transferCollateralFromMarginAccount",
-    transfer_collateral_to_auto_margin_account: "transferCollateralToAutoMarginAccount",
     transfer_collateral_to_margin_account: "transferCollateralToMarginAccount",
+    transfer_collateral_to_parent_margin_account: "transferCollateralToParentMarginAccount",
+    transfer_collateral_to_risk_bucket: "transferCollateralToRiskBucket",
     update_sub_account_limit: "subAccounts.updateLimit",
     upsert_delegated_agent: "upsertDelegatedAgent",
     verify_signature: "verifySignature",

package/dist/sdk.d.ts

@@ -1,5 +1,5 @@
 import type { ApplicationsAPI, AuthAPI, AuthState, DelegatedAgentsAPI, FaucetAPI, FeesAPI, MarginAccountsAPI, MarketAPI, MonacoSDK, Network, PositionsAPI, ProfileAPI, SDKConfig, SubAccountsAPI, TradingAPI, VaultAPI, WhitelistAPI, WithdrawalsAPI } from "@0xmonaco/types";
-import { type PublicClient, type TransactionReceipt, type WalletClient } from "viem";
+import { type Address, type PublicClient, type TransactionReceipt, type WalletClient } from "viem";
 import { type MonacoWebSocket, OrderbookAPIImpl, TradesAPIImpl } from "./api";
 export declare class MonacoSDKImpl implements MonacoSDK {
     auth: AuthAPI;
@@ -147,7 +147,7 @@ export declare class MonacoSDKImpl implements MonacoSDK {
     /**
      * Get the current account address
      */
-    getAccountAddress(): string;
+    getAccountAddress(): Address;
     /**
      * Get the current network
      */

package/dist/sdk.js

@@ -242,10 +242,10 @@ export class MonacoSDKImpl {
         this.authState = {
             sessionPublicKey: session.publicKey,
             sessionPrivateKey: session.privateKey,
-            expiresAt: delegatedSession.expires_at,
+            expiresAt: delegatedSession.expiresAt,
             user: {
-                id: delegatedSession.owner_user_id,
-                address: delegatedSession.agent_address,
+                id: delegatedSession.ownerUserId,
+                address: delegatedSession.agentAddress,
             },
         };
         this.propagateSession(this.sessionFromAuthState(this.authState));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/core",
-	"version": "0.8.11",
+	"version": "0.8.15",
 	"type": "module",
 	"repository": {
 		"type": "git",
@@ -23,8 +23,8 @@
 		"viem": "^2.45.2"
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "0.8.11",
-		"@0xmonaco/types": "0.8.11",
+		"@0xmonaco/contracts": "0.8.15",
+		"@0xmonaco/types": "0.8.15",
 		"@noble/curves": "^1.9.1",
 		"@noble/hashes": "^1.8.0",
 		"http-status-codes": "^2.3.0"