@0xmonaco/core 1.0.39 → 1.0.41-develop.ebb62ed

package/dist/api/margin-accounts/api.js

@@ -72,6 +72,7 @@ export class MarginAccountsAPIImpl extends BaseAPI {
                 amount: request.amount,
                 tradingPairId: request.tradingPairId,
                 strategyKey: request.strategyKey,
+                marginMode: request.marginMode,
             }),
         });
     }

package/dist/api/market/api.js

@@ -54,6 +54,7 @@ export class MarketAPIImpl extends BaseAPI {
             startTime: params?.startTime,
             endTime: params?.endTime,
             limit: params?.limit,
+            priceType: params?.priceType,
         });
         const searchParams = new URLSearchParams();
         if (params?.startTime !== undefined) {
@@ -65,6 +66,9 @@ export class MarketAPIImpl extends BaseAPI {
         if (params?.limit !== undefined) {
             searchParams.append("limit", params.limit.toString());
         }
+        if (params?.priceType !== undefined) {
+            searchParams.append("priceType", params.priceType);
+        }
         const queryString = searchParams.toString();
         const url = queryString
             ? `/api/v1/market/pairs/charts/candlestick/${encodeURIComponent(tradingPairId)}/${interval}?${queryString}`

package/dist/api/perp/routes.d.ts

@@ -170,8 +170,6 @@ export declare const perpRoutes: {
         readonly close: (positionId: string) => string;
         readonly batchCloseAll: () => string;
         readonly risk: (positionId: string) => string;
-        readonly addMargin: (positionId: string) => string;
-        readonly reduceMargin: (positionId: string) => string;
         readonly attachTpSl: (positionId: string) => string;
         readonly history: (params?: {
             positionId?: string;

package/dist/api/perp/routes.js

@@ -94,8 +94,6 @@ export const perpRoutes = {
         close: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}/close`,
         batchCloseAll: () => `${API_V1}/positions/batch-close-all`,
         risk: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}/risk`,
-        addMargin: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}/margin/add`,
-        reduceMargin: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}/margin/reduce`,
         attachTpSl: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}/tp-sl`,
         history: (params) => withQuery(`${API_V1}/positions/history`, params),
         pnlHistory: (positionId, params) => withQuery(`${API_V1}/positions/${encodeSegment(positionId)}/pnl/history`, params),

package/dist/api/positions/api.d.ts

@@ -1,4 +1,4 @@
-import type { AddPositionMarginRequest, AttachPositionTpSlRequest, AttachPositionTpSlResponse, BatchCloseAllRequest, BatchCloseAllResponse, ClosePositionRequest, ClosePositionResponse, GetPositionPnlHistoryParams, GetPositionPnlHistoryResponse, GetPositionResponse, ListPositionHistoryParams, ListPositionHistoryResponse, ListPositionsParams, ListPositionsResponse, PositionMarginResponse, PositionRisk, PositionsAPI, ReducePositionMarginRequest } from "@0xmonaco/types";
+import type { AttachPositionTpSlRequest, AttachPositionTpSlResponse, BatchCloseAllRequest, BatchCloseAllResponse, ClosePositionRequest, ClosePositionResponse, GetPositionPnlHistoryParams, GetPositionPnlHistoryResponse, GetPositionResponse, ListPositionHistoryParams, ListPositionHistoryResponse, ListPositionsParams, ListPositionsResponse, PositionRisk, PositionsAPI } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class PositionsAPIImpl extends BaseAPI implements PositionsAPI {
     listPositions(params?: ListPositionsParams): Promise<ListPositionsResponse>;
@@ -6,8 +6,6 @@ export declare class PositionsAPIImpl extends BaseAPI implements PositionsAPI {
     closePosition(positionId: string, request: ClosePositionRequest): Promise<ClosePositionResponse>;
     batchCloseAllPositions(request?: BatchCloseAllRequest): Promise<BatchCloseAllResponse>;
     getPositionRisk(positionId: string): Promise<PositionRisk>;
-    addPositionMargin(positionId: string, request: AddPositionMarginRequest): Promise<PositionMarginResponse>;
-    reducePositionMargin(positionId: string, request: ReducePositionMarginRequest): Promise<PositionMarginResponse>;
     attachPositionTpSl(positionId: string, request: AttachPositionTpSlRequest): Promise<AttachPositionTpSlResponse>;
     listPositionHistory(params?: ListPositionHistoryParams): Promise<ListPositionHistoryResponse>;
     getPositionPnlHistory(positionId: string, params: GetPositionPnlHistoryParams): Promise<GetPositionPnlHistoryResponse>;

package/dist/api/positions/api.js

@@ -1,4 +1,4 @@
-import { AddPositionMarginSchema, AttachPositionTpSlSchema, BatchCloseAllSchema, ClosePositionSchema, GetPositionPnlHistorySchema, GetPositionRiskSchema, GetPositionSchema, ListPositionHistorySchema, ListPositionsSchema, ReducePositionMarginSchema, validate, } from "@0xmonaco/types";
+import { AttachPositionTpSlSchema, BatchCloseAllSchema, ClosePositionSchema, GetPositionPnlHistorySchema, GetPositionRiskSchema, GetPositionSchema, ListPositionHistorySchema, ListPositionsSchema, validate, } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp";
 export class PositionsAPIImpl extends BaseAPI {
@@ -40,25 +40,6 @@ export class PositionsAPIImpl extends BaseAPI {
         validate(GetPositionRiskSchema, { positionId });
         return await this.makeAuthenticatedRequest(perpRoutes.positions.risk(positionId));
     }
-    async addPositionMargin(positionId, request) {
-        validate(AddPositionMarginSchema, { positionId, request });
-        return await this.makeAuthenticatedRequest(perpRoutes.positions.addMargin(positionId), {
-            method: "POST",
-            body: JSON.stringify({
-                amount: request.amount,
-                asset: request.asset,
-            }),
-        });
-    }
-    async reducePositionMargin(positionId, request) {
-        validate(ReducePositionMarginSchema, { positionId, request });
-        return await this.makeAuthenticatedRequest(perpRoutes.positions.reduceMargin(positionId), {
-            method: "POST",
-            body: JSON.stringify({
-                amount: request.amount,
-            }),
-        });
-    }
     async attachPositionTpSl(positionId, request) {
         validate(AttachPositionTpSlSchema, { positionId, request });
         return await this.makeAuthenticatedRequest(perpRoutes.positions.attachTpSl(positionId), {

package/dist/api/trading/api.d.ts

@@ -88,6 +88,7 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         leverage?: string;
         reduceOnly?: boolean;
         postOnly?: boolean;
+        clientOrderId?: string;
         takeProfit?: ParentTpSlLegParams;
         stopLoss?: ParentTpSlLegParams;
     }): Promise<CreateOrderResponse>;
@@ -147,6 +148,7 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         reduceOnly?: boolean;
         takeProfit?: ParentTpSlLegParams;
         stopLoss?: ParentTpSlLegParams;
+        clientOrderId?: string;
     }): Promise<CreateOrderResponse>;
     /**
      * Cancels an existing order.
@@ -203,6 +205,7 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         quantity?: string;
         useMasterBalance?: boolean;
         postOnly?: boolean;
+        clientOrderId?: string;
     }): Promise<ReplaceOrderResponse>;
     /**
      * Batch creates multiple orders in a single request.

package/dist/api/trading/api.js

@@ -34,6 +34,11 @@ function parentTpSlLegToRequest(leg) {
         timeInForce: leg.timeInForce,
         slippageToleranceBps: leg.slippageToleranceBps,
         expiresAt: leg.expiresAt,
+        // The leg's sizing contract. Omitting these sends neither field, which the
+        // server reads as the legacy "size from the parent order" shape — so a
+        // caller asking to track the position would silently get a frozen partial.
+        quantity: leg.quantity,
+        closePosition: leg.closePosition,
     };
 }
 export class TradingAPIImpl extends BaseAPI {
@@ -115,6 +120,7 @@ export class TradingAPIImpl extends BaseAPI {
             leverage: options?.leverage,
             reduceOnly: options?.reduceOnly,
             postOnly: options?.postOnly,
+            clientOrderId: options?.clientOrderId,
             takeProfit: parentTpSlLegToRequest(options?.takeProfit),
             stopLoss: parentTpSlLegToRequest(options?.stopLoss),
         };
@@ -192,6 +198,7 @@ export class TradingAPIImpl extends BaseAPI {
             reduceOnly: options?.reduceOnly,
             takeProfit: parentTpSlLegToRequest(options?.takeProfit),
             stopLoss: parentTpSlLegToRequest(options?.stopLoss),
+            clientOrderId: options?.clientOrderId,
         };
         return await this.makeAuthenticatedRequest(perpRoutes.orders.create(), {
             method: "POST",
@@ -308,6 +315,9 @@ export class TradingAPIImpl extends BaseAPI {
         if (newOrder.postOnly !== undefined) {
             requestBody.postOnly = newOrder.postOnly;
         }
+        if (newOrder.clientOrderId !== undefined) {
+            requestBody.clientOrderId = newOrder.clientOrderId;
+        }
         return await this.makeAuthenticatedRequest(perpRoutes.orders.replace(orderId), {
             method: "PUT",
             body: JSON.stringify(requestBody),
@@ -366,6 +376,7 @@ export class TradingAPIImpl extends BaseAPI {
                 leverage: order.leverage,
                 reduceOnly: order.reduceOnly,
                 postOnly: order.postOnly,
+                clientOrderId: order.clientOrderId,
             })),
         };
         return this.makeAuthenticatedRequest(perpRoutes.orders.batchCreate(), {
@@ -407,6 +418,7 @@ export class TradingAPIImpl extends BaseAPI {
                 quantity: order.quantity,
                 useMasterBalance: order.useMasterBalance,
                 postOnly: order.postOnly,
+                clientOrderId: order.clientOrderId,
             })),
         };
         return this.makeAuthenticatedRequest(perpRoutes.orders.batchReplace(), {

package/dist/api/websocket/types.d.ts

@@ -1,4 +1,4 @@
-import type { ConditionalOrderEvent, Interval, LiquidationEvent, MonacoWebSocketConfig, OHLCVEvent, OrderbookEvent, OrderbookQuotationMode, OrderEvent, PositionEvent, SessionCredentials, TradeEvent, TradingMode, UserBalanceEvent, UserMovementEvent, WebSocketStatus } from "@0xmonaco/types";
+import type { AccountEvent, ConditionalOrderEvent, Interval, LiquidationEvent, MarketStatsAllEvent, MarketStatsEvent, MonacoWebSocketConfig, OHLCVEvent, OrderbookEvent, OrderbookQuotationMode, OrderEvent, PositionEvent, SessionCredentials, TradeEvent, TradingMode, UserBalanceEvent, UserMovementEvent, WebSocketStatus } from "@0xmonaco/types";
 export type { ResyncHandler, StatusHandler, WebSocketResyncInfo } from "@0xmonaco/types";
 export type MessageHandler<T> = (data: T) => void;
 /**
@@ -42,4 +42,10 @@ export interface MonacoWebSocket {
     positions: (handler: MessageHandler<PositionEvent>, tradingPairId?: string) => () => void;
     /** Subscribe to liquidation alerts (requires authentication); omit `tradingPairId` for all pairs */
     liquidations: (handler: MessageHandler<LiquidationEvent>, tradingPairId?: string) => () => void;
+    /** Subscribe to account-level margin health updates for the authenticated user (requires authentication) */
+    account: (handler: MessageHandler<AccountEvent>) => () => void;
+    /** Subscribe to per-market statistics for one trading pair (public) */
+    marketStats: (tradingPairId: string, handler: MessageHandler<MarketStatsEvent>) => () => void;
+    /** Subscribe to the all-markets statistics summary (public) */
+    marketStatsAll: (handler: MessageHandler<MarketStatsAllEvent>) => () => void;
 }

package/dist/api/websocket/websocket.js

@@ -133,6 +133,8 @@ function parsePositionEvent(rawData) {
             liquidationPrice: readOptionalString(data, "liquidationPrice"),
             isolatedMargin: readString(data, "isolatedMargin"),
             leverage: readString(data, "leverage"),
+            tradeId: readOptionalString(data, "tradeId"),
+            orderId: readOptionalString(data, "orderId"),
             reason: readString(data, "reason"),
             updatedAt: readString(data, "updatedAt"),
         },
@@ -168,6 +170,104 @@ function parseLiquidationEvent(rawData) {
         },
     };
 }
+function parseAccountEvent(rawData) {
+    if (!isRecord(rawData)) {
+        throw new Error("Invalid account event: payload must be an object");
+    }
+    if (!isRecord(rawData.data)) {
+        throw new Error("Invalid account event: data must be an object");
+    }
+    const data = keysToCamelCase(rawData.data);
+    return {
+        // event_type is the event-class discriminator, validated strictly so a
+        // mis-routed frame is rejected rather than parsed as an account update.
+        eventType: readEnum(rawData, "event_type", ["account_update"]),
+        userId: readString(rawData, "user_id"),
+        data: {
+            marginAccountId: readString(data, "marginAccountId"),
+            equity: readString(data, "equity"),
+            collateral: readString(data, "collateral"),
+            freeCollateral: readString(data, "freeCollateral"),
+            marginRatio: readString(data, "marginRatio"),
+            maintenanceRequirement: readString(data, "maintenanceRequirement"),
+            updatedAt: readString(data, "updatedAt"),
+        },
+    };
+}
+function parseMarketStatsData(raw) {
+    if (!isRecord(raw)) {
+        throw new Error("Invalid market stats event: data must be an object");
+    }
+    const data = keysToCamelCase(raw);
+    return {
+        symbol: readString(data, "symbol"),
+        tradingPairId: readString(data, "tradingPairId"),
+        indexPrice: readOptionalString(data, "indexPrice"),
+        markPrice: readOptionalString(data, "markPrice"),
+        midPrice: readOptionalString(data, "midPrice"),
+        bestBidPrice: readOptionalString(data, "bestBidPrice"),
+        bestAskPrice: readOptionalString(data, "bestAskPrice"),
+        openInterest: readOptionalString(data, "openInterest"),
+        openInterestLimit: readOptionalString(data, "openInterestLimit"),
+        lastTradePrice: readOptionalString(data, "lastTradePrice"),
+        dailyBaseTokenVolume: readOptionalString(data, "dailyBaseTokenVolume"),
+        dailyQuoteTokenVolume: readOptionalString(data, "dailyQuoteTokenVolume"),
+        dailyPriceLow: readOptionalString(data, "dailyPriceLow"),
+        dailyPriceHigh: readOptionalString(data, "dailyPriceHigh"),
+        dailyPriceChange: readOptionalString(data, "dailyPriceChange"),
+        dailyPriceChangePercent: readOptionalString(data, "dailyPriceChangePercent"),
+        currentFundingRate: readOptionalString(data, "currentFundingRate"),
+        fundingRate: readOptionalString(data, "fundingRate"),
+        fundingTimestamp: readOptionalNumber(data, "fundingTimestamp"),
+        premium: readOptionalString(data, "premium"),
+        baseInterestRate: readOptionalString(data, "baseInterestRate"),
+        fundingClampSmall: readOptionalString(data, "fundingClampSmall"),
+        fundingClampBig: readOptionalString(data, "fundingClampBig"),
+    };
+}
+function parseMarketStatsEvent(rawData) {
+    if (!isRecord(rawData)) {
+        throw new Error("Invalid market stats event: payload must be an object");
+    }
+    // The per-market frame's top-level `trading_pair_id` is not inside `data`, so
+    // it stays snake_case (only `data` is camelCased by parseMarketStatsData).
+    return {
+        tradingPairId: readString(rawData, "trading_pair_id"),
+        data: parseMarketStatsData(rawData.data),
+    };
+}
+function parseMarketStatsSummary(raw) {
+    if (!isRecord(raw)) {
+        throw new Error("Invalid market stats summary: entry must be an object");
+    }
+    const data = keysToCamelCase(raw);
+    return {
+        tradingPairId: readString(data, "tradingPairId"),
+        symbol: readString(data, "symbol"),
+        lastTradePrice: readOptionalString(data, "lastTradePrice"),
+        markPrice: readOptionalString(data, "markPrice"),
+        dailyPriceChange: readOptionalString(data, "dailyPriceChange"),
+        dailyPriceChangePercent: readOptionalString(data, "dailyPriceChangePercent"),
+        dailyBaseTokenVolume: readOptionalString(data, "dailyBaseTokenVolume"),
+        dailyQuoteTokenVolume: readOptionalString(data, "dailyQuoteTokenVolume"),
+        dailyPriceHigh: readOptionalString(data, "dailyPriceHigh"),
+        dailyPriceLow: readOptionalString(data, "dailyPriceLow"),
+        openInterest: readOptionalString(data, "openInterest"),
+        currentFundingRate: readOptionalString(data, "currentFundingRate"),
+        fundingTimestamp: readOptionalNumber(data, "fundingTimestamp"),
+        // marketStatus stays lenient (read as string, not a strict enum) so an
+        // unrecognized status value never drops an otherwise-valid summary row.
+        marketStatus: readString(data, "marketStatus"),
+    };
+}
+function parseMarketStatsAllEvent(rawData) {
+    if (!isRecord(rawData) || !Array.isArray(rawData.markets)) {
+        throw new Error("Invalid market stats all event: markets must be an array");
+    }
+    return {
+        markets: rawData.markets.map(parseMarketStatsSummary),
+    };
+}
 /**
  * Create a Monaco WebSocket client
  */
@@ -488,15 +588,21 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                         quantity: level.quantity,
                         orderCount: level.order_count || 0,
                     })),
-                    bestBid: orderbookData?.best_bid,
-                    bestAsk: orderbookData?.best_ask,
+                    // Rust sends `null` for an empty side; normalize the nullable
+                    // `Option` to `undefined` so it matches the `string | undefined` type
+                    // rather than leaking `null` past the cast.
+                    bestBid: orderbookData?.best_bid ?? undefined,
+                    bestAsk: orderbookData?.best_ask ?? undefined,
                     bidVolume: orderbookData?.bid_volume || undefined,
                     askVolume: orderbookData?.ask_volume || undefined,
                     priceChange: orderbookData?.price_change
                         ? {
                             side: orderbookData.price_change.side,
-                            oldPrice: orderbookData.price_change.old_price,
-                            newPrice: orderbookData.price_change.new_price,
+                            // Normalize nullable Rust `Option` prices to `undefined` (a
+                            // level-add has no old price, a level-remove no new price) so
+                            // neither leaks `null` past the `string | undefined` type.
+                            oldPrice: orderbookData.price_change.old_price ?? undefined,
+                            newPrice: orderbookData.price_change.new_price ?? undefined,
                             levelRemoved: orderbookData.price_change.level_removed || false,
                             levelAdded: orderbookData.price_change.level_added || false,
                         }
@@ -584,7 +690,10 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                         id: movementData.id,
                         entryType: movementData.entry_type,
                         transactionType: movementData.transaction_type,
-                        tokenAddress: movementData.token_address,
+                        status: movementData.status,
+                        token: (movementData.token ?? movementData.token_address),
+                        tokenAddress: (movementData.token ?? movementData.token_address),
+                        assetId: movementData.asset_id,
                         amount: String(movementData.amount),
                         amountRaw: movementData.amount_raw,
                         balanceBefore: movementData.balance_before != null ? String(movementData.balance_before) : undefined,
@@ -595,6 +704,7 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                         referenceType: movementData.reference_type,
                         description: movementData.description,
                         txHash: movementData.tx_hash,
+                        blockNumber: movementData.block_number,
                         createdAt: movementData.created_at,
                         decimals: movementData.decimals,
                     },
@@ -729,6 +839,72 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
             }
         });
     };
+    /**
+     * Subscribe to the authenticated user's account-level margin health updates
+     * (equity, collateral, free collateral, margin ratio, maintenance
+     * requirement). Requires authentication - the user is identified from the
+     * signed session-key handshake. Lag policy is Conflate: a lagging subscriber
+     * is fast-forwarded, no gap signal. Each frame is a terminal-state snapshot
+     * per margin account, not an additive delta.
+     */
+    const subscribeAccount = (handler) => {
+        if (!handler) {
+            throw new Error("account subscription requires a handler");
+        }
+        return subscribe("account", (rawData) => {
+            try {
+                handler(parseAccountEvent(rawData));
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing account event", err);
+            }
+        });
+    };
+    /**
+     * Subscribe to per-market statistics for a single trading pair (public). Each
+     * frame carries the market's full current stats as a terminal-state snapshot.
+     * Use {@link subscribeMarketStatsAll} for the all-markets summary instead.
+     */
+    const subscribeMarketStats = (tradingPairId, handler) => {
+        if (!tradingPairId) {
+            throw new Error("marketStats subscription requires a tradingPairId");
+        }
+        if (!handler) {
+            throw new Error("marketStats subscription requires a handler");
+        }
+        return subscribe(`market_stats:${tradingPairId}`, (rawData) => {
+            try {
+                handler(parseMarketStatsEvent(rawData));
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing market stats event", err);
+            }
+        });
+    };
+    /**
+     * Subscribe to the all-markets statistics summary (public): one summary row
+     * per market in a single frame per push.
+     */
+    const subscribeMarketStatsAll = (handler) => {
+        if (!handler) {
+            throw new Error("marketStatsAll subscription requires a handler");
+        }
+        return subscribe("market_stats", (rawData) => {
+            // routeMessage prefix-matches the bare `market_stats` subscription against
+            // per-market `market_stats:<pair>` frames too; those carry
+            // `{ trading_pair_id, data }`, not `{ markets }`. Drop them here so the
+            // all-markets handler only ever sees all-markets frames.
+            if (!isRecord(rawData) || !Array.isArray(rawData.markets)) {
+                return;
+            }
+            try {
+                handler(parseMarketStatsAllEvent(rawData));
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing market stats all event", err);
+            }
+        });
+    };
     return {
         connect,
         disconnect,
@@ -759,5 +935,8 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
         conditionalOrders: subscribeConditionalOrders,
         positions: subscribePositions,
         liquidations: subscribeLiquidations,
+        account: subscribeAccount,
+        marketStats: subscribeMarketStats,
+        marketStatsAll: subscribeMarketStatsAll,
     };
 }

package/dist/coverage.d.ts

@@ -1,6 +1,5 @@
 /** operationId → the @0xmonaco/core client method that covers it. */
 export declare const COVERED: {
-    add_position_margin: string;
     attach_position_tp_sl: string;
     batch_cancel_all: string;
     batch_cancel_all_by_pair: string;
@@ -84,7 +83,6 @@ export declare const COVERED: {
     list_sub_accounts_with_balances: string;
     list_trading_pairs: string;
     mint_tokens: string;
-    reduce_position_margin: string;
     refresh_session: string;
     replace_order: string;
     revoke_delegated_agent: string;

package/dist/coverage.js

@@ -1,6 +1,5 @@
 /** operationId → the @0xmonaco/core client method that covers it. */
 export const COVERED = {
-    add_position_margin: "addPositionMargin",
     attach_position_tp_sl: "attachPositionTpSl",
     batch_cancel_all: "batchCancelAll",
     batch_cancel_all_by_pair: "batchCancelAll (with tradingPairId)",
@@ -84,7 +83,6 @@ export const COVERED = {
     list_sub_accounts_with_balances: "subAccounts.list",
     list_trading_pairs: "getPaginatedTradingPairs",
     mint_tokens: "faucet.mint",
-    reduce_position_margin: "reducePositionMargin",
     refresh_session: "refreshSession",
     replace_order: "replaceOrder",
     revoke_delegated_agent: "revokeDelegatedAgent",

package/package.json

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