@0xmonaco/core 1.0.55 → 1.0.57

package/dist/api/base.js

@@ -20,7 +20,7 @@
  * }
  * ```
  */
-import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils";
+import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
 import { StatusCodes } from "http-status-codes";
 import { buildHttpSignatureHeaders } from "../crypto/http-signatures";
 import { composeSigningString, keypairFromHex, sha256Hex, signMessage } from "../crypto/session";

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

@@ -164,6 +164,7 @@ export declare const perpRoutes: {
     };
     readonly sweeper: {
         readonly register: () => string;
+        readonly chains: () => string;
     };
     readonly whitelist: {
         readonly submit: () => string;

package/dist/api/perp/routes.js

@@ -89,6 +89,7 @@ export const perpRoutes = {
     },
     sweeper: {
         register: () => `${API_V1}/sweeper/register`,
+        chains: () => `${API_V1}/sweeper/chains`,
     },
     whitelist: {
         submit: () => `${API_V1}/whitelist`,

package/dist/api/sweeper/api.d.ts

@@ -22,7 +22,7 @@
  * const margin = await sdk.sweeper.register({ depositTarget: "margin" });
  * ```
  */
-import type { RegisterSweeperRequest, RegisterSweeperResponse, SweeperAPI } from "@0xmonaco/types";
+import type { GetSweeperChainsResponse, RegisterSweeperRequest, RegisterSweeperResponse, SweeperAPI } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class SweeperAPIImpl extends BaseAPI implements SweeperAPI {
     /**
@@ -42,10 +42,25 @@ export declare class SweeperAPIImpl extends BaseAPI implements SweeperAPI {
      * rather than a guarantee, since a deposit the backend cannot route to
      * collateral is credited to the spot wallet instead.
      *
+     * The deposit address is identical on every supported chain and one
+     * registration is watched on all of them (see {@link getChains} for the
+     * set), so there is nothing chain-specific to pass.
+     *
      * @param body - Optionally the destination ledger; everything else comes
      *   from the session
      * @returns Promise resolving to the deposit address and the initial-check
      *   state
      */
     register(body?: RegisterSweeperRequest): Promise<RegisterSweeperResponse>;
+    /**
+     * The chains and assets the sweeper watches: where a registered deposit
+     * address accepts deposits, which tokens are swept on each chain, and each
+     * token's minimum sweep amount in raw base units.
+     *
+     * Public — no session needed. The set changes only with operator
+     * configuration, so it is safe to cache briefly.
+     *
+     * @returns Promise resolving to the supported chain/asset listing
+     */
+    getChains(): Promise<GetSweeperChainsResponse>;
 }

package/dist/api/sweeper/api.js

@@ -69,6 +69,10 @@ export class SweeperAPIImpl extends BaseAPI {
      * rather than a guarantee, since a deposit the backend cannot route to
      * collateral is credited to the spot wallet instead.
      *
+     * The deposit address is identical on every supported chain and one
+     * registration is watched on all of them (see {@link getChains} for the
+     * set), so there is nothing chain-specific to pass.
+     *
      * @param body - Optionally the destination ledger; everything else comes
      *   from the session
      * @returns Promise resolving to the deposit address and the initial-check
@@ -82,4 +86,19 @@ export class SweeperAPIImpl extends BaseAPI {
             body: JSON.stringify(wireBody),
         });
     }
+    /**
+     * The chains and assets the sweeper watches: where a registered deposit
+     * address accepts deposits, which tokens are swept on each chain, and each
+     * token's minimum sweep amount in raw base units.
+     *
+     * Public — no session needed. The set changes only with operator
+     * configuration, so it is safe to cache briefly.
+     *
+     * @returns Promise resolving to the supported chain/asset listing
+     */
+    async getChains() {
+        return await this.makePublicRequest(perpRoutes.sweeper.chains(), {
+            method: "GET",
+        });
+    }
 }

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

@@ -257,6 +257,17 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * Each order is canceled and re-created with new parameters.
      * Failed replacements do not prevent other orders from being replaced.
      *
+     * Pre-sequencing validation is scoped per item too, matching `batchCreate`:
+     * a malformed `orderId`, `price`, `quantity` or `clientOrderId`, or a
+     * `postOnly` violation, fails only that item — its result slot carries a
+     * structured `error.code` (`INVALID_ORDER_ID`, `INVALID_PRICE`,
+     * `INVALID_QUANTITY`, `INVALID_CLIENT_ORDER_ID`, `INVALID_POST_ONLY`) and its
+     * original is left untouched — while the valid items proceed. A `2xx`
+     * response can therefore mix executed replacements and failed items: read
+     * `results[]` per item rather than treating the status code as the verdict.
+     * Only an empty or oversize (>100) batch rejects the whole request.
+     * `totalRequested === totalSucceeded + totalFailed` always holds.
+     *
      * @param orders - Array of order replacement parameters
      * @returns Promise resolving to BatchReplaceOrdersResponse with individual results
      * @throws {APIError} When API communication fails
@@ -281,6 +292,11 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * Gets orders based on query parameters, cursor-paginated by default.
      *
      * Retrieves orders with optional filtering by status, trading pair, and pagination.
+     * Every kind of order comes back in ONE stream ordered by timestamp: book orders,
+     * TWAP parents (`orderType: "TWAP"`, detail on `twap`) and conditional orders
+     * (`orderType: "CONDITIONAL"`, detail on `conditional`). There is no separate
+     * open-orders call — filter `status` to `["SUBMITTED", "PARTIALLY_FILLED"]` for the
+     * working set.
      * When neither `page` nor `pageToken` is passed, the SDK drives cursor (pageToken)
      * pagination: it starts a cursor walk from the newest (or oldest, for
      * `orderBy: "ASC"`) row and the response's `nextPageToken` resumes it. Cursor
@@ -305,6 +321,17 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      *
      * @example
      * ```typescript
+     * // Every working order, of every kind, in one page
+     * const open = await tradingAPI.getPaginatedOrders({ status: ["SUBMITTED", "PARTIALLY_FILLED"] });
+     * for (const order of open.orders) {
+     *   if (order.orderType === "TWAP") console.log("TWAP parent", order.twap?.slicesPlaced);
+     *   else if (order.orderType === "CONDITIONAL") console.log("trigger", order.conditional?.triggerPrice);
+     *   else console.log("resting", order.price);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
      * // Walk full order history with cursor pagination (the default mode)
      * let pageToken: string | undefined;
      * do {

package/dist/api/trading/api.js

@@ -403,6 +403,17 @@ export class TradingAPIImpl extends BaseAPI {
      * Each order is canceled and re-created with new parameters.
      * Failed replacements do not prevent other orders from being replaced.
      *
+     * Pre-sequencing validation is scoped per item too, matching `batchCreate`:
+     * a malformed `orderId`, `price`, `quantity` or `clientOrderId`, or a
+     * `postOnly` violation, fails only that item — its result slot carries a
+     * structured `error.code` (`INVALID_ORDER_ID`, `INVALID_PRICE`,
+     * `INVALID_QUANTITY`, `INVALID_CLIENT_ORDER_ID`, `INVALID_POST_ONLY`) and its
+     * original is left untouched — while the valid items proceed. A `2xx`
+     * response can therefore mix executed replacements and failed items: read
+     * `results[]` per item rather than treating the status code as the verdict.
+     * Only an empty or oversize (>100) batch rejects the whole request.
+     * `totalRequested === totalSucceeded + totalFailed` always holds.
+     *
      * @param orders - Array of order replacement parameters
      * @returns Promise resolving to BatchReplaceOrdersResponse with individual results
      * @throws {APIError} When API communication fails
@@ -443,6 +454,11 @@ export class TradingAPIImpl extends BaseAPI {
      * Gets orders based on query parameters, cursor-paginated by default.
      *
      * Retrieves orders with optional filtering by status, trading pair, and pagination.
+     * Every kind of order comes back in ONE stream ordered by timestamp: book orders,
+     * TWAP parents (`orderType: "TWAP"`, detail on `twap`) and conditional orders
+     * (`orderType: "CONDITIONAL"`, detail on `conditional`). There is no separate
+     * open-orders call — filter `status` to `["SUBMITTED", "PARTIALLY_FILLED"]` for the
+     * working set.
      * When neither `page` nor `pageToken` is passed, the SDK drives cursor (pageToken)
      * pagination: it starts a cursor walk from the newest (or oldest, for
      * `orderBy: "ASC"`) row and the response's `nextPageToken` resumes it. Cursor
@@ -467,6 +483,17 @@ export class TradingAPIImpl extends BaseAPI {
      *
      * @example
      * ```typescript
+     * // Every working order, of every kind, in one page
+     * const open = await tradingAPI.getPaginatedOrders({ status: ["SUBMITTED", "PARTIALLY_FILLED"] });
+     * for (const order of open.orders) {
+     *   if (order.orderType === "TWAP") console.log("TWAP parent", order.twap?.slicesPlaced);
+     *   else if (order.orderType === "CONDITIONAL") console.log("trigger", order.conditional?.triggerPrice);
+     *   else console.log("resting", order.price);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
      * // Walk full order history with cursor pagination (the default mode)
      * let pageToken: string | undefined;
      * do {

package/dist/api/websocket/websocket.js

@@ -1,4 +1,4 @@
-import { hexToBytes } from "@noble/hashes/utils";
+import { hexToBytes } from "@noble/hashes/utils.js";
 import { composeWsSigningString, signMessage } from "../../crypto/session";
 import { ALL_MAGNITUDES } from "../../utils";
 import { keysToCamelCase } from "./utils";
@@ -82,6 +82,12 @@ function readOptionalNumber(source, field) {
     }
     return value;
 }
+function readOptionalSequence(source, field) {
+    const value = source[field];
+    if (value === undefined || value === null)
+        return undefined;
+    return readSequence(source, field);
+}
 function readStringArray(source, field) {
     const value = source[field];
     if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
@@ -492,6 +498,7 @@ function parseUserBalanceEventData(raw) {
         lockedRaw: readString(data, "lockedRaw"),
         total: readString(data, "total"),
         totalRaw: readString(data, "totalRaw"),
+        version: readOptionalSequence(data, "version"),
         // Free-form on the wire and read leniently: a snapshot row carries the
         // `snapshot` literal, a live frame the mutation cause, and a reason added
         // server-side after this SDK shipped must not drop the row (0XM-2627).
@@ -500,6 +507,20 @@ function parseUserBalanceEventData(raw) {
         updatedAt: readString(data, "updatedAt"),
     };
 }
+/**
+ * Parse one row from a `balances` channel snapshot.
+ *
+ * `version` is read leniently, for the same reason `reason` is: a pre-feature
+ * server sends no version at all, and rejecting the row would drop the entire
+ * subscribe-time baseline for a client whose SDK is ahead of the server it is
+ * talking to. `UserBalanceEventData.version` is optional precisely so an absent
+ * value is representable, and consumers already treat it as the unranked
+ * sentinel. A version that IS present is still validated — `readSequence`
+ * rejects negative and unsafe values.
+ */
+function parseBalanceSnapshotItem(raw) {
+    return parseUserBalanceEventData(raw);
+}
 /**
  * Parse one resting order from an `orders` channel snapshot.
  *
@@ -847,9 +868,14 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                     sendAuthenticate();
                     resubscribeAll();
                     options.onStatusChange?.("connected");
-                    // Send auth/subscribe requests before asking the application to
-                    // reconcile. This callback does not wait for acknowledgements or
-                    // snapshots, and the SDK does not perform REST recovery itself.
+                    // Resync-join order: the live stream resumes first (auth +
+                    // subscribe above), then the application is asked to refetch
+                    // snapshots and reconcile against each channel's authoritative
+                    // identity/version. Balance ordering uses the durable row version,
+                    // never `updatedAt`, arrival time, or receiver backlog.
+                    //
+                    // This callback waits for neither acknowledgements nor snapshots,
+                    // and the SDK performs no REST recovery itself.
                     if (pendingResyncCode !== null) {
                         const code = pendingResyncCode;
                         pendingResyncCode = null;
@@ -1201,7 +1227,7 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
             catch (err) {
                 console.error("WebSocket: Error processing balance event", err);
             }
-        }, onSnapshot && snapshotFrameHandler("balances", parseUserBalanceEventData, onSnapshot));
+        }, onSnapshot && snapshotFrameHandler("balances", parseBalanceSnapshotItem, onSnapshot));
     };
     const subscribeConditionalOrders = (handler, tradingPairId, onSnapshot) => {
         if (!handler) {

package/dist/coverage.d.ts

@@ -35,6 +35,7 @@ export declare const COVERED: {
     get_market_stats: string;
     get_my_fee_tier: string;
     get_pulse: string;
+    get_sweeper_chains: string;
     get_my_trader_code: string;
     get_rewards_balance: string;
     get_trader_code_info: string;

package/dist/coverage.js

@@ -35,6 +35,7 @@ export const COVERED = {
     get_market_stats: "getMarketStats",
     get_my_fee_tier: "getMyFeeTier",
     get_pulse: "pulse.getPulse",
+    get_sweeper_chains: "sweeper.getChains",
     get_my_trader_code: "pitpass.getMyTraderCode",
     get_rewards_balance: "pitpass.getRewardsBalance",
     get_trader_code_info: "pitpass.getTraderCodeInfo",

package/dist/crypto/http-signatures.js

@@ -1,7 +1,7 @@
 /** Monaco's RFC 9421 Ed25519 profile; key registration remains wallet-authorized. */
 import { ed25519 } from "@noble/curves/ed25519";
-import { sha256 } from "@noble/hashes/sha2";
-import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
 function base64(bytes) {
     return btoa(String.fromCharCode(...bytes));
 }

package/dist/crypto/session.js

@@ -8,8 +8,8 @@
  * key — it never sees the private key, so it cannot mint requests as the user.
  */
 import { ed25519 } from "@noble/curves/ed25519";
-import { sha256 } from "@noble/hashes/sha2";
-import { bytesToHex, hexToBytes, utf8ToBytes } from "@noble/hashes/utils";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex, hexToBytes, utf8ToBytes } from "@noble/hashes/utils.js";
 /**
  * Generate a fresh ed25519 session keypair.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/core",
-	"version": "1.0.55",
+	"version": "1.0.57",
 	"type": "module",
 	"homepage": "https://docs.0xmonaco.com/sdk/typescript",
 	"main": "./dist/index.js",
@@ -19,10 +19,10 @@
 		"viem": "^2.45.2"
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "1.0.55",
-		"@0xmonaco/types": "1.0.55",
+		"@0xmonaco/contracts": "1.0.57",
+		"@0xmonaco/types": "1.0.57",
 		"@noble/curves": "^1.9.1",
-		"@noble/hashes": "^1.8.0",
+		"@noble/hashes": "^2.4.0",
 		"http-status-codes": "^2.3.0"
 	},
 	"devDependencies": {