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

package/README.md

@@ -82,7 +82,11 @@ client.ws!.on("chainEvent", (e) => console.log("chain event", e));
 
 ```ts
 client.ws!.on("markets", (markets) => console.log("markets", markets));
-client.ws!.on("positions", (positions) => console.log("positions", positions));
+client.ws!.on("positions", (positions) => {
+  console.log("positions", positions);
+  // taker position payload includes market expiry as unix seconds
+  console.log("first expiry", positions[0]?.expiry_ts);
+});
 
 client.ws!.getMarkets();
 // positions require auth:

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/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/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";
@@ -818,6 +825,8 @@ export type PositionInfo = {
     /** Net premium amount from on-chain position state (quote token base units). */
     total_premium: WsU64;
     created_at: WsU64;
+    /** Market expiry timestamp (unix seconds), sourced from markets table join. */
+    expiry_ts: WsU64;
 };
 export type TradeInfo = {
     id: UuidString;

package/package.json

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