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

package/dist/ws/client.test.js

@@ -11,6 +11,7 @@ const WELCOME_MESSAGE = {
         enabled_features: [],
     },
 };
+const createdClients = [];
 class MockWebSocket {
     url;
     readyState = WS_CONNECTING;
@@ -65,6 +66,7 @@ function makeHarness(overrides = {}) {
             return currentSocket;
         },
     });
+    createdClients.push(client);
     return {
         client,
         socket: () => {
@@ -81,6 +83,9 @@ async function flushMicrotasks() {
 }
 describe("ActaWsClient", () => {
     afterEach(() => {
+        for (const client of createdClients.splice(0, createdClients.length)) {
+            client.disconnect();
+        }
         jest.restoreAllMocks();
         jest.useRealTimers();
     });
@@ -167,13 +172,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/ws/discovery.js

@@ -8,11 +8,13 @@ export 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/ws/types.d.ts

@@ -83,6 +83,8 @@ export type ClientMessage = {
     data: {
         session_id: string;
     };
+} | {
+    type: "Logout";
 } | {
     type: "AuthChallenge";
     data: AuthChallengeData;
@@ -93,6 +95,7 @@ export type ClientMessage = {
     type: "CancelQuote";
     data: {
         rfq_id: UuidString;
+        request_id: RequestId;
     };
 } | {
     type: "IndicativePricesResponse";
@@ -113,14 +116,17 @@ export type ClientMessage = {
     type: "CancelRfq";
     data: {
         rfq_id: UuidString;
+        request_id: RequestId;
     };
 } | {
     type: "GetIndicativePrices";
     data: GetIndicativePricesMessage;
 } | {
     type: "GetPositions";
+    data: GetPositionsMessage;
 } | {
     type: "GetMarkets";
+    data: GetMarketsMessage;
 } | {
     type: "GetMarketDescriptors";
     data: GetMarketDescriptorsMessage;
@@ -132,11 +138,13 @@ export type ClientMessage = {
     data: GetTokensMessage;
 } | {
     type: "GetMyActiveRfqs";
+    data: GetMyActiveRfqsMessage;
 } | {
     type: "GetOrderStatus";
     data: GetOrderStatusMessage;
 } | {
     type: "GetActiveRfqs";
+    data: GetActiveRfqsMessage;
 } | {
     type: "GetMakerPositions";
     data: GetMakerPositionsMessage;
@@ -148,8 +156,10 @@ export type ClientMessage = {
     data: GetMarketsForMakerMessage;
 } | {
     type: "GetMakerBalances";
+    data: GetMakerBalancesMessage;
 } | {
     type: "GetSubscriptions";
+    data: GetSubscriptionsMessage;
 } | {
     type: "CancelAllQuotes";
     data: CancelAllQuotesMessage;
@@ -168,29 +178,54 @@ export type ClientMessage = {
     };
 };
 export type GetMarketDescriptorsMessage = {
+    request_id: RequestId;
     active_only?: boolean;
 };
 export type GetTokensMessage = {
+    request_id: RequestId;
     active_only?: boolean;
 };
 export type GetExpiriesMessage = {
+    request_id: RequestId;
     underlying_mint?: Address<string>;
     quote_mint?: Address<string>;
     is_put?: boolean | null;
 };
+export type GetPositionsMessage = {
+    request_id: RequestId;
+};
+export type GetMarketsMessage = {
+    request_id: RequestId;
+};
+export type GetMyActiveRfqsMessage = {
+    request_id: RequestId;
+};
+export type GetActiveRfqsMessage = {
+    request_id: RequestId;
+};
+export type GetMakerBalancesMessage = {
+    request_id: RequestId;
+};
+export type GetSubscriptionsMessage = {
+    request_id: RequestId;
+};
 export type GetOrderStatusMessage = {
+    request_id: RequestId;
     order_id: OrderIdHex32;
 };
 export type GetMakerPositionsMessage = {
+    request_id: RequestId;
     market?: string;
     underlying_mint?: string;
     status?: string[];
     min_expiry_ts?: WsU64;
 };
 export type GetMyQuotesMessage = {
+    request_id: RequestId;
     active_only?: boolean;
 };
 export type GetMarketsForMakerMessage = {
+    request_id: RequestId;
     underlying_mints?: string[];
     quote_mints?: string[];
     min_expiry_ts?: WsU64;
@@ -199,6 +234,7 @@ export type GetMarketsForMakerMessage = {
     include_stats?: boolean;
 };
 export type CancelAllQuotesMessage = {
+    request_id: RequestId;
     market?: string;
 };
 export type AuthChallengeData = {
@@ -268,6 +304,9 @@ export type ServerMessage = {
         reason: ErrorMessage;
         message?: string;
     };
+} | {
+    type: "LogoutSuccess";
+    data: Record<string, never>;
 } | {
     type: "RfqCreated";
     data: RfqCreatedMessage;
@@ -319,6 +358,7 @@ export type ServerMessage = {
 } | {
     type: "ActiveRfqs";
     data: {
+        request_id: RequestId;
         rfqs: ActiveRfqInfo[];
     };
 } | {
@@ -429,13 +469,20 @@ export type MarketDescriptorInfo = {
     quote_oracle_pda: PubkeyBase58;
     underlying_decimals: number;
     quote_decimals: number;
-    underlying_symbol?: string;
-    quote_symbol?: string;
+    size_rule: PositionSizeRule;
+    underlying_symbol: string;
+    quote_symbol: string;
+};
+export type PositionSizeRule = {
+    min_size: WsU64;
+    max_size: WsU64;
+    step: WsU64;
 };
 export type TokenInfo = {
     mint: Address<string>;
     decimals: number;
-    symbol?: string;
+    size_rule: PositionSizeRule;
+    symbol: string;
 };
 export type RfqCreatedMessage = {
     rfq_id: UuidString;
@@ -625,11 +672,14 @@ export type QuoteExpiredMessage = {
     reason: QuoteExpiredReason;
 };
 export type MakerPositionsMessage = {
+    request_id: RequestId;
     positions: MakerPositionInfo[];
 };
 export type MakerPositionInfo = {
     pda: string;
     market: string;
+    underlying_mint: string;
+    quote_mint: string;
     position_type: PositionType;
     status: PositionStatus;
     strike: WsU64;
@@ -642,6 +692,7 @@ export type MakerPositionInfo = {
     expiry_ts: WsU64;
 };
 export type MyQuotesMessage = {
+    request_id: RequestId;
     quotes: MakerQuoteInfo[];
 };
 export type MakerQuoteInfo = {
@@ -657,6 +708,7 @@ export type MakerQuoteInfo = {
     created_at: WsU64;
 };
 export type MakerMarketsMessage = {
+    request_id: RequestId;
     markets: MakerMarketInfo[];
 };
 export type MakerMarketInfo = {
@@ -666,8 +718,8 @@ export type MakerMarketInfo = {
     expiry_ts: WsU64;
     is_put: boolean;
     is_finalized: boolean;
-    underlying_symbol?: string;
-    quote_symbol?: string;
+    underlying_symbol: string;
+    quote_symbol: string;
     stats?: MarketStats;
 };
 export type MarketStats = {
@@ -675,6 +727,7 @@ export type MarketStats = {
     trades_24h: WsU32;
 };
 export type MakerBalancesMessage = {
+    request_id: RequestId;
     balances_by_mint: Record<string, MakerMintBalance>;
 };
 export type MakerMintBalance = {
@@ -683,6 +736,7 @@ export type MakerMintBalance = {
     available: WsU64;
 };
 export type SubscriptionsMessage = {
+    request_id: RequestId;
     channels: WsChannel[];
     markets?: string[];
 };
@@ -702,10 +756,12 @@ export type IndicativePricesResponseMessage = {
     }>;
 };
 export type GetIndicativePricesMessage = {
+    request_id: RequestId;
     market: Address<string>;
     position_type: PositionType;
 };
 export type IndicativePricesMessage = {
+    request_id: RequestId;
     market: Address<string>;
     position_type: PositionType;
     updated_at: WsU64;
@@ -746,18 +802,23 @@ export type QuotesUpdateMessage = {
     quotes: QuoteReceivedMessage[];
 };
 export type PositionsMessage = {
+    request_id: RequestId;
     positions: PositionInfo[];
 };
 export type MarketsMessage = {
+    request_id: RequestId;
     markets: MarketInfo[];
 };
 export type MarketDescriptorsMessage = {
+    request_id: RequestId;
     markets: MarketDescriptorInfo[];
 };
 export type ExpiriesMessage = {
+    request_id: RequestId;
     expiries_ts: WsU64[];
 };
 export type TokensMessage = {
+    request_id: RequestId;
     underlyings: TokenInfo[];
     quotes_by_underlying: Record<Address<string>, TokenInfo[]>;
 };
@@ -769,9 +830,11 @@ export type SnapshotMessage = {
     markets: MarketInfo[];
 };
 export type MyActiveRfqsMessage = {
+    request_id: RequestId;
     rfqs: MyActiveRfqInfo[];
 };
 export type OrderStatusMessage = {
+    request_id: RequestId;
     order_id: OrderIdHex32;
     status: OrderStatusValue;
     rfq_id?: UuidString | null;
@@ -817,6 +880,8 @@ export type RfqOrderOption = {
 export type PositionInfo = {
     pda: string;
     market: string;
+    underlying_mint: string;
+    quote_mint: string;
     position_type: PositionType;
     status: PositionStatus;
     strike: WsU64;

package/dist/ws/wirePolicy.d.ts

@@ -10,3 +10,9 @@
  */
 export declare function assertWsU64Safe(value: number, name: string): void;
 export declare function assertWsI64Safe(value: number, name: string): void;
+export type QuantitySizeRuleLike = {
+    min_size: number;
+    max_size: number;
+    step: number;
+};
+export declare function validateQuantityBySizeRule(quantity: number, rule: QuantitySizeRuleLike, quantityName?: string): void;

package/dist/ws/wirePolicy.js

@@ -28,3 +28,18 @@ export function assertWsI64Safe(value, name) {
         throw new Error(`${name} exceeds JS safe integer range; WS wire requires safe integers`);
     }
 }
+export 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})`);
+    }
+}

package/dist/ws/wirePolicy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ws/wirePolicy.test.js

@@ -0,0 +1,20 @@
+import { validateQuantityBySizeRule } from "./wirePolicy";
+describe("validateQuantityBySizeRule", () => {
+    const rule = {
+        min_size: 2_000_000_000,
+        max_size: 10_000_000_000,
+        step: 1_000_000_000,
+    };
+    it("accepts a valid quantity", () => {
+        expect(() => validateQuantityBySizeRule(6_000_000_000, rule)).not.toThrow();
+    });
+    it("rejects quantity below min", () => {
+        expect(() => validateQuantityBySizeRule(1_000_000_000, rule)).toThrow("must be within");
+    });
+    it("rejects quantity above max", () => {
+        expect(() => validateQuantityBySizeRule(11_000_000_000, rule)).toThrow("must be within");
+    });
+    it("rejects quantity with invalid step", () => {
+        expect(() => validateQuantityBySizeRule(2_500_000_000, rule)).toThrow("(quantity - min_size) % step == 0");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acta-markets/ts-sdk",
-  "version": "0.0.4-beta",
+  "version": "0.0.6-beta",
   "description": "TypeScript SDK for Acta Protocol",
   "type": "module",
   "main": "dist/index.js",