unwallet-client-sdk 0.15.0 → 0.16.0

package/dist/index.d.mts

@@ -1,20 +1,48 @@
 declare const VALID_ENVS: readonly ["prod", "dev"];
-
 type Env = (typeof VALID_ENVS)[number];
 interface Config {
-    clientID: string;
     env?: Env;
-}
-interface UnWalletConfig {
-    frontend: UnWalletFrontendConfig;
-    xapi: UnWalletXAPIConfig;
-}
-interface UnWalletFrontendConfig {
-    baseURL: string;
+    clientID: string;
 }
 interface UnWalletXAPIConfig {
     url: string;
+    connectionTimeout: number;
+}
+
+declare const VALID_UW_ERROR_CODES: readonly ["CONNECTION_TIMEOUT", "CONNECTION_FAILED", "CONNECTION_NOT_OPENED", "CONNECTION_CLOSED", "INVALID_REQUEST", "REQUEST_IN_PROGRESS", "REQUEST_REJECTED", "INVALID_RESPONSE"];
+type UWErrorCode = (typeof VALID_UW_ERROR_CODES)[number];
+declare class UWError extends Error {
+    readonly code: UWErrorCode;
+    constructor(code: UWErrorCode, message?: string);
 }
+
+declare const VALID_X_RESPONSE_TYPES: readonly ["connectionID", "signature", "transactionID", "error"];
+type XResponseType = (typeof VALID_X_RESPONSE_TYPES)[number];
+interface XResponse {
+    readonly type: XResponseType;
+    readonly value: string;
+}
+interface XResponseHandler {
+    resolve: (resp: XResponse) => void;
+    reject: (err: UWError) => void;
+}
+declare class XConnection {
+    private socket;
+    private responseHandler;
+    readonly id: string;
+    constructor(args: {
+        socket: WebSocket;
+        id: string;
+    });
+    private initListeners;
+    get readyState(): number;
+    get hasResponseHandler(): boolean;
+    setResponseHandler(handler: XResponseHandler | null): void;
+    static init(config: UnWalletXAPIConfig): Promise<XConnection>;
+}
+
+declare const VALID_AUTHORIZATION_RESPONSE_MODES: readonly ["fragment", "form_post"];
+type AuthorizationResponseMode = (typeof VALID_AUTHORIZATION_RESPONSE_MODES)[number];
 interface SignResult {
     digest: string;
     signature: string;
@@ -22,19 +50,19 @@ interface SignResult {
 interface SendTransactionResult {
     transactionID: string;
 }
-
 declare class UnWallet {
-    private config;
-    private unWalletConfig;
-    private ws;
-    private connectionID;
-    private resolve;
-    private reject;
-    constructor(config: Config, unWalletConfig: UnWalletConfig, ws: WebSocket);
-    private initPromiseArgs;
+    private env;
+    private clientID;
+    private xConnection;
+    constructor(args: {
+        env: Env;
+        clientID: string;
+        xConnection: XConnection;
+    });
     static init(config: Config): Promise<UnWallet>;
+    private get unWalletConfig();
     authorize(args: {
-        responseMode?: string;
+        responseMode?: AuthorizationResponseMode;
         redirectURL: string;
         nonce?: string;
         isVirtual?: boolean;
@@ -51,10 +79,6 @@ declare class UnWallet {
         data?: string;
         ticketToken: string;
     }): Promise<SendTransactionResult>;
-    private getConnectionID;
-    private sendWSMessage;
-    private handleWSMessage;
-    private openWindow;
 }
 
-export { type Config, type SendTransactionResult, type SignResult, UnWallet };
+export { type AuthorizationResponseMode, type Config, type Env, type SendTransactionResult, type SignResult, UWError, type UWErrorCode, UnWallet };

package/dist/index.d.ts

@@ -1,20 +1,48 @@
 declare const VALID_ENVS: readonly ["prod", "dev"];
-
 type Env = (typeof VALID_ENVS)[number];
 interface Config {
-    clientID: string;
     env?: Env;
-}
-interface UnWalletConfig {
-    frontend: UnWalletFrontendConfig;
-    xapi: UnWalletXAPIConfig;
-}
-interface UnWalletFrontendConfig {
-    baseURL: string;
+    clientID: string;
 }
 interface UnWalletXAPIConfig {
     url: string;
+    connectionTimeout: number;
+}
+
+declare const VALID_UW_ERROR_CODES: readonly ["CONNECTION_TIMEOUT", "CONNECTION_FAILED", "CONNECTION_NOT_OPENED", "CONNECTION_CLOSED", "INVALID_REQUEST", "REQUEST_IN_PROGRESS", "REQUEST_REJECTED", "INVALID_RESPONSE"];
+type UWErrorCode = (typeof VALID_UW_ERROR_CODES)[number];
+declare class UWError extends Error {
+    readonly code: UWErrorCode;
+    constructor(code: UWErrorCode, message?: string);
 }
+
+declare const VALID_X_RESPONSE_TYPES: readonly ["connectionID", "signature", "transactionID", "error"];
+type XResponseType = (typeof VALID_X_RESPONSE_TYPES)[number];
+interface XResponse {
+    readonly type: XResponseType;
+    readonly value: string;
+}
+interface XResponseHandler {
+    resolve: (resp: XResponse) => void;
+    reject: (err: UWError) => void;
+}
+declare class XConnection {
+    private socket;
+    private responseHandler;
+    readonly id: string;
+    constructor(args: {
+        socket: WebSocket;
+        id: string;
+    });
+    private initListeners;
+    get readyState(): number;
+    get hasResponseHandler(): boolean;
+    setResponseHandler(handler: XResponseHandler | null): void;
+    static init(config: UnWalletXAPIConfig): Promise<XConnection>;
+}
+
+declare const VALID_AUTHORIZATION_RESPONSE_MODES: readonly ["fragment", "form_post"];
+type AuthorizationResponseMode = (typeof VALID_AUTHORIZATION_RESPONSE_MODES)[number];
 interface SignResult {
     digest: string;
     signature: string;
@@ -22,19 +50,19 @@ interface SignResult {
 interface SendTransactionResult {
     transactionID: string;
 }
-
 declare class UnWallet {
-    private config;
-    private unWalletConfig;
-    private ws;
-    private connectionID;
-    private resolve;
-    private reject;
-    constructor(config: Config, unWalletConfig: UnWalletConfig, ws: WebSocket);
-    private initPromiseArgs;
+    private env;
+    private clientID;
+    private xConnection;
+    constructor(args: {
+        env: Env;
+        clientID: string;
+        xConnection: XConnection;
+    });
     static init(config: Config): Promise<UnWallet>;
+    private get unWalletConfig();
     authorize(args: {
-        responseMode?: string;
+        responseMode?: AuthorizationResponseMode;
         redirectURL: string;
         nonce?: string;
         isVirtual?: boolean;
@@ -51,10 +79,6 @@ declare class UnWallet {
         data?: string;
         ticketToken: string;
     }): Promise<SendTransactionResult>;
-    private getConnectionID;
-    private sendWSMessage;
-    private handleWSMessage;
-    private openWindow;
 }
 
-export { type Config, type SendTransactionResult, type SignResult, UnWallet };
+export { type AuthorizationResponseMode, type Config, type Env, type SendTransactionResult, type SignResult, UWError, type UWErrorCode, UnWallet };

package/dist/index.js

@@ -20,20 +20,32 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  UWError: () => UWError,
   UnWallet: () => UnWallet
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/error.ts
+var _UWError = class _UWError extends Error {
+  constructor(code, message) {
+    super(message !== void 0 ? `${code}: ${message}` : code);
+    this.code = code;
+  }
+};
+_UWError.prototype.name = "UWError";
+var UWError = _UWError;
+
 // src/unwallet.ts
 var import_ethers = require("ethers");
 
-// src/consts.ts
+// src/config.ts
 var UNWALLET_CONFIG_PROD = {
   frontend: {
     baseURL: "https://id.unwallet.world"
   },
   xapi: {
-    url: "wss://xapi.id.unwallet.world"
+    url: "wss://xapi.id.unwallet.world",
+    connectionTimeout: 1e4
   }
 };
 var UNWALLET_CONFIG_DEV = {
@@ -41,75 +53,196 @@ var UNWALLET_CONFIG_DEV = {
     baseURL: "http://localhost:4200"
   },
   xapi: {
-    url: "wss://xapi.id.test.unwallet.dev"
+    url: "wss://xapi.id.test.unwallet.dev",
+    connectionTimeout: 1e4
   }
 };
+function getUnWalletConfigByEnv(env) {
+  switch (env) {
+    case "prod":
+      return UNWALLET_CONFIG_PROD;
+    case "dev":
+      return UNWALLET_CONFIG_DEV;
+  }
+}
 
-// src/unwallet.ts
-var UnWallet = class _UnWallet {
-  constructor(config, unWalletConfig, ws) {
-    this.resolve = null;
-    this.reject = null;
-    this.config = config;
-    this.unWalletConfig = unWalletConfig;
-    this.ws = ws;
-    this.connectionID = "";
-    this.initPromiseArgs();
-  }
-  initPromiseArgs() {
-    this.resolve = () => {
-    };
-    this.reject = () => {
-    };
+// src/x.ts
+var import_zod = require("zod");
+var VALID_X_RESPONSE_TYPES = [
+  "connectionID",
+  "signature",
+  "transactionID",
+  "error"
+];
+var XConnection = class _XConnection {
+  constructor(args) {
+    this.responseHandler = null;
+    this.socket = args.socket;
+    this.id = args.id;
+    this.initListeners();
   }
-  static init(config) {
-    return new Promise((resolve, reject) => {
-      if (config.env === void 0) {
-        config.env = "prod";
+  initListeners() {
+    this.socket.onopen = null;
+    this.socket.onmessage = (event) => {
+      if (this.responseHandler === null) {
+        return;
       }
-      let unWalletConfig;
+      let resp;
       {
-        switch (config.env) {
-          case "prod":
-            unWalletConfig = UNWALLET_CONFIG_PROD;
-            break;
-          case "dev":
-            unWalletConfig = UNWALLET_CONFIG_DEV;
-            break;
+        const result = safeParseMessageEventDataToXResponse(event.data);
+        if (!result.success) {
+          this.responseHandler.reject(result.error);
+          return;
         }
+        resp = result.data;
       }
-      const ws = new WebSocket(unWalletConfig.xapi.url);
-      {
-        ws.onerror = () => {
-          reject("websocket connection failed");
-        };
-        ws.onopen = () => {
-          unWallet.getConnectionID();
-        };
-        ws.onmessage = (event) => {
-          const msg = JSON.parse(event.data);
-          if (msg.type === "connectionID") {
-            unWallet.connectionID = msg.value;
-            resolve(unWallet);
+      switch (resp.type) {
+        case "error":
+          switch (resp.value) {
+            case "rejected":
+              this.responseHandler.reject(new UWError("REQUEST_REJECTED"));
+              break;
+            default:
+              this.responseHandler.reject(
+                new UWError(
+                  "INVALID_RESPONSE",
+                  `unexpected error response value: ${resp.value}`
+                )
+              );
+          }
+          break;
+        default:
+          this.responseHandler.resolve(resp);
+      }
+    };
+    this.socket.onerror = null;
+    this.socket.onclose = (event) => {
+      if (this.responseHandler === null) {
+        return;
+      }
+      this.responseHandler.reject(
+        new UWError("CONNECTION_CLOSED", event.reason)
+      );
+    };
+  }
+  get readyState() {
+    return this.socket.readyState;
+  }
+  get hasResponseHandler() {
+    return this.responseHandler !== null;
+  }
+  setResponseHandler(handler) {
+    this.responseHandler = handler;
+  }
+  static async init(config) {
+    const socket = new WebSocket(config.url);
+    const id = await new Promise((resolve, reject) => {
+      setInterval(
+        () => reject(new UWError("CONNECTION_TIMEOUT")),
+        config.connectionTimeout
+      );
+      socket.onopen = () => socket.send(JSON.stringify({ action: "getConnectionID" }));
+      socket.onmessage = (event) => {
+        let resp;
+        {
+          const result = safeParseMessageEventDataToXResponse(event.data);
+          if (!result.success) {
+            reject(result.error);
             return;
           }
-          unWallet.handleWSMessage(msg);
-        };
+          resp = result.data;
+        }
+        if (resp.type !== "connectionID") {
+          reject(
+            new UWError(
+              "INVALID_RESPONSE",
+              `unexpected response type: ${resp.type}`
+            )
+          );
+          return;
+        }
+        resolve(resp.value);
+      };
+      socket.onerror = () => reject(new UWError("CONNECTION_FAILED"));
+      socket.onclose = (event) => reject(new UWError("CONNECTION_CLOSED", event.reason));
+    });
+    return new _XConnection({ socket, id });
+  }
+};
+function safeParseMessageEventDataToXResponse(data) {
+  let s;
+  {
+    const result = import_zod.z.string().refine((val) => {
+      try {
+        JSON.parse(val);
+      } catch (e) {
+        return false;
       }
-      const unWallet = new _UnWallet(config, unWalletConfig, ws);
+      return true;
+    }).safeParse(data);
+    if (!result.success) {
+      return {
+        success: false,
+        error: new UWError(
+          "INVALID_RESPONSE",
+          "message event data must be a json string"
+        )
+      };
+    }
+    s = result.data;
+  }
+  let parsed;
+  {
+    const result = import_zod.z.object({
+      type: import_zod.z.enum(VALID_X_RESPONSE_TYPES),
+      value: import_zod.z.string()
+    }).safeParse(JSON.parse(s));
+    if (!result.success) {
+      return {
+        success: false,
+        error: new UWError(
+          "INVALID_RESPONSE",
+          `invalid message event data: ${result.error.message}`
+        )
+      };
+    }
+    parsed = result.data;
+  }
+  return {
+    success: true,
+    data: parsed
+  };
+}
+
+// src/unwallet.ts
+var UnWallet = class _UnWallet {
+  constructor(args) {
+    this.env = args.env;
+    this.clientID = args.clientID;
+    this.xConnection = args.xConnection;
+  }
+  static async init(config) {
+    const env = config.env !== void 0 ? config.env : "prod";
+    return new _UnWallet({
+      env,
+      clientID: config.clientID,
+      xConnection: await XConnection.init(getUnWalletConfigByEnv(env).xapi)
     });
   }
+  get unWalletConfig() {
+    return getUnWalletConfigByEnv(this.env);
+  }
   authorize(args) {
-    if (!args.responseMode) {
-      args.responseMode = "fragment";
-    }
-    let url = new URL(
-      `${this.unWalletConfig.frontend.baseURL}/${args.isVirtual === false ? "" : "v"}authorize`
+    const url = new URL(
+      `${this.unWalletConfig.frontend.baseURL}/${args.isVirtual !== void 0 ? args.isVirtual ? "v" : "" : "v"}authorize`
     );
     {
       url.searchParams.set("response_type", "id_token");
-      url.searchParams.set("response_mode", args.responseMode);
-      url.searchParams.set("client_id", this.config.clientID);
+      url.searchParams.set(
+        "response_mode",
+        args.responseMode !== void 0 ? args.responseMode : "fragment"
+      );
+      url.searchParams.set("client_id", this.clientID);
       url.searchParams.set("scope", "openid");
       url.searchParams.set("redirect_uri", args.redirectURL);
       if (args.nonce !== void 0) {
@@ -119,42 +252,91 @@ var UnWallet = class _UnWallet {
         url.searchParams.set("chain_id", args.chainID.toString());
       }
     }
-    location.assign(url.toString());
+    location.assign(url);
   }
   sign(args) {
     return new Promise((resolve, reject) => {
-      this.resolve = (sig) => {
-        resolve({
-          digest: import_ethers.ethers.sha256(import_ethers.ethers.toUtf8Bytes(args.message)),
-          signature: sig
-        });
-      };
-      this.reject = reject;
+      if (this.xConnection.readyState !== WebSocket.OPEN) {
+        reject(new UWError("CONNECTION_NOT_OPENED"));
+        return;
+      }
+      if (this.xConnection.hasResponseHandler) {
+        reject(new UWError("REQUEST_IN_PROGRESS"));
+        return;
+      }
+      this.xConnection.setResponseHandler({
+        resolve: (resp) => {
+          this.xConnection.setResponseHandler(null);
+          if (resp.type !== "signature") {
+            reject(
+              new UWError(
+                "INVALID_RESPONSE",
+                `unexpected response type: ${resp.type}`
+              )
+            );
+            return;
+          }
+          resolve({
+            digest: import_ethers.ethers.sha256(import_ethers.ethers.toUtf8Bytes(args.message)),
+            signature: resp.value
+          });
+        },
+        reject: (err) => {
+          this.xConnection.setResponseHandler(null);
+          reject(err);
+        }
+      });
       const url = new URL(`${this.unWalletConfig.frontend.baseURL}/x/sign`);
       {
-        url.searchParams.set("connectionID", this.connectionID);
-        url.searchParams.set("clientID", this.config.clientID);
+        url.searchParams.set("connectionID", this.xConnection.id);
+        url.searchParams.set("clientID", this.clientID);
         url.searchParams.set("message", args.message);
         url.searchParams.set("ticketToken", args.ticketToken);
       }
-      this.openWindow(url);
+      openWindow(url);
     });
   }
   sendTransaction(args) {
     return new Promise((resolve, reject) => {
+      if (this.xConnection.readyState !== WebSocket.OPEN) {
+        reject(new UWError("CONNECTION_NOT_OPENED"));
+        return;
+      }
+      if (this.xConnection.hasResponseHandler) {
+        reject(new UWError("REQUEST_IN_PROGRESS"));
+        return;
+      }
       if (args.value === void 0 && args.data === void 0) {
-        throw new Error("either value or data required");
+        reject(
+          new UWError("INVALID_REQUEST", "either value or data is required")
+        );
+        return;
       }
-      this.resolve = (txID) => {
-        resolve({ transactionID: txID });
-      };
-      this.reject = reject;
+      this.xConnection.setResponseHandler({
+        resolve: (resp) => {
+          this.xConnection.setResponseHandler(null);
+          if (resp.type !== "transactionID") {
+            reject(
+              new UWError(
+                "INVALID_RESPONSE",
+                `unexpected response type: ${resp.type}`
+              )
+            );
+            return;
+          }
+          resolve({ transactionID: resp.value });
+        },
+        reject: (err) => {
+          this.xConnection.setResponseHandler(null);
+          reject(err);
+        }
+      });
       const url = new URL(
         `${this.unWalletConfig.frontend.baseURL}/x/sendTransaction`
       );
       {
-        url.searchParams.set("connectionID", this.connectionID);
-        url.searchParams.set("clientID", this.config.clientID);
+        url.searchParams.set("connectionID", this.xConnection.id);
+        url.searchParams.set("clientID", this.clientID);
         url.searchParams.set("chainID", args.chainID.toString());
         url.searchParams.set("toAddress", args.toAddress);
         url.searchParams.set(
@@ -167,52 +349,23 @@ var UnWallet = class _UnWallet {
         );
         url.searchParams.set("ticketToken", args.ticketToken);
       }
-      this.openWindow(url);
-    });
-  }
-  getConnectionID() {
-    this.sendWSMessage({
-      action: "getConnectionID"
+      openWindow(url);
     });
   }
-  sendWSMessage(msg) {
-    this.ws.send(JSON.stringify(msg));
-  }
-  handleWSMessage(msg) {
-    switch (msg.type) {
-      case "signature":
-        this.resolve(msg.value);
-        break;
-      case "transactionID":
-        this.resolve(msg.value);
-        break;
-      case "error":
-        switch (msg.value) {
-          case "rejected":
-            this.reject("canceled");
-            break;
-          default:
-            throw new Error(msg.value);
-        }
-        break;
-      default:
-        throw new Error(`unexpected message type: ${msg.type}`);
-    }
-    this.initPromiseArgs();
-  }
-  openWindow(url) {
-    const width = screen.width / 2;
-    const height = screen.height;
-    const left = screen.width / 4;
-    const top = 0;
-    window.open(
-      url.toString(),
-      "_blank",
-      `width=${width},height=${height},left=${left},top=${top}`
-    );
-  }
 };
+function openWindow(url) {
+  const width = screen.width / 2;
+  const height = screen.height;
+  const left = screen.width / 4;
+  const top = 0;
+  window.open(
+    url.toString(),
+    "_blank",
+    `width=${width},height=${height},left=${left},top=${top}`
+  );
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  UWError,
   UnWallet
 });

package/dist/index.mjs

@@ -1,13 +1,24 @@
+// src/error.ts
+var _UWError = class _UWError extends Error {
+  constructor(code, message) {
+    super(message !== void 0 ? `${code}: ${message}` : code);
+    this.code = code;
+  }
+};
+_UWError.prototype.name = "UWError";
+var UWError = _UWError;
+
 // src/unwallet.ts
 import { ethers } from "ethers";
 
-// src/consts.ts
+// src/config.ts
 var UNWALLET_CONFIG_PROD = {
   frontend: {
     baseURL: "https://id.unwallet.world"
   },
   xapi: {
-    url: "wss://xapi.id.unwallet.world"
+    url: "wss://xapi.id.unwallet.world",
+    connectionTimeout: 1e4
   }
 };
 var UNWALLET_CONFIG_DEV = {
@@ -15,75 +26,196 @@ var UNWALLET_CONFIG_DEV = {
     baseURL: "http://localhost:4200"
   },
   xapi: {
-    url: "wss://xapi.id.test.unwallet.dev"
+    url: "wss://xapi.id.test.unwallet.dev",
+    connectionTimeout: 1e4
   }
 };
+function getUnWalletConfigByEnv(env) {
+  switch (env) {
+    case "prod":
+      return UNWALLET_CONFIG_PROD;
+    case "dev":
+      return UNWALLET_CONFIG_DEV;
+  }
+}
 
-// src/unwallet.ts
-var UnWallet = class _UnWallet {
-  constructor(config, unWalletConfig, ws) {
-    this.resolve = null;
-    this.reject = null;
-    this.config = config;
-    this.unWalletConfig = unWalletConfig;
-    this.ws = ws;
-    this.connectionID = "";
-    this.initPromiseArgs();
-  }
-  initPromiseArgs() {
-    this.resolve = () => {
-    };
-    this.reject = () => {
-    };
+// src/x.ts
+import { z } from "zod";
+var VALID_X_RESPONSE_TYPES = [
+  "connectionID",
+  "signature",
+  "transactionID",
+  "error"
+];
+var XConnection = class _XConnection {
+  constructor(args) {
+    this.responseHandler = null;
+    this.socket = args.socket;
+    this.id = args.id;
+    this.initListeners();
   }
-  static init(config) {
-    return new Promise((resolve, reject) => {
-      if (config.env === void 0) {
-        config.env = "prod";
+  initListeners() {
+    this.socket.onopen = null;
+    this.socket.onmessage = (event) => {
+      if (this.responseHandler === null) {
+        return;
       }
-      let unWalletConfig;
+      let resp;
       {
-        switch (config.env) {
-          case "prod":
-            unWalletConfig = UNWALLET_CONFIG_PROD;
-            break;
-          case "dev":
-            unWalletConfig = UNWALLET_CONFIG_DEV;
-            break;
+        const result = safeParseMessageEventDataToXResponse(event.data);
+        if (!result.success) {
+          this.responseHandler.reject(result.error);
+          return;
         }
+        resp = result.data;
       }
-      const ws = new WebSocket(unWalletConfig.xapi.url);
-      {
-        ws.onerror = () => {
-          reject("websocket connection failed");
-        };
-        ws.onopen = () => {
-          unWallet.getConnectionID();
-        };
-        ws.onmessage = (event) => {
-          const msg = JSON.parse(event.data);
-          if (msg.type === "connectionID") {
-            unWallet.connectionID = msg.value;
-            resolve(unWallet);
+      switch (resp.type) {
+        case "error":
+          switch (resp.value) {
+            case "rejected":
+              this.responseHandler.reject(new UWError("REQUEST_REJECTED"));
+              break;
+            default:
+              this.responseHandler.reject(
+                new UWError(
+                  "INVALID_RESPONSE",
+                  `unexpected error response value: ${resp.value}`
+                )
+              );
+          }
+          break;
+        default:
+          this.responseHandler.resolve(resp);
+      }
+    };
+    this.socket.onerror = null;
+    this.socket.onclose = (event) => {
+      if (this.responseHandler === null) {
+        return;
+      }
+      this.responseHandler.reject(
+        new UWError("CONNECTION_CLOSED", event.reason)
+      );
+    };
+  }
+  get readyState() {
+    return this.socket.readyState;
+  }
+  get hasResponseHandler() {
+    return this.responseHandler !== null;
+  }
+  setResponseHandler(handler) {
+    this.responseHandler = handler;
+  }
+  static async init(config) {
+    const socket = new WebSocket(config.url);
+    const id = await new Promise((resolve, reject) => {
+      setInterval(
+        () => reject(new UWError("CONNECTION_TIMEOUT")),
+        config.connectionTimeout
+      );
+      socket.onopen = () => socket.send(JSON.stringify({ action: "getConnectionID" }));
+      socket.onmessage = (event) => {
+        let resp;
+        {
+          const result = safeParseMessageEventDataToXResponse(event.data);
+          if (!result.success) {
+            reject(result.error);
             return;
           }
-          unWallet.handleWSMessage(msg);
-        };
+          resp = result.data;
+        }
+        if (resp.type !== "connectionID") {
+          reject(
+            new UWError(
+              "INVALID_RESPONSE",
+              `unexpected response type: ${resp.type}`
+            )
+          );
+          return;
+        }
+        resolve(resp.value);
+      };
+      socket.onerror = () => reject(new UWError("CONNECTION_FAILED"));
+      socket.onclose = (event) => reject(new UWError("CONNECTION_CLOSED", event.reason));
+    });
+    return new _XConnection({ socket, id });
+  }
+};
+function safeParseMessageEventDataToXResponse(data) {
+  let s;
+  {
+    const result = z.string().refine((val) => {
+      try {
+        JSON.parse(val);
+      } catch (e) {
+        return false;
       }
-      const unWallet = new _UnWallet(config, unWalletConfig, ws);
+      return true;
+    }).safeParse(data);
+    if (!result.success) {
+      return {
+        success: false,
+        error: new UWError(
+          "INVALID_RESPONSE",
+          "message event data must be a json string"
+        )
+      };
+    }
+    s = result.data;
+  }
+  let parsed;
+  {
+    const result = z.object({
+      type: z.enum(VALID_X_RESPONSE_TYPES),
+      value: z.string()
+    }).safeParse(JSON.parse(s));
+    if (!result.success) {
+      return {
+        success: false,
+        error: new UWError(
+          "INVALID_RESPONSE",
+          `invalid message event data: ${result.error.message}`
+        )
+      };
+    }
+    parsed = result.data;
+  }
+  return {
+    success: true,
+    data: parsed
+  };
+}
+
+// src/unwallet.ts
+var UnWallet = class _UnWallet {
+  constructor(args) {
+    this.env = args.env;
+    this.clientID = args.clientID;
+    this.xConnection = args.xConnection;
+  }
+  static async init(config) {
+    const env = config.env !== void 0 ? config.env : "prod";
+    return new _UnWallet({
+      env,
+      clientID: config.clientID,
+      xConnection: await XConnection.init(getUnWalletConfigByEnv(env).xapi)
     });
   }
+  get unWalletConfig() {
+    return getUnWalletConfigByEnv(this.env);
+  }
   authorize(args) {
-    if (!args.responseMode) {
-      args.responseMode = "fragment";
-    }
-    let url = new URL(
-      `${this.unWalletConfig.frontend.baseURL}/${args.isVirtual === false ? "" : "v"}authorize`
+    const url = new URL(
+      `${this.unWalletConfig.frontend.baseURL}/${args.isVirtual !== void 0 ? args.isVirtual ? "v" : "" : "v"}authorize`
     );
     {
       url.searchParams.set("response_type", "id_token");
-      url.searchParams.set("response_mode", args.responseMode);
-      url.searchParams.set("client_id", this.config.clientID);
+      url.searchParams.set(
+        "response_mode",
+        args.responseMode !== void 0 ? args.responseMode : "fragment"
+      );
+      url.searchParams.set("client_id", this.clientID);
       url.searchParams.set("scope", "openid");
       url.searchParams.set("redirect_uri", args.redirectURL);
       if (args.nonce !== void 0) {
@@ -93,42 +225,91 @@ var UnWallet = class _UnWallet {
         url.searchParams.set("chain_id", args.chainID.toString());
       }
     }
-    location.assign(url.toString());
+    location.assign(url);
   }
   sign(args) {
     return new Promise((resolve, reject) => {
-      this.resolve = (sig) => {
-        resolve({
-          digest: ethers.sha256(ethers.toUtf8Bytes(args.message)),
-          signature: sig
-        });
-      };
-      this.reject = reject;
+      if (this.xConnection.readyState !== WebSocket.OPEN) {
+        reject(new UWError("CONNECTION_NOT_OPENED"));
+        return;
+      }
+      if (this.xConnection.hasResponseHandler) {
+        reject(new UWError("REQUEST_IN_PROGRESS"));
+        return;
+      }
+      this.xConnection.setResponseHandler({
+        resolve: (resp) => {
+          this.xConnection.setResponseHandler(null);
+          if (resp.type !== "signature") {
+            reject(
+              new UWError(
+                "INVALID_RESPONSE",
+                `unexpected response type: ${resp.type}`
+              )
+            );
+            return;
+          }
+          resolve({
+            digest: ethers.sha256(ethers.toUtf8Bytes(args.message)),
+            signature: resp.value
+          });
+        },
+        reject: (err) => {
+          this.xConnection.setResponseHandler(null);
+          reject(err);
+        }
+      });
       const url = new URL(`${this.unWalletConfig.frontend.baseURL}/x/sign`);
       {
-        url.searchParams.set("connectionID", this.connectionID);
-        url.searchParams.set("clientID", this.config.clientID);
+        url.searchParams.set("connectionID", this.xConnection.id);
+        url.searchParams.set("clientID", this.clientID);
         url.searchParams.set("message", args.message);
         url.searchParams.set("ticketToken", args.ticketToken);
       }
-      this.openWindow(url);
+      openWindow(url);
     });
   }
   sendTransaction(args) {
     return new Promise((resolve, reject) => {
+      if (this.xConnection.readyState !== WebSocket.OPEN) {
+        reject(new UWError("CONNECTION_NOT_OPENED"));
+        return;
+      }
+      if (this.xConnection.hasResponseHandler) {
+        reject(new UWError("REQUEST_IN_PROGRESS"));
+        return;
+      }
       if (args.value === void 0 && args.data === void 0) {
-        throw new Error("either value or data required");
+        reject(
+          new UWError("INVALID_REQUEST", "either value or data is required")
+        );
+        return;
       }
-      this.resolve = (txID) => {
-        resolve({ transactionID: txID });
-      };
-      this.reject = reject;
+      this.xConnection.setResponseHandler({
+        resolve: (resp) => {
+          this.xConnection.setResponseHandler(null);
+          if (resp.type !== "transactionID") {
+            reject(
+              new UWError(
+                "INVALID_RESPONSE",
+                `unexpected response type: ${resp.type}`
+              )
+            );
+            return;
+          }
+          resolve({ transactionID: resp.value });
+        },
+        reject: (err) => {
+          this.xConnection.setResponseHandler(null);
+          reject(err);
+        }
+      });
       const url = new URL(
         `${this.unWalletConfig.frontend.baseURL}/x/sendTransaction`
       );
       {
-        url.searchParams.set("connectionID", this.connectionID);
-        url.searchParams.set("clientID", this.config.clientID);
+        url.searchParams.set("connectionID", this.xConnection.id);
+        url.searchParams.set("clientID", this.clientID);
         url.searchParams.set("chainID", args.chainID.toString());
         url.searchParams.set("toAddress", args.toAddress);
         url.searchParams.set(
@@ -141,51 +322,22 @@ var UnWallet = class _UnWallet {
         );
         url.searchParams.set("ticketToken", args.ticketToken);
       }
-      this.openWindow(url);
-    });
-  }
-  getConnectionID() {
-    this.sendWSMessage({
-      action: "getConnectionID"
+      openWindow(url);
     });
   }
-  sendWSMessage(msg) {
-    this.ws.send(JSON.stringify(msg));
-  }
-  handleWSMessage(msg) {
-    switch (msg.type) {
-      case "signature":
-        this.resolve(msg.value);
-        break;
-      case "transactionID":
-        this.resolve(msg.value);
-        break;
-      case "error":
-        switch (msg.value) {
-          case "rejected":
-            this.reject("canceled");
-            break;
-          default:
-            throw new Error(msg.value);
-        }
-        break;
-      default:
-        throw new Error(`unexpected message type: ${msg.type}`);
-    }
-    this.initPromiseArgs();
-  }
-  openWindow(url) {
-    const width = screen.width / 2;
-    const height = screen.height;
-    const left = screen.width / 4;
-    const top = 0;
-    window.open(
-      url.toString(),
-      "_blank",
-      `width=${width},height=${height},left=${left},top=${top}`
-    );
-  }
 };
+function openWindow(url) {
+  const width = screen.width / 2;
+  const height = screen.height;
+  const left = screen.width / 4;
+  const top = 0;
+  window.open(
+    url.toString(),
+    "_blank",
+    `width=${width},height=${height},left=${left},top=${top}`
+  );
+}
 export {
+  UWError,
   UnWallet
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unwallet-client-sdk",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "unWallet client-side SDK",
   "license": "MIT",
   "author": "SIVIRA",
@@ -29,7 +29,8 @@
     }
   },
   "dependencies": {
-    "ethers": "6.14.0"
+    "ethers": "6.14.0",
+    "zod": "3.24.4"
   },
   "devDependencies": {
     "@commitlint/cli": "19.8.1",