@0xmonaco/core 1.0.76 → 1.0.80

package/dist/api/pitpass/api.d.ts

@@ -77,10 +77,12 @@ export declare class PitpassAPIImpl extends BaseAPI implements PitpassAPI {
      */
     transferRewards(params: TransferRewardsParams): Promise<TransferRewardsResponse>;
     /**
-     * Read the caller's own referral position: their upline (L1, L2, ...), their
-     * L1 referrer, total earned, and recent rewards. Self-scoped — no id is sent,
-     * so it can only ever return your own chain. `referrer` is "" and `upline` is
-     * empty when you were not referred.
+     * Read the caller's own referral position: their upline (L1, L2, ..., as
+     * many levels as their trades on this client application pay), their L1
+     * referrer, total earned, and recent rewards. Self-scoped — no id is sent,
+     * so it can only ever return your own chain. `referrer` is "" when you were
+     * not referred; `upline` is also empty when this client application pays no
+     * referral levels.
      */
     getMyReferralPosition(): Promise<GetMyReferralPositionResponse>;
     /**
@@ -96,7 +98,8 @@ export declare class PitpassAPIImpl extends BaseAPI implements PitpassAPI {
      * Read one level of the caller's own referral tree: the wallets `parent`
      * directly referred (the caller when omitted), a page at a time, newest
      * first. `parent` must be the caller or one of their own referees above the
-     * deepest rewarded level; any other wallet is a 404.
+     * deepest level any client application rewards (at most 10); any other
+     * wallet is a 404. The caller's direct referees (L1) are always listed.
      */
     getMyReferralTree(params?: GetMyReferralTreeParams): Promise<GetMyReferralTreeResponse>;
 }

package/dist/api/pitpass/api.js

@@ -109,10 +109,12 @@ export class PitpassAPIImpl extends BaseAPI {
         });
     }
     /**
-     * Read the caller's own referral position: their upline (L1, L2, ...), their
-     * L1 referrer, total earned, and recent rewards. Self-scoped — no id is sent,
-     * so it can only ever return your own chain. `referrer` is "" and `upline` is
-     * empty when you were not referred.
+     * Read the caller's own referral position: their upline (L1, L2, ..., as
+     * many levels as their trades on this client application pay), their L1
+     * referrer, total earned, and recent rewards. Self-scoped — no id is sent,
+     * so it can only ever return your own chain. `referrer` is "" when you were
+     * not referred; `upline` is also empty when this client application pays no
+     * referral levels.
      */
     async getMyReferralPosition() {
         return await this.makeAuthenticatedRequest("/api/v1/pitpass/referrals/me", {
@@ -146,7 +148,8 @@ export class PitpassAPIImpl extends BaseAPI {
      * Read one level of the caller's own referral tree: the wallets `parent`
      * directly referred (the caller when omitted), a page at a time, newest
      * first. `parent` must be the caller or one of their own referees above the
-     * deepest rewarded level; any other wallet is a 404.
+     * deepest level any client application rewards (at most 10); any other
+     * wallet is a 404. The caller's direct referees (L1) are always listed.
      */
     async getMyReferralTree(params) {
         if (params) {

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

@@ -11,10 +11,11 @@ export declare class PositionsAPIImpl extends BaseAPI implements PositionsAPI {
      * paging loop off it — follow `nextPageToken`.
      *
      * Order depends on the filter: `status: "OPEN"` is served from the engine's
-     * live view in `(marginAccountId, tradingPairId, positionId)` order, every
-     * other filter from persisted rows newest-opened first. The two are
-     * separate cursor spaces, so a token is only valid in the one that minted
-     * it.
+     * live view in `(marginAccountId, tradingPairId, positionId)` order;
+     * `status: "CLOSED"` and `status: "LIQUIDATED"` from persisted rows
+     * newest-closed first; every other filter from persisted rows
+     * newest-opened first. Each is a separate cursor space, so a token is only
+     * valid in the one that minted it.
      */
     listPositions(params?: ListPositionsParams): Promise<ListPositionsResponse>;
     getPosition(positionId: string): Promise<GetPositionResponse>;

package/dist/api/positions/api.js

@@ -12,10 +12,11 @@ export class PositionsAPIImpl extends BaseAPI {
      * paging loop off it — follow `nextPageToken`.
      *
      * Order depends on the filter: `status: "OPEN"` is served from the engine's
-     * live view in `(marginAccountId, tradingPairId, positionId)` order, every
-     * other filter from persisted rows newest-opened first. The two are
-     * separate cursor spaces, so a token is only valid in the one that minted
-     * it.
+     * live view in `(marginAccountId, tradingPairId, positionId)` order;
+     * `status: "CLOSED"` and `status: "LIQUIDATED"` from persisted rows
+     * newest-closed first; every other filter from persisted rows
+     * newest-opened first. Each is a separate cursor space, so a token is only
+     * valid in the one that minted it.
      */
     async listPositions(params) {
         if (params) {

package/dist/api/websocket/websocket.js

@@ -454,6 +454,10 @@ function parseMarketStatsSummary(raw) {
         // 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"),
+        indexPrice: readOptionalString(data, "indexPrice"),
+        fundingRate: readOptionalString(data, "fundingRate"),
+        premium: readOptionalString(data, "premium"),
+        openInterestNotional: readOptionalString(data, "openInterestNotional"),
     };
 }
 function parseMarketStatsAllEvent(rawData) {
@@ -464,6 +468,60 @@ function parseMarketStatsAllEvent(rawData) {
         markets: rawData.markets.map(parseMarketStatsSummary),
     };
 }
+function parseRiskTier(raw) {
+    if (!isRecord(raw)) {
+        throw new Error("Invalid instrument event: each riskTiers entry must be an object");
+    }
+    const tierLevel = raw.tierLevel;
+    if (typeof tierLevel !== "number" || !Number.isSafeInteger(tierLevel) || tierLevel < 1) {
+        throw new Error("Invalid WebSocket event: tierLevel must be a positive integer");
+    }
+    return {
+        tierLevel,
+        lowerBoundNotional: readString(raw, "lowerBoundNotional"),
+        maxLeverage: readOptionalString(raw, "maxLeverage"),
+        initialMarginRatio: readString(raw, "initialMarginRatio"),
+        maintenanceMarginRatio: readString(raw, "maintenanceMarginRatio"),
+        initialMarginDeduction: readString(raw, "initialMarginDeduction"),
+        maintenanceMarginDeduction: readString(raw, "maintenanceMarginDeduction"),
+        maxPositionNotional: readOptionalString(raw, "maxPositionNotional"),
+    };
+}
+/**
+ * Read the perp-only margin ladder. Absent (a spot market, or a server that
+ * predates the key) is `undefined`, never a made-up empty ladder; a present
+ * value that is not an array of well-formed tiers throws like any other
+ * malformed field.
+ */
+function readOptionalRiskTiers(source, field) {
+    const value = source[field];
+    if (value === undefined || value === null)
+        return undefined;
+    if (!Array.isArray(value)) {
+        throw new Error(`Invalid WebSocket event: ${field} must be an array`);
+    }
+    return value.map(parseRiskTier);
+}
+/**
+ * Parse one `trades` snapshot row: the live trade frame's `data` body.
+ *
+ * Strict, unlike the live trade handler's casts: a snapshot is delivered
+ * all-or-nothing, so a row with a missing or non-string field must throw for
+ * {@link snapshotFrameHandler} to withhold the frame. The output is the same
+ * `TradeEventData` the live handler builds, `makerSide` uppercased likewise.
+ */
+function parseTradeEventData(raw) {
+    if (!isRecord(raw)) {
+        throw new Error("Invalid trade snapshot row: must be an object");
+    }
+    return {
+        tradeId: readString(raw, "trade_id"),
+        price: readString(raw, "price"),
+        quantity: readString(raw, "quantity"),
+        makerSide: readString(raw, "maker_side").toUpperCase(),
+        executedAt: readString(raw, "executed_at"),
+    };
+}
 function parseInstrumentEventData(raw) {
     if (!isRecord(raw)) {
         throw new Error("Invalid instrument event: data must be an object");
@@ -510,6 +568,7 @@ function parseInstrumentEventData(raw) {
         maxLeverage: readOptionalString(data, "maxLeverage"),
         initialMarginRate: readOptionalString(data, "initialMarginRate"),
         maintenanceMarginRate: readOptionalString(data, "maintenanceMarginRate"),
+        riskTiers: readOptionalRiskTiers(data, "riskTiers"),
         // Values are snake_case wire field NAMES (e.g. "tick_size"); only object
         // keys are camelCased, so they pass through untouched.
         changedFields: readStringArray(data, "changedFields"),
@@ -1457,7 +1516,7 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
             }
         });
     };
-    const subscribeTrades = (tradingPairId, handler) => {
+    const subscribeTrades = (tradingPairId, handler, onSnapshot) => {
         const channel = `trades:${tradingPairId}`;
         return subscribe(channel, (rawData) => {
             try {
@@ -1480,7 +1539,7 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
             catch (err) {
                 console.error("WebSocket: Error processing trade event", err);
             }
-        });
+        }, onSnapshot && snapshotFrameHandler("trades", parseTradeEventData, onSnapshot));
     };
     const subscribeMovements = (handler) => {
         // User is identified from the authenticated session, so channel is just "movements"
@@ -1717,8 +1776,9 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
      * markets, or pass one to filter. Every frame carries the market's FULL
      * current config as a terminal-state snapshot (never an additive delta);
      * `changedFields` names what the mutation touched. A subscribe-time snapshot
-     * of the current active-pair list arrives before the live diffs; a
-     * subscriber joining a channel this client already holds is replayed the
+     * of every listed market arrives before the live diffs, inactive markets
+     * included and flagged `isActive: false` (filter on `isActive` for the
+     * tradable set); a subscriber joining a channel this client already holds is replayed the
      * current baseline from a local cache instead (the server snapshots only
      * genuinely new wire subscriptions). Detected broadcast lag closes the connection
      * with 1013; a new wire subscription provides a fresh baseline.
@@ -1761,8 +1821,8 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
             }
         }, 
         // The subscribe-time baseline arrives as one Snapshot frame whose data is
-        // a flat InstrumentEventData[] (a `listing` per active market, no
-        // per-item envelope).
+        // a flat InstrumentEventData[] (a `listing` per market, inactive ones
+        // flagged `isActive: false`, no per-item envelope).
         //
         // Where it goes depends on whether the caller opted in. With
         // `onSnapshot`, the rows are handed over as one array and the event
@@ -1774,7 +1834,7 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
         // asked would be a silent behaviour break.
         //
         // Either way the local cache is replaced wholesale rather than upserted,
-        // so markets absent from the snapshot (delisted while disconnected) do
+        // so markets absent from the snapshot (no longer listed) do
         // not linger.
         snapshotFrameHandler("instrument", parseInstrumentEventData, (items) => {
             const events = items.map((item) => ({ tradingPairId: item.tradingPairId, data: item }));
@@ -1818,18 +1878,13 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
                     // follows the same delivery contract: one array to `onSnapshot`
                     // when opted in, per-market events otherwise.
                     //
-                    // The two forms carry deliberately different sets. The ARRAY is
-                    // filtered to active markets, because that is what a real snapshot
-                    // is — the server enumerates active pairs, while this cache also
-                    // holds the delistings it has seen live — and a consumer replaces
-                    // its market set from the array, so a delisted row there would
-                    // resurrect a market that is gone. The per-market EVENTS are not
-                    // filtered: a delisting is a legitimate event, it is what tells a
-                    // legacy subscriber the market went inactive, and dropping it would
-                    // change a caller that never opted into any of this.
+                    // Both forms carry the cache's full set, delistings it has seen live
+                    // included, because that is what a real snapshot is: the server
+                    // enumerates inactive markets too, each flagged `isActive: false`.
+                    // A consumer wanting the tradable set filters on `isActive`.
                     if (onSnapshot) {
                         try {
-                            onSnapshot(replay.filter((event) => event.data.isActive).map((event) => event.data));
+                            onSnapshot(replay.map((event) => event.data));
                         }
                         catch (err) {
                             console.error("WebSocket: Error processing instrument baseline replay", err);

package/package.json

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