@acta-markets/ts-sdk 0.0.1-beta → 0.0.3-beta

package/dist/actaClient.d.ts

@@ -38,7 +38,9 @@ export declare class ActaClient {
     /** Convenience: `client.connectWs(auth)` instead of `client.ws!.connect(auth)`. */
     connectWs(authProvider: AuthProvider): this;
     /** Convenience: connect and trigger auth flow in one call. */
-    connectWsAndAuthenticate(authProvider: AuthProvider): this;
+    connectWsAndAuthenticate(authProvider: AuthProvider, options?: {
+        sessionId?: string;
+    }): this;
     /** Convenience: connect WS without triggering auth (anonymous browsing). */
     connectWsAnonymous(): this;
     /** Convenience: disconnect WS (and stop reconnect timers). */

package/dist/actaClient.js

@@ -82,8 +82,8 @@ export class ActaClient {
         return this;
     }
     /** Convenience: connect and trigger auth flow in one call. */
-    connectWsAndAuthenticate(authProvider) {
-        this.assertWs().connectAndAuthenticate(authProvider);
+    connectWsAndAuthenticate(authProvider, options) {
+        this.assertWs().connectAndAuthenticate(authProvider, options);
         return this;
     }
     /** Convenience: connect WS without triggering auth (anonymous browsing). */

package/dist/chain/fetch.js

@@ -86,6 +86,13 @@ async function fetchAndDecode(rpc, config, decode) {
 function dataSize(bytes) {
     return { dataSize: BigInt(bytes) };
 }
+function marketAccountFilters(...extra) {
+    return [
+        dataSize(MARKET_ACCOUNT_SIZE_BYTES),
+        memcmp(0, new Uint8Array([MARKET_ACCOUNT_DISCRIMINATOR])),
+        ...extra,
+    ];
+}
 // --- Positions ---
 export async function fetchPositionsByMaker(rpc, makerOwner, options) {
     return rpc
@@ -236,10 +243,7 @@ export async function fetchAllMarketsDecoded(rpc, options) {
     return fetchAndDecode(rpc, {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [
-            dataSize(MARKET_ACCOUNT_SIZE_BYTES),
-            memcmp(0, new Uint8Array([MARKET_ACCOUNT_DISCRIMINATOR])),
-        ],
+        filters: marketAccountFilters(),
     }, decodeMarketAccount);
 }
 export async function fetchAllOraclesDecoded(rpc, options) {
@@ -268,7 +272,7 @@ export async function fetchMarketsByUnderlying(rpc, underlying, options) {
         .getProgramAccounts(getActaProgramId(), {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [memcmp(MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying))],
+        filters: marketAccountFilters(memcmp(MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying))),
     })
         .send();
 }
@@ -276,7 +280,7 @@ export async function fetchMarketsByUnderlyingDecoded(rpc, underlying, options)
     return fetchAndDecode(rpc, {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [memcmp(MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying))],
+        filters: marketAccountFilters(memcmp(MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying))),
     }, decodeMarketAccount);
 }
 export async function fetchMarketsByQuote(rpc, quote, options) {
@@ -284,7 +288,7 @@ export async function fetchMarketsByQuote(rpc, quote, options) {
         .getProgramAccounts(getActaProgramId(), {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [memcmp(MARKET_OFFSET_QUOTE_MINT, addrBytes(quote))],
+        filters: marketAccountFilters(memcmp(MARKET_OFFSET_QUOTE_MINT, addrBytes(quote))),
     })
         .send();
 }
@@ -292,7 +296,7 @@ export async function fetchMarketsByQuoteDecoded(rpc, quote, options) {
     return fetchAndDecode(rpc, {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [memcmp(MARKET_OFFSET_QUOTE_MINT, addrBytes(quote))],
+        filters: marketAccountFilters(memcmp(MARKET_OFFSET_QUOTE_MINT, addrBytes(quote))),
     }, decodeMarketAccount);
 }
 export async function fetchMarketsByExpiry(rpc, expiryTs, options) {
@@ -300,7 +304,7 @@ export async function fetchMarketsByExpiry(rpc, expiryTs, options) {
         .getProgramAccounts(getActaProgramId(), {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))],
+        filters: marketAccountFilters(memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))),
     })
         .send();
 }
@@ -308,7 +312,7 @@ export async function fetchMarketsByExpiryDecoded(rpc, expiryTs, options) {
     return fetchAndDecode(rpc, {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))],
+        filters: marketAccountFilters(memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))),
     }, decodeMarketAccount);
 }
 export async function fetchMarketsByQuoteAndExpiry(rpc, quote, expiryTs, options) {
@@ -316,10 +320,7 @@ export async function fetchMarketsByQuoteAndExpiry(rpc, quote, expiryTs, options
         .getProgramAccounts(getActaProgramId(), {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [
-            memcmp(MARKET_OFFSET_QUOTE_MINT, addrBytes(quote)),
-            memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs)),
-        ],
+        filters: marketAccountFilters(memcmp(MARKET_OFFSET_QUOTE_MINT, addrBytes(quote)), memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))),
     })
         .send();
 }
@@ -327,10 +328,7 @@ export async function fetchMarketsByQuoteAndExpiryDecoded(rpc, quote, expiryTs,
     return fetchAndDecode(rpc, {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [
-            memcmp(MARKET_OFFSET_QUOTE_MINT, addrBytes(quote)),
-            memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs)),
-        ],
+        filters: marketAccountFilters(memcmp(MARKET_OFFSET_QUOTE_MINT, addrBytes(quote)), memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))),
     }, decodeMarketAccount);
 }
 export async function fetchMarketsByUnderlyingAndExpiry(rpc, underlying, expiryTs, options) {
@@ -338,10 +336,7 @@ export async function fetchMarketsByUnderlyingAndExpiry(rpc, underlying, expiryT
         .getProgramAccounts(getActaProgramId(), {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [
-            memcmp(MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying)),
-            memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs)),
-        ],
+        filters: marketAccountFilters(memcmp(MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying)), memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))),
     })
         .send();
 }
@@ -368,10 +363,7 @@ export async function fetchMarketsByUnderlyingAndExpiryDecoded(rpc, underlying,
     return fetchAndDecode(rpc, {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [
-            memcmp(MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying)),
-            memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs)),
-        ],
+        filters: marketAccountFilters(memcmp(MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying)), memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))),
     }, decodeMarketAccount);
 }
 // --- Decode helpers ---
@@ -379,6 +371,12 @@ export function decodePositionAccount(data) {
     return getPositionDecoder().decode(data);
 }
 export function decodeMarketAccount(data) {
+    if (data.length < MARKET_ACCOUNT_SIZE_BYTES) {
+        throw new Error(`Invalid Market account size: expected >= ${MARKET_ACCOUNT_SIZE_BYTES}, got ${data.length}`);
+    }
+    if (data[0] !== MARKET_ACCOUNT_DISCRIMINATOR) {
+        throw new Error(`Invalid Market account discriminator: expected ${MARKET_ACCOUNT_DISCRIMINATOR}, got ${data[0]}`);
+    }
     return getMarketDecoder().decode(data);
 }
 export function decodeConfigAccount(data) {

package/dist/chain/fetch.test.js

@@ -1,4 +1,4 @@
-import { MAKER_OFFSET_MAKER_OWNER, MAKER_OFFSET_QUOTE_SIGNING, MARKET_OFFSET_EXPIRY_TS, MARKET_OFFSET_FLAGS, MARKET_OFFSET_SETTLEMENT_PRICE, MARKET_OFFSET_UNDERLYING_DECIMALS, MARKET_OFFSET_QUOTE_DECIMALS, MARKET_OFFSET_QUOTE_MINT, MARKET_OFFSET_QUOTE_ORACLE_ADDRESS, MARKET_OFFSET_UNDERLYING_MINT, MARKET_OFFSET_UNDERLYING_ORACLE_ADDRESS, POSITION_OFFSET_MAKER_OWNER, POSITION_OFFSET_MARKET, POSITION_OFFSET_STATUS, POSITION_OFFSET_TAKER_OWNER, } from "./fetch";
+import { decodeMarketAccount, MAKER_OFFSET_MAKER_OWNER, MAKER_OFFSET_QUOTE_SIGNING, MARKET_OFFSET_EXPIRY_TS, MARKET_OFFSET_FLAGS, MARKET_OFFSET_SETTLEMENT_PRICE, MARKET_OFFSET_UNDERLYING_DECIMALS, MARKET_OFFSET_QUOTE_DECIMALS, MARKET_OFFSET_QUOTE_MINT, MARKET_OFFSET_QUOTE_ORACLE_ADDRESS, MARKET_OFFSET_UNDERLYING_MINT, MARKET_OFFSET_UNDERLYING_ORACLE_ADDRESS, POSITION_OFFSET_MAKER_OWNER, POSITION_OFFSET_MARKET, POSITION_OFFSET_STATUS, POSITION_OFFSET_TAKER_OWNER, } from "./fetch";
 import { getAddressDecoder } from "@solana/addresses";
 import { encodeOrderPreimage } from "./orders";
 import { getMakerEncoder, getMakerSize } from "../generated/accounts/maker";
@@ -155,4 +155,33 @@ describe("fetch offsets and order encode", () => {
         expect(preimage.slice(base + 66, base + 98)).toEqual(makerBytes);
         expect(preimage.slice(base + 98, base + 130)).toEqual(takerBytes);
     });
+    it("decodeMarketAccount rejects non-market discriminator and short data", () => {
+        const decoder = getAddressDecoder();
+        const marketBytes = new Uint8Array(Array(32).fill(1));
+        const makerBytes = new Uint8Array(Array(32).fill(7));
+        const takerBytes = new Uint8Array(Array(32).fill(8));
+        const market = decoder.decode(marketBytes);
+        const makerOwner = decoder.decode(makerBytes);
+        const takerOwner = decoder.decode(takerBytes);
+        const positionData = getPositionEncoder().encode({
+            discriminator: 1,
+            version: 1,
+            bump: 7,
+            positionType: 0,
+            status: 1,
+            flags: 0,
+            flags2: 0,
+            flags3: 0,
+            takerOwner,
+            makerOwner,
+            market,
+            strike: 1n,
+            quantity: 1n,
+            totalPremium: 1n,
+            orderId: new Uint8Array(32).fill(0x11),
+            reserved: Array(32).fill(0n),
+        });
+        expect(() => decodeMarketAccount(Buffer.from(positionData))).toThrow("Invalid Market account discriminator");
+        expect(() => decodeMarketAccount(Buffer.alloc(8))).toThrow("Invalid Market account size");
+    });
 });

package/dist/cjs/actaClient.js

@@ -85,8 +85,8 @@ class ActaClient {
         return this;
     }
     /** Convenience: connect and trigger auth flow in one call. */
-    connectWsAndAuthenticate(authProvider) {
-        this.assertWs().connectAndAuthenticate(authProvider);
+    connectWsAndAuthenticate(authProvider, options) {
+        this.assertWs().connectAndAuthenticate(authProvider, options);
         return this;
     }
     /** Convenience: connect WS without triggering auth (anonymous browsing). */

package/dist/cjs/chain/fetch.js

@@ -125,6 +125,13 @@ async function fetchAndDecode(rpc, config, decode) {
 function dataSize(bytes) {
     return { dataSize: BigInt(bytes) };
 }
+function marketAccountFilters(...extra) {
+    return [
+        dataSize(exports.MARKET_ACCOUNT_SIZE_BYTES),
+        memcmp(0, new Uint8Array([exports.MARKET_ACCOUNT_DISCRIMINATOR])),
+        ...extra,
+    ];
+}
 // --- Positions ---
 async function fetchPositionsByMaker(rpc, makerOwner, options) {
     return rpc
@@ -275,10 +282,7 @@ async function fetchAllMarketsDecoded(rpc, options) {
     return fetchAndDecode(rpc, {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [
-            dataSize(exports.MARKET_ACCOUNT_SIZE_BYTES),
-            memcmp(0, new Uint8Array([exports.MARKET_ACCOUNT_DISCRIMINATOR])),
-        ],
+        filters: marketAccountFilters(),
     }, decodeMarketAccount);
 }
 async function fetchAllOraclesDecoded(rpc, options) {
@@ -307,7 +311,7 @@ async function fetchMarketsByUnderlying(rpc, underlying, options) {
         .getProgramAccounts((0, index_1.getActaProgramId)(), {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [memcmp(exports.MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying))],
+        filters: marketAccountFilters(memcmp(exports.MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying))),
     })
         .send();
 }
@@ -315,7 +319,7 @@ async function fetchMarketsByUnderlyingDecoded(rpc, underlying, options) {
     return fetchAndDecode(rpc, {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [memcmp(exports.MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying))],
+        filters: marketAccountFilters(memcmp(exports.MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying))),
     }, decodeMarketAccount);
 }
 async function fetchMarketsByQuote(rpc, quote, options) {
@@ -323,7 +327,7 @@ async function fetchMarketsByQuote(rpc, quote, options) {
         .getProgramAccounts((0, index_1.getActaProgramId)(), {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [memcmp(exports.MARKET_OFFSET_QUOTE_MINT, addrBytes(quote))],
+        filters: marketAccountFilters(memcmp(exports.MARKET_OFFSET_QUOTE_MINT, addrBytes(quote))),
     })
         .send();
 }
@@ -331,7 +335,7 @@ async function fetchMarketsByQuoteDecoded(rpc, quote, options) {
     return fetchAndDecode(rpc, {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [memcmp(exports.MARKET_OFFSET_QUOTE_MINT, addrBytes(quote))],
+        filters: marketAccountFilters(memcmp(exports.MARKET_OFFSET_QUOTE_MINT, addrBytes(quote))),
     }, decodeMarketAccount);
 }
 async function fetchMarketsByExpiry(rpc, expiryTs, options) {
@@ -339,7 +343,7 @@ async function fetchMarketsByExpiry(rpc, expiryTs, options) {
         .getProgramAccounts((0, index_1.getActaProgramId)(), {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [memcmp(exports.MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))],
+        filters: marketAccountFilters(memcmp(exports.MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))),
     })
         .send();
 }
@@ -347,7 +351,7 @@ async function fetchMarketsByExpiryDecoded(rpc, expiryTs, options) {
     return fetchAndDecode(rpc, {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [memcmp(exports.MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))],
+        filters: marketAccountFilters(memcmp(exports.MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))),
     }, decodeMarketAccount);
 }
 async function fetchMarketsByQuoteAndExpiry(rpc, quote, expiryTs, options) {
@@ -355,10 +359,7 @@ async function fetchMarketsByQuoteAndExpiry(rpc, quote, expiryTs, options) {
         .getProgramAccounts((0, index_1.getActaProgramId)(), {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [
-            memcmp(exports.MARKET_OFFSET_QUOTE_MINT, addrBytes(quote)),
-            memcmp(exports.MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs)),
-        ],
+        filters: marketAccountFilters(memcmp(exports.MARKET_OFFSET_QUOTE_MINT, addrBytes(quote)), memcmp(exports.MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))),
     })
         .send();
 }
@@ -366,10 +367,7 @@ async function fetchMarketsByQuoteAndExpiryDecoded(rpc, quote, expiryTs, options
     return fetchAndDecode(rpc, {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [
-            memcmp(exports.MARKET_OFFSET_QUOTE_MINT, addrBytes(quote)),
-            memcmp(exports.MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs)),
-        ],
+        filters: marketAccountFilters(memcmp(exports.MARKET_OFFSET_QUOTE_MINT, addrBytes(quote)), memcmp(exports.MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))),
     }, decodeMarketAccount);
 }
 async function fetchMarketsByUnderlyingAndExpiry(rpc, underlying, expiryTs, options) {
@@ -377,10 +375,7 @@ async function fetchMarketsByUnderlyingAndExpiry(rpc, underlying, expiryTs, opti
         .getProgramAccounts((0, index_1.getActaProgramId)(), {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [
-            memcmp(exports.MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying)),
-            memcmp(exports.MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs)),
-        ],
+        filters: marketAccountFilters(memcmp(exports.MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying)), memcmp(exports.MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))),
     })
         .send();
 }
@@ -407,10 +402,7 @@ async function fetchMarketsByUnderlyingAndExpiryDecoded(rpc, underlying, expiryT
     return fetchAndDecode(rpc, {
         commitment: options?.commitment,
         dataSlice: options?.dataSlice,
-        filters: [
-            memcmp(exports.MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying)),
-            memcmp(exports.MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs)),
-        ],
+        filters: marketAccountFilters(memcmp(exports.MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying)), memcmp(exports.MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))),
     }, decodeMarketAccount);
 }
 // --- Decode helpers ---
@@ -418,6 +410,12 @@ function decodePositionAccount(data) {
     return (0, position_1.getPositionDecoder)().decode(data);
 }
 function decodeMarketAccount(data) {
+    if (data.length < exports.MARKET_ACCOUNT_SIZE_BYTES) {
+        throw new Error(`Invalid Market account size: expected >= ${exports.MARKET_ACCOUNT_SIZE_BYTES}, got ${data.length}`);
+    }
+    if (data[0] !== exports.MARKET_ACCOUNT_DISCRIMINATOR) {
+        throw new Error(`Invalid Market account discriminator: expected ${exports.MARKET_ACCOUNT_DISCRIMINATOR}, got ${data[0]}`);
+    }
     return (0, market_1.getMarketDecoder)().decode(data);
 }
 function decodeConfigAccount(data) {

package/dist/cjs/chain/fetch.test.js

@@ -157,4 +157,33 @@ describe("fetch offsets and order encode", () => {
         expect(preimage.slice(base + 66, base + 98)).toEqual(makerBytes);
         expect(preimage.slice(base + 98, base + 130)).toEqual(takerBytes);
     });
+    it("decodeMarketAccount rejects non-market discriminator and short data", () => {
+        const decoder = (0, addresses_1.getAddressDecoder)();
+        const marketBytes = new Uint8Array(Array(32).fill(1));
+        const makerBytes = new Uint8Array(Array(32).fill(7));
+        const takerBytes = new Uint8Array(Array(32).fill(8));
+        const market = decoder.decode(marketBytes);
+        const makerOwner = decoder.decode(makerBytes);
+        const takerOwner = decoder.decode(takerBytes);
+        const positionData = (0, position_1.getPositionEncoder)().encode({
+            discriminator: 1,
+            version: 1,
+            bump: 7,
+            positionType: 0,
+            status: 1,
+            flags: 0,
+            flags2: 0,
+            flags3: 0,
+            takerOwner,
+            makerOwner,
+            market,
+            strike: 1n,
+            quantity: 1n,
+            totalPremium: 1n,
+            orderId: new Uint8Array(32).fill(0x11),
+            reserved: Array(32).fill(0n),
+        });
+        expect(() => (0, fetch_1.decodeMarketAccount)(buffer_1.Buffer.from(positionData))).toThrow("Invalid Market account discriminator");
+        expect(() => (0, fetch_1.decodeMarketAccount)(buffer_1.Buffer.alloc(8))).toThrow("Invalid Market account size");
+    });
 });

package/dist/cjs/ws/client.js

@@ -79,6 +79,7 @@ class ActaWsClient extends TypedEventEmitter {
     authProvider = null;
     authRequested = false;
     startAuthSent = false;
+    pendingResumeSessionId = null;
     connectionState = "disconnected";
     sessionId = null;
     helloSent = false;
@@ -122,22 +123,25 @@ class ActaWsClient extends TypedEventEmitter {
     connectAnonymous() {
         this.authProvider = null;
         this.authRequested = false;
+        this.pendingResumeSessionId = null;
         this.shouldReconnect = this.options.autoReconnect;
         this.doConnect();
     }
     connect(authProvider) {
         this.authProvider = authProvider;
         this.authRequested = false;
+        this.pendingResumeSessionId = null;
         this.shouldReconnect = this.options.autoReconnect;
         this.doConnect();
     }
-    connectAndAuthenticate(authProvider) {
+    connectAndAuthenticate(authProvider, options) {
         this.authProvider = authProvider;
         this.authRequested = true;
+        this.pendingResumeSessionId = options?.sessionId ?? null;
         this.shouldReconnect = this.options.autoReconnect;
         if (this.ws?.readyState === WS_OPEN) {
             if (this.welcomeReceived && !this.startAuthSent) {
-                void this.sendStartAuth().catch((err) => {
+                void this.beginAuthHandshake().catch((err) => {
                     this.emit("error", err);
                     this.setConnectionState("error");
                 });
@@ -149,6 +153,7 @@ class ActaWsClient extends TypedEventEmitter {
     async authenticate(authProvider) {
         this.authProvider = authProvider;
         this.authRequested = true;
+        this.pendingResumeSessionId = null;
         if (this.ws?.readyState === WS_OPEN) {
             if (this.welcomeReceived && !this.startAuthSent) {
                 await this.sendStartAuth();
@@ -319,6 +324,10 @@ class ActaWsClient extends TypedEventEmitter {
             this.send({ type: "Ping" });
         }
     }
+    resumeAuth(sessionId) {
+        this.pendingResumeSessionId = sessionId;
+        this.sendResumeAuth(sessionId);
+    }
     doConnect() {
         if (this.ws) {
             this.cleanup();
@@ -379,7 +388,7 @@ class ActaWsClient extends TypedEventEmitter {
                 this.emit("welcome", message.data);
                 this.flushPendingMessages();
                 if (this.authRequested && this.authProvider && !this.startAuthSent) {
-                    void this.sendStartAuth().catch((err) => {
+                    void this.beginAuthHandshake().catch((err) => {
                         this.emit("error", err);
                         this.setConnectionState("error");
                     });
@@ -404,10 +413,10 @@ class ActaWsClient extends TypedEventEmitter {
                 void this.handleAuthRequest(message.data.challenge);
                 break;
             case "AuthSuccess":
-                this.handleAuthSuccess(message.data.session_id);
+                this.handleAuthSuccess(message.data.session_id, message.data.expires_at);
                 break;
             case "AuthError":
-                this.handleAuthError(message.data.reason);
+                this.handleAuthError(message.data.reason, message.data.message);
                 break;
             case "Snapshot":
                 this.handleSnapshot(message.data);
@@ -609,6 +618,13 @@ class ActaWsClient extends TypedEventEmitter {
             this.setConnectionState("error");
         }
     }
+    async beginAuthHandshake() {
+        if (this.pendingResumeSessionId) {
+            this.sendResumeAuth(this.pendingResumeSessionId);
+            return;
+        }
+        await this.sendStartAuth();
+    }
     async sendStartAuth() {
         if (!this.authProvider)
             throw new Error("No auth provider configured");
@@ -616,6 +632,10 @@ class ActaWsClient extends TypedEventEmitter {
         const pubkey = await this.authProvider.getPublicKey();
         this.send({ type: "StartAuth", data: { pubkey } });
     }
+    sendResumeAuth(sessionId) {
+        this.startAuthSent = true;
+        this.send({ type: "ResumeAuth", data: { session_id: sessionId } });
+    }
     sendHello() {
         const hello = {
             protocol_version: this.options.protocolVersion,
@@ -634,10 +654,11 @@ class ActaWsClient extends TypedEventEmitter {
             this.send(msg);
         }
     }
-    handleAuthSuccess(sessionId) {
+    handleAuthSuccess(sessionId, expiresAt) {
         this.sessionId = sessionId;
+        this.pendingResumeSessionId = null;
         this.setConnectionState("authenticated");
-        this.emit("authenticated", sessionId);
+        this.emit("authenticated", sessionId, expiresAt);
         if (this.subscribedChannels.size > 0) {
             const channels = Array.from(this.subscribedChannels);
             const data = this.hasMarketScope
@@ -646,9 +667,23 @@ class ActaWsClient extends TypedEventEmitter {
             this.send({ type: "Subscribe", data });
         }
     }
-    handleAuthError(reason) {
+    handleAuthError(reason, message) {
+        this.emit("authError", reason);
+        if (reason === "session_expired" &&
+            this.authRequested &&
+            this.authProvider &&
+            this.pendingResumeSessionId) {
+            this.pendingResumeSessionId = null;
+            this.startAuthSent = false;
+            void this.sendStartAuth().catch((err) => {
+                this.emit("error", err);
+                this.setConnectionState("error");
+            });
+            return;
+        }
         this.setConnectionState("error");
-        this.emit("error", new Error(`Authentication failed: ${reason}`));
+        const details = message ? `${reason}: ${message}` : reason;
+        this.emit("error", new Error(`Authentication failed: ${details}`));
     }
     handleSnapshot(snapshot) {
         this.state.stats = snapshot.stats;
@@ -848,6 +883,7 @@ 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

@@ -121,6 +121,62 @@ describe("ActaWsClient", () => {
             expect(authChallenge.data.challenge).toBe("challenge-text");
         }
     });
+    it("connectAndAuthenticate sends ResumeAuth when sessionId is provided", async () => {
+        const { client, socket } = makeHarness();
+        const auth = makeAuthProvider("WalletPubkey", "WalletSignature");
+        client.connectAndAuthenticate(auth, { sessionId: "resume-session-id" });
+        const 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("resume-session-id");
+        }
+    });
+    it("falls back to StartAuth when ResumeAuth session_expired", async () => {
+        const { client, socket } = makeHarness();
+        const auth = makeAuthProvider("WalletPubkey", "WalletSignature");
+        client.connectAndAuthenticate(auth, { sessionId: "expired-session" });
+        const ws = socket();
+        ws.triggerOpen();
+        ws.triggerMessage(WELCOME_MESSAGE);
+        await flushMicrotasks();
+        ws.triggerMessage({
+            type: "AuthError",
+            data: { reason: "session_expired" },
+        });
+        await flushMicrotasks();
+        const sentTypes = ws.sent.map((payload) => parseClientMessage(payload).type);
+        expect(sentTypes).toEqual(["Hello", "ResumeAuth", "StartAuth"]);
+    });
+    it("emits authenticated with expiresAt from AuthSuccess", () => {
+        const { client } = makeHarness();
+        const seen = [];
+        client.on("authenticated", (sessionId, expiresAt) => {
+            seen.push({ sessionId, expiresAt });
+        });
+        client.handleMessage({
+            type: "AuthSuccess",
+            data: { session_id: "auth-session", expires_at: 1_710_086_400 },
+        });
+        expect(seen).toEqual([
+            { sessionId: "auth-session", expiresAt: 1_710_086_400 },
+        ]);
+    });
+    it("emits authError reason on AuthError", () => {
+        const { client } = makeHarness();
+        const reasons = [];
+        client.on("authError", (reason) => reasons.push(reason));
+        client.handleMessage({
+            type: "AuthError",
+            data: { reason: "invalid_signature", message: "bad signature bytes" },
+        });
+        expect(reasons).toEqual(["invalid_signature"]);
+    });
     it("drop_oldest policy keeps the latest queued messages", () => {
         const { client, socket } = makeHarness({
             maxPendingMessages: 2,

package/dist/ws/client.d.ts

@@ -56,7 +56,8 @@ export type ActaWsClientEvents = {
     connected: () => void;
     welcome: (msg: WelcomeMessage) => void;
     versionMismatch: (msg: VersionMismatchMessage) => void;
-    authenticated: (sessionId: string) => void;
+    authenticated: (sessionId: string, expiresAt: number | null) => void;
+    authError: (reason: string) => void;
     disconnected: (code: number, reason: string) => void;
     error: (error: Error) => void;
     stateChange: (state: ConnectionState) => void;
@@ -147,6 +148,7 @@ export declare class ActaWsClient extends TypedEventEmitter<ActaWsClientEvents>
     private authProvider;
     private authRequested;
     private startAuthSent;
+    private pendingResumeSessionId;
     private connectionState;
     private sessionId;
     private helloSent;
@@ -163,7 +165,9 @@ export declare class ActaWsClient extends TypedEventEmitter<ActaWsClientEvents>
     constructor(options: ActaWsClientOptions);
     connectAnonymous(): void;
     connect(authProvider: AuthProvider): void;
-    connectAndAuthenticate(authProvider: AuthProvider): void;
+    connectAndAuthenticate(authProvider: AuthProvider, options?: {
+        sessionId?: string;
+    }): void;
     authenticate(authProvider: AuthProvider): Promise<void>;
     disconnect(): void;
     getConnectionState(): ConnectionState;
@@ -228,6 +232,7 @@ export declare class ActaWsClient extends TypedEventEmitter<ActaWsClientEvents>
     subscribe(channels: WsChannel[], markets?: string[]): void;
     unsubscribe(channels: WsChannel[]): void;
     ping(): void;
+    resumeAuth(sessionId: string): void;
     private doConnect;
     private handleMessage;
     /** Taker-only: request current indicative prices for a market + position_type. */
@@ -235,7 +240,9 @@ export declare class ActaWsClient extends TypedEventEmitter<ActaWsClientEvents>
     /** Maker-only: respond to an indicative request (unsigned, non-binding). */
     sendIndicativePricesResponse(resp: IndicativePricesResponseMessage): void;
     private handleAuthRequest;
+    private beginAuthHandshake;
     private sendStartAuth;
+    private sendResumeAuth;
     private sendHello;
     private flushPendingMessages;
     private handleAuthSuccess;

package/dist/ws/client.js

@@ -76,6 +76,7 @@ export class ActaWsClient extends TypedEventEmitter {
     authProvider = null;
     authRequested = false;
     startAuthSent = false;
+    pendingResumeSessionId = null;
     connectionState = "disconnected";
     sessionId = null;
     helloSent = false;
@@ -119,22 +120,25 @@ export class ActaWsClient extends TypedEventEmitter {
     connectAnonymous() {
         this.authProvider = null;
         this.authRequested = false;
+        this.pendingResumeSessionId = null;
         this.shouldReconnect = this.options.autoReconnect;
         this.doConnect();
     }
     connect(authProvider) {
         this.authProvider = authProvider;
         this.authRequested = false;
+        this.pendingResumeSessionId = null;
         this.shouldReconnect = this.options.autoReconnect;
         this.doConnect();
     }
-    connectAndAuthenticate(authProvider) {
+    connectAndAuthenticate(authProvider, options) {
         this.authProvider = authProvider;
         this.authRequested = true;
+        this.pendingResumeSessionId = options?.sessionId ?? null;
         this.shouldReconnect = this.options.autoReconnect;
         if (this.ws?.readyState === WS_OPEN) {
             if (this.welcomeReceived && !this.startAuthSent) {
-                void this.sendStartAuth().catch((err) => {
+                void this.beginAuthHandshake().catch((err) => {
                     this.emit("error", err);
                     this.setConnectionState("error");
                 });
@@ -146,6 +150,7 @@ export class ActaWsClient extends TypedEventEmitter {
     async authenticate(authProvider) {
         this.authProvider = authProvider;
         this.authRequested = true;
+        this.pendingResumeSessionId = null;
         if (this.ws?.readyState === WS_OPEN) {
             if (this.welcomeReceived && !this.startAuthSent) {
                 await this.sendStartAuth();
@@ -316,6 +321,10 @@ export class ActaWsClient extends TypedEventEmitter {
             this.send({ type: "Ping" });
         }
     }
+    resumeAuth(sessionId) {
+        this.pendingResumeSessionId = sessionId;
+        this.sendResumeAuth(sessionId);
+    }
     doConnect() {
         if (this.ws) {
             this.cleanup();
@@ -376,7 +385,7 @@ export class ActaWsClient extends TypedEventEmitter {
                 this.emit("welcome", message.data);
                 this.flushPendingMessages();
                 if (this.authRequested && this.authProvider && !this.startAuthSent) {
-                    void this.sendStartAuth().catch((err) => {
+                    void this.beginAuthHandshake().catch((err) => {
                         this.emit("error", err);
                         this.setConnectionState("error");
                     });
@@ -401,10 +410,10 @@ export class ActaWsClient extends TypedEventEmitter {
                 void this.handleAuthRequest(message.data.challenge);
                 break;
             case "AuthSuccess":
-                this.handleAuthSuccess(message.data.session_id);
+                this.handleAuthSuccess(message.data.session_id, message.data.expires_at);
                 break;
             case "AuthError":
-                this.handleAuthError(message.data.reason);
+                this.handleAuthError(message.data.reason, message.data.message);
                 break;
             case "Snapshot":
                 this.handleSnapshot(message.data);
@@ -606,6 +615,13 @@ export class ActaWsClient extends TypedEventEmitter {
             this.setConnectionState("error");
         }
     }
+    async beginAuthHandshake() {
+        if (this.pendingResumeSessionId) {
+            this.sendResumeAuth(this.pendingResumeSessionId);
+            return;
+        }
+        await this.sendStartAuth();
+    }
     async sendStartAuth() {
         if (!this.authProvider)
             throw new Error("No auth provider configured");
@@ -613,6 +629,10 @@ export class ActaWsClient extends TypedEventEmitter {
         const pubkey = await this.authProvider.getPublicKey();
         this.send({ type: "StartAuth", data: { pubkey } });
     }
+    sendResumeAuth(sessionId) {
+        this.startAuthSent = true;
+        this.send({ type: "ResumeAuth", data: { session_id: sessionId } });
+    }
     sendHello() {
         const hello = {
             protocol_version: this.options.protocolVersion,
@@ -631,10 +651,11 @@ export class ActaWsClient extends TypedEventEmitter {
             this.send(msg);
         }
     }
-    handleAuthSuccess(sessionId) {
+    handleAuthSuccess(sessionId, expiresAt) {
         this.sessionId = sessionId;
+        this.pendingResumeSessionId = null;
         this.setConnectionState("authenticated");
-        this.emit("authenticated", sessionId);
+        this.emit("authenticated", sessionId, expiresAt);
         if (this.subscribedChannels.size > 0) {
             const channels = Array.from(this.subscribedChannels);
             const data = this.hasMarketScope
@@ -643,9 +664,23 @@ export class ActaWsClient extends TypedEventEmitter {
             this.send({ type: "Subscribe", data });
         }
     }
-    handleAuthError(reason) {
+    handleAuthError(reason, message) {
+        this.emit("authError", reason);
+        if (reason === "session_expired" &&
+            this.authRequested &&
+            this.authProvider &&
+            this.pendingResumeSessionId) {
+            this.pendingResumeSessionId = null;
+            this.startAuthSent = false;
+            void this.sendStartAuth().catch((err) => {
+                this.emit("error", err);
+                this.setConnectionState("error");
+            });
+            return;
+        }
         this.setConnectionState("error");
-        this.emit("error", new Error(`Authentication failed: ${reason}`));
+        const details = message ? `${reason}: ${message}` : reason;
+        this.emit("error", new Error(`Authentication failed: ${details}`));
     }
     handleSnapshot(snapshot) {
         this.state.stats = snapshot.stats;
@@ -845,6 +880,7 @@ export class ActaWsClient extends TypedEventEmitter {
         this.helloSent = false;
         this.welcomeReceived = false;
         this.startAuthSent = false;
+        this.pendingResumeSessionId = null;
         this.pendingMessages = [];
         this.setConnectionState("disconnected");
     }

package/dist/ws/client.test.js

@@ -119,6 +119,62 @@ describe("ActaWsClient", () => {
             expect(authChallenge.data.challenge).toBe("challenge-text");
         }
     });
+    it("connectAndAuthenticate sends ResumeAuth when sessionId is provided", async () => {
+        const { client, socket } = makeHarness();
+        const auth = makeAuthProvider("WalletPubkey", "WalletSignature");
+        client.connectAndAuthenticate(auth, { sessionId: "resume-session-id" });
+        const 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("resume-session-id");
+        }
+    });
+    it("falls back to StartAuth when ResumeAuth session_expired", async () => {
+        const { client, socket } = makeHarness();
+        const auth = makeAuthProvider("WalletPubkey", "WalletSignature");
+        client.connectAndAuthenticate(auth, { sessionId: "expired-session" });
+        const ws = socket();
+        ws.triggerOpen();
+        ws.triggerMessage(WELCOME_MESSAGE);
+        await flushMicrotasks();
+        ws.triggerMessage({
+            type: "AuthError",
+            data: { reason: "session_expired" },
+        });
+        await flushMicrotasks();
+        const sentTypes = ws.sent.map((payload) => parseClientMessage(payload).type);
+        expect(sentTypes).toEqual(["Hello", "ResumeAuth", "StartAuth"]);
+    });
+    it("emits authenticated with expiresAt from AuthSuccess", () => {
+        const { client } = makeHarness();
+        const seen = [];
+        client.on("authenticated", (sessionId, expiresAt) => {
+            seen.push({ sessionId, expiresAt });
+        });
+        client.handleMessage({
+            type: "AuthSuccess",
+            data: { session_id: "auth-session", expires_at: 1_710_086_400 },
+        });
+        expect(seen).toEqual([
+            { sessionId: "auth-session", expiresAt: 1_710_086_400 },
+        ]);
+    });
+    it("emits authError reason on AuthError", () => {
+        const { client } = makeHarness();
+        const reasons = [];
+        client.on("authError", (reason) => reasons.push(reason));
+        client.handleMessage({
+            type: "AuthError",
+            data: { reason: "invalid_signature", message: "bad signature bytes" },
+        });
+        expect(reasons).toEqual(["invalid_signature"]);
+    });
     it("drop_oldest policy keeps the latest queued messages", () => {
         const { client, socket } = makeHarness({
             maxPendingMessages: 2,

package/dist/ws/types.d.ts

@@ -78,6 +78,11 @@ export type ClientMessage = {
     data: {
         pubkey: string;
     };
+} | {
+    type: "ResumeAuth";
+    data: {
+        session_id: string;
+    };
 } | {
     type: "AuthChallenge";
     data: AuthChallengeData;
@@ -255,11 +260,13 @@ export type ServerMessage = {
     type: "AuthSuccess";
     data: {
         session_id: string;
+        expires_at: WsI64 | null;
     };
 } | {
     type: "AuthError";
     data: {
         reason: ErrorMessage;
+        message?: string;
     };
 } | {
     type: "RfqCreated";
@@ -628,6 +635,8 @@ export type MakerPositionInfo = {
     strike: WsU64;
     quantity: WsU64;
     price: WsU64;
+    /** Net premium amount from on-chain position state (quote token base units). */
+    total_premium: WsU64;
     collateral_locked: WsU64;
     created_at: WsU64;
     expiry_ts: WsU64;
@@ -813,6 +822,8 @@ export type PositionInfo = {
     strike: WsU64;
     quantity: WsU64;
     price: WsU64;
+    /** Net premium amount from on-chain position state (quote token base units). */
+    total_premium: WsU64;
     created_at: WsU64;
 };
 export type TradeInfo = {

package/package.json

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