@fivenorth/loop-sdk 0.7.2 → 0.7.3

package/dist/index.js

@@ -2067,6 +2067,43 @@ var MessageType;
   MessageType2["REJECT_REQUEST"] = "reject_request";
 })(MessageType ||= {});
 
+// src/errors.ts
+class RequestTimeoutError extends Error {
+  constructor(timeout) {
+    super(`Request timed out after ${timeout}ms.`);
+  }
+}
+
+class RejectRequestError extends Error {
+  constructor() {
+    super("Request was rejected by the wallet.");
+  }
+}
+
+class UnauthorizedError extends Error {
+  code;
+  constructor(code) {
+    super(code || "Unauthorized");
+    this.code = code;
+  }
+}
+var UNAUTH_CODES = new Set(["UNAUTHENTICATED", "UNAUTHORIZED", "SESSION_EXPIRED", "LOGGED_OUT"]);
+function extractErrorCode(message) {
+  if (typeof message?.error?.code === "string" && message.error.code.length > 0) {
+    return message.error.code;
+  }
+  if (message?.type === "unauthorized" && typeof message?.code === "string") {
+    return message.code;
+  }
+  return null;
+}
+function isUnauthCode(code) {
+  if (!code) {
+    return false;
+  }
+  return UNAUTH_CODES.has(code);
+}
+
 // src/connection.ts
 class Connection {
   walletUrl = "https://cantonloop.com";
@@ -2076,6 +2113,7 @@ class Connection {
   ticketId = null;
   onMessageHandler = null;
   reconnectPromise = null;
+  status = "disconnected";
   constructor({ network, walletUrl, apiUrl }) {
     this.network = network || "main";
     switch (this.network) {
@@ -2106,6 +2144,9 @@ class Connection {
       this.apiUrl = apiUrl;
     }
   }
+  connectInProgress() {
+    return this.status === "connecting" || this.status === "connected";
+  }
   async getTicket(appName, sessionId, version) {
     const response = await fetch(`${this.apiUrl}/api/v1/.connect/pair/tickets`, {
       method: "POST",
@@ -2198,7 +2239,10 @@ class Connection {
       }
     });
     if (!response.ok) {
-      throw new Error("Session verification failed.");
+      if (response.status === 401 || response.status === 403) {
+        throw new UnauthorizedError;
+      }
+      throw new Error(`Session verification failed with status ${response.status}.`);
     }
     const data = await response.json();
     const email = data?.email;
@@ -2216,45 +2260,24 @@ class Connection {
     };
     return account;
   }
-  websocketUrl(ticketId) {
-    return `${this.network === "local" ? "ws" : "wss"}://${this.apiUrl.replace("https://", "").replace("http://", "")}/api/v1/.connect/pair/ws/${ticketId}`;
-  }
-  attachWebSocket(ticketId, onMessage, onOpen, onError, onClose) {
-    const wsUrl = this.websocketUrl(ticketId);
-    const ws = new WebSocket(wsUrl);
-    ws.onmessage = onMessage;
-    ws.onopen = () => {
-      console.log("Connected to ticket server.");
-      onOpen?.();
-    };
-    ws.onclose = (event) => {
-      if (this.ws === ws) {
-        this.ws = null;
-      }
-      console.log("Disconnected from ticket server.");
-      onClose?.(event);
-    };
-    ws.onerror = (event) => {
-      if (this.ws === ws) {
-        this.ws = null;
-      }
-      onError?.(event);
-    };
-    this.ws = ws;
-  }
   connectWebSocket(ticketId, onMessage) {
-    this.ticketId = ticketId;
+    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) && this.ticketId !== ticketId) {
+      this.ws.close();
+      this.ws = null;
+    }
+    if (this.status === "connecting" || this.status === "connected") {
+      return;
+    }
     this.onMessageHandler = onMessage;
+    this.ticketId = ticketId;
+    this.status = "connecting";
     this.attachWebSocket(ticketId, onMessage);
   }
   reconnect() {
     if (!this.ticketId || !this.onMessageHandler) {
       return Promise.reject(new Error("Cannot reconnect without a known ticket."));
     }
-    if (this.reconnectPromise) {
-      return this.reconnectPromise;
-    }
-    this.reconnectPromise = new Promise((resolve, reject) => {
+    return new Promise((resolve, reject) => {
       let opened = false;
       this.attachWebSocket(this.ticketId, this.onMessageHandler, () => {
         opened = true;
@@ -2270,29 +2293,37 @@ class Connection {
         }
         reject(new Error("Failed to reconnect to ticket server."));
       });
-    }).finally(() => {
-      this.reconnectPromise = null;
     });
-    return this.reconnectPromise;
   }
-  async reconnectWebSocket() {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      return;
-    }
-    return this.reconnect();
-  }
-}
-
-// src/errors.ts
-class RequestTimeoutError extends Error {
-  constructor(timeout) {
-    super(`Request timed out after ${timeout}ms.`);
+  websocketUrl(ticketId) {
+    return `${this.network === "local" ? "ws" : "wss"}://${this.apiUrl.replace("https://", "").replace("http://", "")}/api/v1/.connect/pair/ws/${encodeURIComponent(ticketId)}`;
   }
-}
-
-class RejectRequestError extends Error {
-  constructor() {
-    super("Request was rejected by the wallet.");
+  attachWebSocket(ticketId, onMessage, onOpen, onError, onClose) {
+    const wsUrl = this.websocketUrl(ticketId);
+    const ws = new WebSocket(wsUrl);
+    ws.onmessage = onMessage;
+    ws.onopen = () => {
+      this.status = "connected";
+      console.log("[LoopSDK] Connected to ticket server.");
+      onOpen?.();
+    };
+    ws.onclose = (event) => {
+      this.status = "disconnected";
+      if (this.ws === ws) {
+        this.ws = null;
+      }
+      console.log("[LoopSDK] Disconnected from ticket server.");
+      onClose?.(event);
+    };
+    ws.onerror = (event) => {
+      this.status = "disconnected";
+      ws.close();
+      if (this.ws === ws) {
+        this.ws = null;
+      }
+      onError?.(event);
+    };
+    this.ws = ws;
   }
 }
 
@@ -2403,24 +2434,24 @@ class Provider {
   }
   async ensureConnected() {
     if (this.connection.ws && this.connection.ws.readyState === WebSocket.OPEN) {
-      return;
+      return Promise.resolve();
     }
-    if (typeof this.connection.reconnectWebSocket === "function") {
-      await this.connection.reconnectWebSocket();
-      if (this.connection.ws && this.connection.ws.readyState === WebSocket.OPEN) {
-        return;
-      }
+    await this.connection.reconnect();
+    if (this.connection.ws && this.connection.ws.readyState === WebSocket.OPEN) {
+      return;
     }
     throw new Error("Not connected.");
   }
   sendRequest(messageType, params = {}, options) {
     return new Promise((resolve, reject) => {
       const requestId = generateRequestId();
-      const requestContext = this.hooks?.onRequestStart?.(messageType, options?.requestLabel);
+      let requestContext;
       const ensure = async () => {
         try {
           await this.ensureConnected();
+          requestContext = await this.hooks?.onRequestStart?.(messageType, options?.requestLabel);
         } catch (error) {
+          console.error("[LoopSDK] error when checking connection status", error);
           this.hooks?.onRequestFinish?.({
             status: "error",
             messageType,
@@ -2444,7 +2475,13 @@ class Provider {
             };
           }
         }
-        this.connection.ws.send(JSON.stringify(requestBody));
+        try {
+          this.connection.ws.send(JSON.stringify(requestBody));
+        } catch (error) {
+          console.error("[LoopSDK] error when sending request", error);
+          reject(error);
+          return;
+        }
         const intervalTime = 300;
         let elapsedTime = 0;
         const timeoutMs = options?.requestTimeout ?? this.requestTimeout;
@@ -2453,6 +2490,18 @@ class Provider {
           if (response) {
             clearInterval(intervalId);
             this.requests.delete(requestId);
+            const code = extractErrorCode(response);
+            if (isUnauthCode(code)) {
+              this.hooks?.onRequestFinish?.({
+                status: "error",
+                messageType,
+                requestLabel: options?.requestLabel,
+                requestContext,
+                errorCode: code
+              });
+              reject(new UnauthorizedError(code));
+              return;
+            }
             if (response.type === "reject_request" /* REJECT_REQUEST */) {
               this.hooks?.onRequestFinish?.({
                 status: "rejected",
@@ -2568,11 +2617,87 @@ class LoopWallet {
   }
 }
 
+// src/session.ts
+var STORAGE_KEY_LOOP_CONNECT = "loop_connect";
+
+class SessionInfo {
+  sessionId;
+  ticketId;
+  authToken;
+  partyId;
+  publicKey;
+  email;
+  _isAuthorized = false;
+  constructor({ sessionId, ticketId, authToken, partyId, publicKey, email }) {
+    this.sessionId = sessionId;
+    this.ticketId = ticketId;
+    this.authToken = authToken;
+    this.partyId = partyId;
+    this.publicKey = publicKey;
+    this.email = email;
+  }
+  setTicketId(ticketId) {
+    this.ticketId = ticketId;
+    this.save();
+  }
+  authorized() {
+    if (this.ticketId === undefined || this.sessionId === undefined || this.authToken === undefined || this.partyId === undefined || this.publicKey === undefined) {
+      throw new Error("Session cannot be authorized without all required fields.");
+    }
+    this._isAuthorized = true;
+  }
+  isPreAuthorized() {
+    return !this._isAuthorized && this.ticketId !== undefined && this.sessionId !== undefined && this.authToken !== undefined && this.partyId !== undefined && this.publicKey !== undefined;
+  }
+  isAuthorized() {
+    return this._isAuthorized;
+  }
+  save() {
+    localStorage.setItem("loop_connect", this.toJson());
+  }
+  reset() {
+    localStorage.removeItem(STORAGE_KEY_LOOP_CONNECT);
+    this.sessionId = generateRequestId();
+    this._isAuthorized = false;
+    this.ticketId = undefined;
+    this.authToken = undefined;
+    this.partyId = undefined;
+    this.publicKey = undefined;
+    this.email = undefined;
+  }
+  static fromStorage() {
+    const existingConnectionRaw = localStorage.getItem(STORAGE_KEY_LOOP_CONNECT);
+    if (!existingConnectionRaw) {
+      return new SessionInfo({ sessionId: generateRequestId() });
+    }
+    let session = null;
+    try {
+      session = new SessionInfo(JSON.parse(existingConnectionRaw));
+    } catch (error) {
+      console.error("Failed to parse existing connection info, local storage is corrupted.", error);
+      localStorage.removeItem(STORAGE_KEY_LOOP_CONNECT);
+      session = new SessionInfo({ sessionId: generateRequestId() });
+    }
+    return session;
+  }
+  toJson() {
+    return JSON.stringify({
+      sessionId: this.sessionId,
+      ticketId: this.ticketId,
+      authToken: this.authToken,
+      partyId: this.partyId,
+      publicKey: this.publicKey,
+      email: this.email
+    });
+  }
+}
+
 // src/index.ts
 class LoopSDK {
-  version = "0.0.1";
+  version = "0.7.3";
   appName = "Unknown";
   connection = null;
+  session = null;
   provider = null;
   openMode = "popup";
   requestSigningMode = "popup";
@@ -2581,7 +2706,6 @@ class LoopSDK {
   onAccept = null;
   onReject = null;
   overlay = null;
-  ticketId = null;
   wallet;
   constructor() {
     this.wallet = new LoopWallet(() => this.provider);
@@ -2595,6 +2719,9 @@ class LoopSDK {
     onReject,
     options
   }) {
+    if (typeof window === "undefined" || typeof document === "undefined" || typeof localStorage === "undefined") {
+      throw new Error("LoopSDK can only be initialized in a browser environment with localStorage support.");
+    }
     this.appName = appName;
     this.onAccept = onAccept || null;
     this.onReject = onReject || null;
@@ -2609,70 +2736,68 @@ class LoopSDK {
     this.redirectUrl = resolvedOptions.redirectUrl;
     this.connection = new Connection({ network, walletUrl, apiUrl });
   }
-  async connect() {
-    if (typeof window === "undefined") {
-      console.warn("LoopSDK.connect() can only be called in a browser environment.");
+  async loadSessionInfo() {
+    if (this.session) {
+      return;
+    }
+    this.session = SessionInfo.fromStorage();
+    if (!this.session.isPreAuthorized()) {
       return;
     }
+    try {
+      const verifiedAccount = await this.connection?.verifySession(this.session.authToken);
+      if (!verifiedAccount || verifiedAccount?.party_id !== this.session.partyId) {
+        console.warn("[LoopSDK] Stored partyId does not match verified account. Clearing cached session.");
+        this.logout();
+        return;
+      }
+      this.session.authorized();
+    } catch (err) {
+      if (err instanceof UnauthorizedError) {
+        console.error("Unauthorized error when verifying session.", err);
+        this.session.reset();
+        return;
+      }
+      console.error("[LoopSDK] Failed to verify session.", err);
+      throw err;
+    }
+  }
+  async autoConnect() {
     if (!this.connection) {
       throw new Error("SDK not initialized. Call init() first.");
     }
-    const existingConnectionRaw = localStorage.getItem("loop_connect");
-    if (existingConnectionRaw) {
-      try {
-        let canReuseTicket = true;
-        const { ticketId, authToken, partyId, publicKey, email } = JSON.parse(existingConnectionRaw);
-        if (authToken && partyId && publicKey) {
-          try {
-            const verifiedAccount = await this.connection.verifySession(authToken);
-            if (verifiedAccount.party_id === partyId) {
-              this.provider = new Provider({
-                connection: this.connection,
-                party_id: partyId,
-                auth_token: authToken,
-                public_key: publicKey,
-                email,
-                hooks: this.createProviderHooks()
-              });
-              this.ticketId = ticketId || null;
-              this.onAccept?.(this.provider);
-              if (ticketId) {
-                this.connection.connectWebSocket(ticketId, this.handleWebSocketMessage.bind(this));
-              }
-              return;
-            } else {
-              console.warn("[LoopSDK] Sttored partyId does not march verified account. Clearing cached session.");
-              canReuseTicket = false;
-              localStorage.removeItem("loop_connect");
-            }
-          } catch (err) {
-            console.error("Auto-login failed, token is invalid. Starting new connection.", err);
-            canReuseTicket = false;
-            localStorage.removeItem("loop_connect");
-          }
-        }
-        if (ticketId && canReuseTicket) {
-          this.ticketId = ticketId;
-          const url = new URL("/.connect/", this.connection.walletUrl);
-          url.searchParams.set("ticketId", ticketId);
-          if (this.redirectUrl) {
-            url.searchParams.set("redirectUrl", this.redirectUrl);
-          }
-          const connectUrl = url.toString();
-          this.showQrCode(connectUrl);
-          this.connection.connectWebSocket(ticketId, this.handleWebSocketMessage.bind(this));
-          return;
-        }
-      } catch (error) {
-        console.error("Failed to parse existing connection info, creating a new one.", error);
-      }
-      localStorage.removeItem("loop_connect");
+    await this.loadSessionInfo();
+    if (!this.session) {
+      throw new Error("No valid session found. The network connection maynot available or the backend is not reachable.");
+    }
+    if (this.session.isAuthorized()) {
+      this.provider = new Provider({
+        connection: this.connection,
+        party_id: this.session.partyId,
+        auth_token: this.session.authToken,
+        public_key: this.session.publicKey,
+        email: this.session.email,
+        hooks: this.createProviderHooks()
+      });
+      this.onAccept?.(this.provider);
+      this.connection.connectWebSocket(this.session.ticketId, this.handleWebSocketMessage.bind(this));
+      return Promise.resolve();
+    }
+  }
+  async connect() {
+    if (!this.connection) {
+      throw new Error("SDK not initialized. Call init() first.");
+    }
+    await this.autoConnect();
+    if (this.connection?.connectInProgress() === true) {
+      return;
+    }
+    if (this.session && this.session.isAuthorized()) {
+      return;
     }
-    const sessionId = generateRequestId();
     try {
-      const { ticket_id: ticketId } = await this.connection.getTicket(this.appName, sessionId, this.version);
-      this.ticketId = ticketId;
-      localStorage.setItem("loop_connect", JSON.stringify({ sessionId, ticketId }));
+      const { ticket_id: ticketId } = await this.connection.getTicket(this.appName, this.session.sessionId, this.version);
+      this.session.setTicketId(ticketId);
       const connectUrl = this.buildConnectUrl(ticketId);
       this.showQrCode(connectUrl);
       this.connection.connectWebSocket(ticketId, this.handleWebSocketMessage.bind(this));
@@ -2683,6 +2808,12 @@ class LoopSDK {
   }
   handleWebSocketMessage(event) {
     const message = JSON.parse(event.data);
+    const errCode = extractErrorCode(message);
+    if (isUnauthCode(errCode)) {
+      console.warn("[LoopSDK] Detected session invalidation:", errCode, { message });
+      this.logout();
+      return;
+    }
     console.log("[LoopSDK] WS message received:", message);
     if (message.type === "handshake_accept" /* HANDSHAKE_ACCEPT */) {
       console.log("[LoopSDK] Entering HANDSHAKE_ACCEPT flow");
@@ -2696,32 +2827,27 @@ class LoopSDK {
           email,
           hooks: this.createProviderHooks()
         });
-        const connectionInfoRaw = localStorage.getItem("loop_connect");
-        if (connectionInfoRaw) {
-          try {
-            const connectionInfo = JSON.parse(connectionInfoRaw);
-            this.ticketId = connectionInfo.ticketId || this.ticketId;
-            connectionInfo.authToken = authToken;
-            connectionInfo.partyId = partyId;
-            connectionInfo.publicKey = publicKey;
-            connectionInfo.email = email;
-            localStorage.setItem("loop_connect", JSON.stringify(connectionInfo));
-            this.onAccept?.(this.provider);
-            this.hideQrCode();
-            this.connection?.connectWebSocket(connectionInfo.ticketId, this.handleWebSocketMessage.bind(this));
-            console.log("[LoopSDK] HANDSHAKE_ACCEPT: closing popup (if exists)");
-            this.popupWindow = null;
-          } catch (error) {
-            console.error("Failed to update local storage with auth token.", error);
-          }
+        try {
+          this.session.authToken = authToken;
+          this.session.partyId = partyId;
+          this.session.publicKey = publicKey;
+          this.session.email = email;
+          this.session.authorized();
+          this.session.save();
+          this.onAccept?.(this.provider);
+          this.hideQrCode();
+          console.log("[LoopSDK] HANDSHAKE_ACCEPT: closing popup (if exists)");
+          this.popupWindow = null;
+        } catch (error) {
+          console.error("Failed to update local storage with auth token.", error);
         }
       }
     } else if (message.type === "handshake_reject" /* HANDSHAKE_REJECT */) {
       console.log("[LoopSDK] Entering HANDSHAKE_REJECT flow");
-      localStorage.removeItem("loop_connect");
       this.connection?.ws?.close();
       this.onReject?.();
       this.hideQrCode();
+      this.session?.reset();
       console.log("[LoopSDK] HANDSHAKE_REJECT: closing popup (if exists)");
       this.popupWindow = null;
     } else if (this.provider) {
@@ -2746,7 +2872,7 @@ class LoopSDK {
     if (typeof window === "undefined") {
       return null;
     }
-    if (!this.ticketId) {
+    if (!this.session?.ticketId) {
       console.warn("[LoopSDK] Cannot open wallet UI for request: no active ticket.");
       return null;
     }
@@ -2791,9 +2917,6 @@ class LoopSDK {
     return window.open(url, "_blank", "noopener,noreferrer");
   }
   showQrCode(url) {
-    if (typeof window === "undefined" || typeof document === "undefined") {
-      return;
-    }
     import_qrcode.default.toDataURL(url, (err, dataUrl) => {
       if (err) {
         console.error("Failed to generate QR code", err);
@@ -2847,6 +2970,12 @@ class LoopSDK {
       this.overlay = null;
     }
   }
+  logout() {
+    this.session?.reset();
+    this.provider = null;
+    this.connection?.ws?.close();
+    this.hideQrCode();
+  }
   requireProvider() {
     if (!this.provider) {
       throw new Error("SDK not connected. Call connect() and wait for acceptance first.");
@@ -2855,9 +2984,7 @@ class LoopSDK {
   }
   createProviderHooks() {
     return {
-      onRequestStart: () => {
-        return this.openRequestUi();
-      },
+      onRequestStart: () => this.openRequestUi(),
       onRequestFinish: ({ requestContext }) => {
         const win = requestContext;
         if (win) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fivenorth/loop-sdk",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "author": "hello@fivenorth.io",
   "main": "dist/index.js",
   "module": "dist/index.js",