@acta-markets/ts-sdk 0.0.4-beta → 0.0.6-beta

package/README.md

@@ -88,11 +88,14 @@ client.ws!.on("positions", (positions) => {
   console.log("first expiry", positions[0]?.expiry_ts);
 });
 
-client.ws!.getMarkets();
+const marketsRequestId = client.ws!.getMarkets();
+console.log("GetMarkets request_id:", marketsRequestId);
 // positions require auth:
 // client.ws!.getPositions();
 ```
 
+Most WS read/query methods now return the generated `request_id` so UI code can correlate responses (`data.request_id`) without building custom request id plumbing.
+
 ### RFQ → accept quote → sign sponsored tx (wallet UX)
 
 ```ts

package/dist/cjs/events.test.js

@@ -184,6 +184,8 @@ describe("events parsing", () => {
                 Buffer.from(pk(3)),
                 u64(777),
                 Buffer.from([1]), // is_put
+                Buffer.from([6]), // underlying_decimals
+                Buffer.from([9]), // quote_decimals
             ]));
             const d = (0, events_1.decodeActaEventLine)(line);
             expect(d.kind).toBe(events_1.EventKind.CreateMarket);
@@ -194,6 +196,8 @@ describe("events parsing", () => {
                 expect(d.event.quoteMint).toBe(addr(3));
                 expect(d.event.expiryTs).toBe(777n);
                 expect(d.event.isPut).toBe(1);
+                expect(d.event.underlyingDecimals).toBe(6);
+                expect(d.event.quoteDecimals).toBe(9);
             }
         }
         // 9: FinalizeMarket
@@ -215,6 +219,7 @@ describe("events parsing", () => {
                 u64(222),
                 Buffer.from([1]),
                 Buffer.from(pk(3)),
+                Buffer.from(pk(9)),
             ]));
             const d = (0, events_1.decodeActaEventLine)(line);
             expect(d.kind).toBe(events_1.EventKind.CreateOracle);
@@ -225,6 +230,7 @@ describe("events parsing", () => {
                 expect(d.event.expiryTs).toBe(222n);
                 expect(d.event.oracleType).toBe(1);
                 expect(d.event.authority).toBe(addr(3));
+                expect(Buffer.from(d.event.feedId)).toEqual(Buffer.from(pk(9)));
             }
         }
         // 15: UpdateOraclePrice

package/dist/cjs/generated/types/actaEvent.js

@@ -89,6 +89,8 @@ function getActaEventEncoder() {
                 ["quoteMint", (0, kit_1.getAddressEncoder)()],
                 ["expiryTs", (0, kit_1.getU64Encoder)()],
                 ["isPut", (0, kit_1.getU8Encoder)()],
+                ["underlyingDecimals", (0, kit_1.getU8Encoder)()],
+                ["quoteDecimals", (0, kit_1.getU8Encoder)()],
             ]),
         ],
         [
@@ -142,6 +144,7 @@ function getActaEventEncoder() {
                 ["expiryTs", (0, kit_1.getU64Encoder)()],
                 ["oracleType", (0, kit_1.getU8Encoder)()],
                 ["authority", (0, kit_1.getAddressEncoder)()],
+                ["feedId", (0, kit_1.fixEncoderSize)((0, kit_1.getBytesEncoder)(), 32)],
             ]),
         ],
         [
@@ -247,6 +250,8 @@ function getActaEventDecoder() {
                 ["quoteMint", (0, kit_1.getAddressDecoder)()],
                 ["expiryTs", (0, kit_1.getU64Decoder)()],
                 ["isPut", (0, kit_1.getU8Decoder)()],
+                ["underlyingDecimals", (0, kit_1.getU8Decoder)()],
+                ["quoteDecimals", (0, kit_1.getU8Decoder)()],
             ]),
         ],
         [
@@ -300,6 +305,7 @@ function getActaEventDecoder() {
                 ["expiryTs", (0, kit_1.getU64Decoder)()],
                 ["oracleType", (0, kit_1.getU8Decoder)()],
                 ["authority", (0, kit_1.getAddressDecoder)()],
+                ["feedId", (0, kit_1.fixDecoderSize)((0, kit_1.getBytesDecoder)(), 32)],
             ]),
         ],
         [

package/dist/cjs/idl/acta_contract.json

@@ -1883,6 +1883,14 @@
                             {
                                 "name": "is_put",
                                 "type": "u8"
+                            },
+                            {
+                                "name": "underlying_decimals",
+                                "type": "u8"
+                            },
+                            {
+                                "name": "quote_decimals",
+                                "type": "u8"
                             }
                         ]
                     },
@@ -2030,6 +2038,15 @@
                             {
                                 "name": "authority",
                                 "type": "publicKey"
+                            },
+                            {
+                                "name": "feed_id",
+                                "type": {
+                                    "array": [
+                                        "u8",
+                                        32
+                                    ]
+                                }
                             }
                         ]
                     },

package/dist/cjs/idl/hash.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ACTA_IDL_SHA256 = void 0;
-exports.ACTA_IDL_SHA256 = "1466fbb647b4c33af315eefbb61e5e572ce14f22f16d050ac2894f8e017aaf66";
+exports.ACTA_IDL_SHA256 = "704677f7071ecbe98f442fb62468d882329b906950a707fc47aad0f38683636f";

package/dist/cjs/ws/client.js

@@ -73,6 +73,21 @@ function getCloseInfo(ev) {
         reason: typeof rec.reason === "string" ? rec.reason : undefined,
     };
 }
+function generateRequestId() {
+    const cryptoApi = globalThis.crypto;
+    if (cryptoApi?.randomUUID) {
+        return cryptoApi.randomUUID();
+    }
+    if (cryptoApi?.getRandomValues) {
+        const bytes = cryptoApi.getRandomValues(new Uint8Array(16));
+        // RFC4122 v4 bits: version=0100, variant=10xx.
+        bytes[6] = (bytes[6] & 0x0f) | 0x40;
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+        return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    }
+    return `req-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
+}
 class ActaWsClient extends TypedEventEmitter {
     ws = null;
     options;
@@ -82,6 +97,7 @@ class ActaWsClient extends TypedEventEmitter {
     pendingResumeSessionId = null;
     connectionState = "disconnected";
     sessionId = null;
+    lastAuthSessionId = null;
     helloSent = false;
     welcomeReceived = false;
     pendingMessages = [];
@@ -92,6 +108,7 @@ class ActaWsClient extends TypedEventEmitter {
     subscribedChannels = new Set(["rfqs"]);
     subscribedMarkets = new Set();
     hasMarketScope = false;
+    marketDescriptorsByMarket = new Map();
     state = {
         stats: null,
         activeRfqs: new Map(),
@@ -124,6 +141,7 @@ class ActaWsClient extends TypedEventEmitter {
         this.authProvider = null;
         this.authRequested = false;
         this.pendingResumeSessionId = null;
+        this.lastAuthSessionId = null;
         this.shouldReconnect = this.options.autoReconnect;
         this.doConnect();
     }
@@ -179,6 +197,13 @@ class ActaWsClient extends TypedEventEmitter {
     }
     async createRfq(request) {
         this.ensureAuthenticated();
+        (0, wirePolicy_1.assertWsU64Safe)(request.strike, "strike");
+        (0, wirePolicy_1.assertWsU64Safe)(request.quantity, "quantity");
+        const marketDescriptor = this.marketDescriptorsByMarket.get(request.market);
+        if (!marketDescriptor) {
+            throw new Error(`Missing market descriptor for market=${request.market}; call getMarketDescriptors() before createRfq().`);
+        }
+        (0, wirePolicy_1.validateQuantityBySizeRule)(request.quantity, marketDescriptor.size_rule);
         this.send({
             type: "RfqRequest",
             data: {
@@ -223,47 +248,89 @@ class ActaWsClient extends TypedEventEmitter {
     }
     getPositions() {
         this.ensureAuthenticated();
-        this.send({ type: "GetPositions" });
+        const requestId = this.nextRequestId();
+        this.send({
+            type: "GetPositions",
+            data: { request_id: requestId },
+        });
+        return requestId;
     }
     getMarkets() {
-        this.send({ type: "GetMarkets" });
+        const requestId = this.nextRequestId();
+        this.send({
+            type: "GetMarkets",
+            data: { request_id: requestId },
+        });
+        return requestId;
     }
     getMarketDescriptors(args) {
+        const requestId = this.nextRequestId();
         const data = {
+            request_id: requestId,
             active_only: args?.active_only ?? true,
         };
         this.send({ type: "GetMarketDescriptors", data });
+        return requestId;
     }
     getExpiries(args) {
+        const requestId = this.nextRequestId();
         this.send({
             type: "GetExpiries",
             data: {
+                request_id: requestId,
                 underlying_mint: args?.underlying_mint,
                 quote_mint: args?.quote_mint,
                 is_put: args?.is_put ?? null,
             },
         });
+        return requestId;
     }
     getTokens(args) {
+        const requestId = this.nextRequestId();
         const data = {
+            request_id: requestId,
             active_only: args?.active_only ?? true,
         };
         this.send({ type: "GetTokens", data });
+        return requestId;
     }
     getMyActiveRfqs() {
         this.ensureAuthenticated();
-        this.send({ type: "GetMyActiveRfqs" });
+        const requestId = this.nextRequestId();
+        this.send({
+            type: "GetMyActiveRfqs",
+            data: { request_id: requestId },
+        });
+        return requestId;
     }
     getActiveRfqs() {
-        this.send({ type: "GetActiveRfqs" });
+        const requestId = this.nextRequestId();
+        this.send({
+            type: "GetActiveRfqs",
+            data: { request_id: requestId },
+        });
+        return requestId;
+    }
+    logout() {
+        this.send({ type: "Logout" });
     }
     getOrderStatus(orderIdHex) {
         this.ensureAuthenticated();
-        this.send({ type: "GetOrderStatus", data: { order_id: orderIdHex } });
+        const requestId = this.nextRequestId();
+        this.send({
+            type: "GetOrderStatus",
+            data: { request_id: requestId, order_id: orderIdHex },
+        });
+        return requestId;
     }
     cancelRfq(rfqId) {
         this.ensureAuthenticated();
-        this.send({ type: "CancelRfq", data: { rfq_id: rfqId } });
+        const requestId = this.nextRequestId();
+        this.send({
+            type: "CancelRfq",
+            data: { rfq_id: rfqId, request_id: requestId },
+        });
+        return requestId;
     }
     submitQuote(quote) {
         this.ensureAuthenticated();
@@ -293,7 +360,12 @@ class ActaWsClient extends TypedEventEmitter {
     }
     cancelQuote(rfqId) {
         this.ensureAuthenticated();
-        this.send({ type: "CancelQuote", data: { rfq_id: rfqId } });
+        const requestId = this.nextRequestId();
+        this.send({
+            type: "CancelQuote",
+            data: { rfq_id: rfqId, request_id: requestId },
+        });
+        return requestId;
     }
     subscribe(channels, markets) {
         this.ensureAuthenticated();
@@ -418,6 +490,14 @@ class ActaWsClient extends TypedEventEmitter {
             case "AuthError":
                 this.handleAuthError(message.data.reason, message.data.message);
                 break;
+            case "LogoutSuccess":
+                this.sessionId = null;
+                this.pendingResumeSessionId = null;
+                this.lastAuthSessionId = null;
+                this.startAuthSent = false;
+                this.setConnectionState("connecting");
+                this.emit("logoutSuccess");
+                break;
             case "Snapshot":
                 this.handleSnapshot(message.data);
                 break;
@@ -428,7 +508,13 @@ class ActaWsClient extends TypedEventEmitter {
                 this.handleMarkets(message.data.markets ?? []);
                 break;
             case "MarketDescriptors":
-                this.emit("marketDescriptors", message.data.markets ?? []);
+                {
+                    const marketDescriptors = message.data.markets ?? [];
+                    for (const marketDescriptor of marketDescriptors) {
+                        this.marketDescriptorsByMarket.set(marketDescriptor.market.market_pda, marketDescriptor);
+                    }
+                    this.emit("marketDescriptors", marketDescriptors);
+                }
                 break;
             case "Expiries":
                 this.emit("expiries", message.data.expiries_ts ?? []);
@@ -587,10 +673,12 @@ class ActaWsClient extends TypedEventEmitter {
     }
     /** Taker-only: request current indicative prices for a market + position_type. */
     getIndicativePrices(req) {
+        const requestId = this.nextRequestId();
         this.send({
             type: "GetIndicativePrices",
-            data: req,
+            data: { ...req, request_id: requestId },
         });
+        return requestId;
     }
     /** Maker-only: respond to an indicative request (unsigned, non-binding). */
     sendIndicativePricesResponse(resp) {
@@ -619,8 +707,9 @@ class ActaWsClient extends TypedEventEmitter {
         }
     }
     async beginAuthHandshake() {
-        if (this.pendingResumeSessionId) {
-            this.sendResumeAuth(this.pendingResumeSessionId);
+        const resumeSessionId = this.pendingResumeSessionId ?? this.lastAuthSessionId;
+        if (resumeSessionId) {
+            this.sendResumeAuth(resumeSessionId);
             return;
         }
         await this.sendStartAuth();
@@ -657,6 +746,9 @@ class ActaWsClient extends TypedEventEmitter {
     handleAuthSuccess(sessionId, expiresAt) {
         this.sessionId = sessionId;
         this.pendingResumeSessionId = null;
+        if (expiresAt !== null) {
+            this.lastAuthSessionId = sessionId;
+        }
         this.setConnectionState("authenticated");
         this.emit("authenticated", sessionId, expiresAt);
         if (this.subscribedChannels.size > 0) {
@@ -668,12 +760,13 @@ class ActaWsClient extends TypedEventEmitter {
         }
     }
     handleAuthError(reason, message) {
-        this.emit("authError", reason);
+        this.emit("authError", reason, message);
         if (reason === "session_expired" &&
             this.authRequested &&
             this.authProvider &&
-            this.pendingResumeSessionId) {
+            (this.pendingResumeSessionId || this.lastAuthSessionId)) {
             this.pendingResumeSessionId = null;
+            this.lastAuthSessionId = null;
             this.startAuthSent = false;
             void this.sendStartAuth().catch((err) => {
                 this.emit("error", err);
@@ -789,6 +882,9 @@ class ActaWsClient extends TypedEventEmitter {
             this.log("Cannot send, WebSocket not open");
         }
     }
+    nextRequestId() {
+        return generateRequestId();
+    }
     ensureAuthenticated() {
         if (this.connectionState !== "authenticated") {
             throw new Error("Client is not authenticated");
@@ -883,7 +979,6 @@ class ActaWsClient extends TypedEventEmitter {
         this.helloSent = false;
         this.welcomeReceived = false;
         this.startAuthSent = false;
-        this.pendingResumeSessionId = null;
         this.pendingMessages = [];
         this.setConnectionState("disconnected");
     }

package/dist/cjs/ws/client.test.js

@@ -13,6 +13,7 @@ const WELCOME_MESSAGE = {
         enabled_features: [],
     },
 };
+const createdClients = [];
 class MockWebSocket {
     url;
     readyState = WS_CONNECTING;
@@ -67,6 +68,7 @@ function makeHarness(overrides = {}) {
             return currentSocket;
         },
     });
+    createdClients.push(client);
     return {
         client,
         socket: () => {
@@ -83,6 +85,9 @@ async function flushMicrotasks() {
 }
 describe("ActaWsClient", () => {
     afterEach(() => {
+        for (const client of createdClients.splice(0, createdClients.length)) {
+            client.disconnect();
+        }
         jest.restoreAllMocks();
         jest.useRealTimers();
     });
@@ -169,13 +174,204 @@ describe("ActaWsClient", () => {
     });
     it("emits authError reason on AuthError", () => {
         const { client } = makeHarness();
-        const reasons = [];
-        client.on("authError", (reason) => reasons.push(reason));
+        const errors = [];
+        client.on("authError", (reason, message) => errors.push({ reason, message }));
         client.handleMessage({
             type: "AuthError",
             data: { reason: "invalid_signature", message: "bad signature bytes" },
         });
-        expect(reasons).toEqual(["invalid_signature"]);
+        expect(errors).toEqual([
+            { reason: "invalid_signature", message: "bad signature bytes" },
+        ]);
+    });
+    it("uses last auth session for resume-first reconnect", async () => {
+        const { client, socket } = makeHarness();
+        const auth = makeAuthProvider("WalletPubkey", "WalletSignature");
+        client.connectAndAuthenticate(auth);
+        let ws = socket();
+        ws.triggerOpen();
+        ws.triggerMessage(WELCOME_MESSAGE);
+        await flushMicrotasks();
+        ws.triggerMessage({
+            type: "AuthSuccess",
+            data: { session_id: "persisted-session", expires_at: 1_710_086_400 },
+        });
+        ws.triggerClose(1006, "network_drop");
+        client.connectAndAuthenticate(auth);
+        ws = socket();
+        ws.triggerOpen();
+        ws.triggerMessage(WELCOME_MESSAGE);
+        await flushMicrotasks();
+        const sentTypes = ws.sent.map((payload) => parseClientMessage(payload).type);
+        expect(sentTypes).toEqual(["Hello", "ResumeAuth"]);
+        const resumeAuth = parseClientMessage(ws.sent[1]);
+        expect(resumeAuth.type).toBe("ResumeAuth");
+        if (resumeAuth.type === "ResumeAuth") {
+            expect(resumeAuth.data.session_id).toBe("persisted-session");
+        }
+    });
+    it("sends Logout and emits logoutSuccess", () => {
+        const { client, socket } = makeHarness();
+        const events = [];
+        client.on("logoutSuccess", () => events.push("logoutSuccess"));
+        client.connectAnonymous();
+        const ws = socket();
+        ws.triggerOpen();
+        ws.triggerMessage(WELCOME_MESSAGE);
+        client.logout();
+        const sent = parseClientMessage(ws.sent[1]);
+        expect(sent.type).toBe("Logout");
+        ws.triggerMessage({ type: "LogoutSuccess", data: {} });
+        expect(events).toEqual(["logoutSuccess"]);
+    });
+    it("adds request_id to public request messages", () => {
+        const { client, socket } = makeHarness();
+        client.connectAnonymous();
+        const ws = socket();
+        ws.triggerOpen();
+        ws.triggerMessage(WELCOME_MESSAGE);
+        const getMarketsId = client.getMarkets();
+        const getMarketDescriptorsId = client.getMarketDescriptors();
+        const getTokensId = client.getTokens();
+        const getExpiriesId = client.getExpiries();
+        const getActiveRfqsId = client.getActiveRfqs();
+        const getIndicativePricesId = client.getIndicativePrices({
+            market: "market-1",
+            position_type: "covered_call",
+        });
+        const sent = ws.sent.slice(1).map(parseClientMessage);
+        const withRequestId = sent.filter((msg) => msg.type !== "Logout");
+        for (const msg of withRequestId) {
+            if ("data" in msg) {
+                const data = msg.data;
+                expect(typeof data.request_id).toBe("string");
+                expect(data.request_id.length).toBeGreaterThan(0);
+            }
+        }
+        expect(sent[0].data.request_id).toBe(getMarketsId);
+        expect(sent[1].data.request_id).toBe(getMarketDescriptorsId);
+        expect(sent[2].data.request_id).toBe(getTokensId);
+        expect(sent[3].data.request_id).toBe(getExpiriesId);
+        expect(sent[4].data.request_id).toBe(getActiveRfqsId);
+        expect(sent[5].data.request_id).toBe(getIndicativePricesId);
+    });
+    it("adds request_id to authenticated request messages", () => {
+        const { client, socket } = makeHarness();
+        client.connectAnonymous();
+        const ws = socket();
+        ws.triggerOpen();
+        ws.triggerMessage(WELCOME_MESSAGE);
+        client.handleMessage({
+            type: "AuthSuccess",
+            data: { session_id: "session-id", expires_at: 1_710_086_400 },
+        });
+        const getPositionsId = client.getPositions();
+        const getMyActiveRfqsId = client.getMyActiveRfqs();
+        const getOrderStatusId = client.getOrderStatus("11".repeat(32));
+        const cancelRfqId = client.cancelRfq("rfq-1");
+        const cancelQuoteId = client.cancelQuote("rfq-2");
+        const sent = ws.sent.slice(1).map(parseClientMessage);
+        const authRequests = sent.filter((msg) => [
+            "GetPositions",
+            "GetMyActiveRfqs",
+            "GetOrderStatus",
+            "CancelRfq",
+            "CancelQuote",
+        ].includes(msg.type));
+        expect(authRequests).toHaveLength(5);
+        for (const msg of authRequests) {
+            if ("data" in msg) {
+                const data = msg.data;
+                expect(typeof data.request_id).toBe("string");
+                expect(data.request_id.length).toBeGreaterThan(0);
+            }
+        }
+        expect(authRequests[0].data.request_id).toBe(getPositionsId);
+        expect(authRequests[1].data.request_id).toBe(getMyActiveRfqsId);
+        expect(authRequests[2].data.request_id).toBe(getOrderStatusId);
+        expect(authRequests[3].data.request_id).toBe(cancelRfqId);
+        expect(authRequests[4].data.request_id).toBe(cancelQuoteId);
+    });
+    it("createRfq rejects when market descriptor is missing", async () => {
+        const { client, socket } = makeHarness();
+        client.connectAnonymous();
+        const ws = socket();
+        ws.triggerOpen();
+        ws.triggerMessage(WELCOME_MESSAGE);
+        client.handleMessage({
+            type: "AuthSuccess",
+            data: { session_id: "session-id", expires_at: 1_710_086_400 },
+        });
+        await expect(client.createRfq({
+            market: "market-1",
+            position_type: "covered_call",
+            strike: 100_000_000_000,
+            quantity: 2_000_000_000,
+        })).rejects.toThrow("Missing market descriptor");
+        const sentTypes = ws.sent.map((payload) => parseClientMessage(payload).type);
+        expect(sentTypes).not.toContain("RfqRequest");
+    });
+    it("createRfq validates quantity against market size rule", async () => {
+        const { client, socket } = makeHarness();
+        client.connectAnonymous();
+        const ws = socket();
+        ws.triggerOpen();
+        ws.triggerMessage(WELCOME_MESSAGE);
+        client.handleMessage({
+            type: "AuthSuccess",
+            data: { session_id: "session-id", expires_at: 1_710_086_400 },
+        });
+        client.handleMessage({
+            type: "MarketDescriptors",
+            data: {
+                request_id: "req-1",
+                markets: [
+                    {
+                        market: {
+                            chain_id: 1,
+                            program_id: "program-1",
+                            market_pda: "market-1",
+                            underlying_mint: "So11111111111111111111111111111111111111112",
+                            quote_mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+                            expiry_ts: 1_800_000_000,
+                            is_put: false,
+                            collateral_mint: "So11111111111111111111111111111111111111112",
+                            settlement_mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+                        },
+                        underlying_oracle_pda: "oracle-underlying",
+                        quote_oracle_pda: "oracle-quote",
+                        underlying_decimals: 9,
+                        quote_decimals: 6,
+                        size_rule: {
+                            min_size: 2_000_000_000,
+                            max_size: 10_000_000_000,
+                            step: 1_000_000_000,
+                        },
+                    },
+                ],
+            },
+        });
+        await expect(client.createRfq({
+            market: "market-1",
+            position_type: "covered_call",
+            strike: 100_000_000_000,
+            quantity: 2_500_000_000,
+        })).rejects.toThrow("(quantity - min_size) % step == 0");
+        await client.createRfq({
+            market: "market-1",
+            position_type: "covered_call",
+            strike: 100_000_000_000,
+            quantity: 3_000_000_000,
+        });
+        const sentMessages = ws.sent.map(parseClientMessage);
+        const rfqRequest = sentMessages
+            .filter((message) => message.type === "RfqRequest")
+            .at(-1);
+        expect(rfqRequest?.type).toBe("RfqRequest");
+        if (rfqRequest?.type === "RfqRequest") {
+            expect(rfqRequest.data.market).toBe("market-1");
+            expect(rfqRequest.data.quantity).toBe(3_000_000_000);
+        }
     });
     it("drop_oldest policy keeps the latest queued messages", () => {
         const { client, socket } = makeHarness({

package/dist/cjs/ws/discovery.js

@@ -12,11 +12,13 @@ function deriveTokenLists(markets) {
         underlyings.set(uMint, {
             mint: m.market.underlying_mint,
             decimals: m.underlying_decimals,
+            size_rule: m.size_rule,
             symbol: m.underlying_symbol,
         });
         const q = {
             mint: m.market.quote_mint,
             decimals: m.quote_decimals,
+            size_rule: m.size_rule,
             symbol: m.quote_symbol,
         };
         const inner = quotesByUnderlying.get(uMint) ?? new Map();

package/dist/cjs/ws/wirePolicy.js

@@ -12,6 +12,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertWsU64Safe = assertWsU64Safe;
 exports.assertWsI64Safe = assertWsI64Safe;
+exports.validateQuantityBySizeRule = validateQuantityBySizeRule;
 function assertWsU64Safe(value, name) {
     if (!Number.isFinite(value) || !Number.isInteger(value)) {
         throw new Error(`${name} must be an integer number (u64 on wire)`);
@@ -32,3 +33,18 @@ function assertWsI64Safe(value, name) {
         throw new Error(`${name} exceeds JS safe integer range; WS wire requires safe integers`);
     }
 }
+function validateQuantityBySizeRule(quantity, rule, quantityName = "quantity") {
+    assertWsU64Safe(quantity, quantityName);
+    assertWsU64Safe(rule.min_size, "size_rule.min_size");
+    assertWsU64Safe(rule.max_size, "size_rule.max_size");
+    assertWsU64Safe(rule.step, "size_rule.step");
+    if (rule.max_size < rule.min_size) {
+        throw new Error(`invalid size_rule: max_size (${rule.max_size}) must be >= min_size (${rule.min_size})`);
+    }
+    if (quantity < rule.min_size || quantity > rule.max_size) {
+        throw new Error(`${quantityName} must be within [${rule.min_size}, ${rule.max_size}], got ${quantity}`);
+    }
+    if ((quantity - rule.min_size) % rule.step !== 0) {
+        throw new Error(`${quantityName} must satisfy (quantity - min_size) % step == 0 (quantity=${quantity}, min_size=${rule.min_size}, step=${rule.step})`);
+    }
+}