unwallet-client-sdk 0.15.0 → 0.17.0

package/dist/index.d.mts

@@ -1,20 +1,66 @@
 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;
 }
+
+interface EIP712TypedData {
+    types: Record<string, Array<EIP712TypedDataField>>;
+    primaryType: string;
+    domain: EIP712TypedDataDomain;
+    message: Record<string, any>;
+}
+interface EIP712TypedDataDomain {
+    name?: string;
+    version?: string;
+    chainId?: number;
+    verifyingContract?: string;
+    salt?: string;
+}
+interface EIP712TypedDataField {
+    name: string;
+    type: string;
+}
+
+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 +68,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;
@@ -44,6 +90,10 @@ declare class UnWallet {
         message: string;
         ticketToken: string;
     }): Promise<SignResult>;
+    signEIP712TypedData(args: {
+        typedData: EIP712TypedData;
+        ticketToken: string;
+    }): Promise<SignResult>;
     sendTransaction(args: {
         chainID: number;
         toAddress: string;
@@ -51,10 +101,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 EIP712TypedData, type EIP712TypedDataDomain, type EIP712TypedDataField, type Env, type SendTransactionResult, type SignResult, UWError, type UWErrorCode, UnWallet };

package/dist/index.d.ts

@@ -1,20 +1,66 @@
 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;
 }
+
+interface EIP712TypedData {
+    types: Record<string, Array<EIP712TypedDataField>>;
+    primaryType: string;
+    domain: EIP712TypedDataDomain;
+    message: Record<string, any>;
+}
+interface EIP712TypedDataDomain {
+    name?: string;
+    version?: string;
+    chainId?: number;
+    verifyingContract?: string;
+    salt?: string;
+}
+interface EIP712TypedDataField {
+    name: string;
+    type: string;
+}
+
+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 +68,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;
@@ -44,6 +90,10 @@ declare class UnWallet {
         message: string;
         ticketToken: string;
     }): Promise<SignResult>;
+    signEIP712TypedData(args: {
+        typedData: EIP712TypedData;
+        ticketToken: string;
+    }): Promise<SignResult>;
     sendTransaction(args: {
         chainID: number;
         toAddress: string;
@@ -51,10 +101,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 EIP712TypedData, type EIP712TypedDataDomain, type EIP712TypedDataField, type Env, type SendTransactionResult, type SignResult, UWError, type UWErrorCode, UnWallet };

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,25 +17,46 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // 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");
+var import_omit = __toESM(require("lodash/omit"));
 
-// 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 +64,186 @@ 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_v4 = require("zod/v4");
+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) {
+  const result = import_v4.z.string().refine(
+    (val) => {
+      try {
+        JSON.parse(val);
+      } catch (e) {
+        return false;
       }
-      const unWallet = new _UnWallet(config, unWalletConfig, ws);
+      return true;
+    },
+    {
+      abort: true,
+      message: "Invalid JSON string"
+    }
+  ).transform((val) => JSON.parse(val)).pipe(
+    import_v4.z.object({
+      type: import_v4.z.enum(VALID_X_RESPONSE_TYPES),
+      value: import_v4.z.string()
+    })
+  ).safeParse(data);
+  if (!result.success) {
+    return {
+      success: false,
+      error: new UWError(
+        "INVALID_RESPONSE",
+        `invalid message event data: ${result.error.message}`
+      )
+    };
+  }
+  return {
+    success: true,
+    data: result.data
+  };
+}
+
+// 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 +253,180 @@ 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;
+      }
+      const digest = import_ethers.ethers.sha256(import_ethers.ethers.toUtf8Bytes(args.message));
+      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,
+            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);
+    });
+  }
+  signEIP712TypedData(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;
+      }
+      const types = (0, import_omit.default)(args.typedData.types, "EIP712Domain");
+      let primaryType;
+      {
+        try {
+          primaryType = import_ethers.ethers.TypedDataEncoder.getPrimaryType(types);
+        } catch (e) {
+          if (import_ethers.ethers.isError(e, "INVALID_ARGUMENT")) {
+            reject(
+              new UWError("INVALID_REQUEST", `invalid typed data: ${e.message}`)
+            );
+            return;
+          }
+          reject(e);
+          return;
+        }
+      }
+      if (primaryType !== args.typedData.primaryType) {
+        reject(
+          new UWError(
+            "INVALID_REQUEST",
+            `invalid typed data: primary type must be ${primaryType}`
+          )
+        );
+        return;
+      }
+      let digest;
+      {
+        try {
+          digest = import_ethers.ethers.TypedDataEncoder.hash(
+            args.typedData.domain,
+            types,
+            args.typedData.message
+          );
+        } catch (e) {
+          if (import_ethers.ethers.isError(e, "INVALID_ARGUMENT")) {
+            reject(
+              new UWError("INVALID_REQUEST", `invalid typed data: ${e.message}`)
+            );
+            return;
+          }
+          reject(e);
+          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,
+            signature: resp.value
+          });
+        },
+        reject: (err) => {
+          this.xConnection.setResponseHandler(null);
+          reject(err);
+        }
+      });
+      const url = new URL(
+        `${this.unWalletConfig.frontend.baseURL}/x/signEIP712TypedData`
+      );
+      {
+        url.searchParams.set("connectionID", this.xConnection.id);
+        url.searchParams.set("clientID", this.clientID);
+        url.searchParams.set("typedData", JSON.stringify(args.typedData));
+        url.searchParams.set("ticketToken", args.ticketToken);
+      }
+      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 +439,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,25 @@
+// 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";
+import omit from "lodash/omit";
 
-// 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 +27,186 @@ 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/v4";
+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) {
+  const result = z.string().refine(
+    (val) => {
+      try {
+        JSON.parse(val);
+      } catch (e) {
+        return false;
       }
-      const unWallet = new _UnWallet(config, unWalletConfig, ws);
+      return true;
+    },
+    {
+      abort: true,
+      message: "Invalid JSON string"
+    }
+  ).transform((val) => JSON.parse(val)).pipe(
+    z.object({
+      type: z.enum(VALID_X_RESPONSE_TYPES),
+      value: z.string()
+    })
+  ).safeParse(data);
+  if (!result.success) {
+    return {
+      success: false,
+      error: new UWError(
+        "INVALID_RESPONSE",
+        `invalid message event data: ${result.error.message}`
+      )
+    };
+  }
+  return {
+    success: true,
+    data: result.data
+  };
+}
+
+// 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 +216,180 @@ 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;
+      }
+      const digest = ethers.sha256(ethers.toUtf8Bytes(args.message));
+      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,
+            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);
+    });
+  }
+  signEIP712TypedData(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;
+      }
+      const types = omit(args.typedData.types, "EIP712Domain");
+      let primaryType;
+      {
+        try {
+          primaryType = ethers.TypedDataEncoder.getPrimaryType(types);
+        } catch (e) {
+          if (ethers.isError(e, "INVALID_ARGUMENT")) {
+            reject(
+              new UWError("INVALID_REQUEST", `invalid typed data: ${e.message}`)
+            );
+            return;
+          }
+          reject(e);
+          return;
+        }
+      }
+      if (primaryType !== args.typedData.primaryType) {
+        reject(
+          new UWError(
+            "INVALID_REQUEST",
+            `invalid typed data: primary type must be ${primaryType}`
+          )
+        );
+        return;
+      }
+      let digest;
+      {
+        try {
+          digest = ethers.TypedDataEncoder.hash(
+            args.typedData.domain,
+            types,
+            args.typedData.message
+          );
+        } catch (e) {
+          if (ethers.isError(e, "INVALID_ARGUMENT")) {
+            reject(
+              new UWError("INVALID_REQUEST", `invalid typed data: ${e.message}`)
+            );
+            return;
+          }
+          reject(e);
+          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,
+            signature: resp.value
+          });
+        },
+        reject: (err) => {
+          this.xConnection.setResponseHandler(null);
+          reject(err);
+        }
+      });
+      const url = new URL(
+        `${this.unWalletConfig.frontend.baseURL}/x/signEIP712TypedData`
+      );
+      {
+        url.searchParams.set("connectionID", this.xConnection.id);
+        url.searchParams.set("clientID", this.clientID);
+        url.searchParams.set("typedData", JSON.stringify(args.typedData));
+        url.searchParams.set("ticketToken", args.ticketToken);
+      }
+      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 +402,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.17.0",
   "description": "unWallet client-side SDK",
   "license": "MIT",
   "author": "SIVIRA",
@@ -29,17 +29,20 @@
     }
   },
   "dependencies": {
-    "ethers": "6.14.0"
+    "ethers": "6.14.1",
+    "lodash": "4.17.21",
+    "zod": "3.25.13"
   },
   "devDependencies": {
     "@commitlint/cli": "19.8.1",
     "@commitlint/config-conventional": "19.8.1",
     "@commitlint/types": "19.8.1",
     "@tsconfig/strictest": "2.0.5",
+    "@types/lodash": "4.17.17",
     "commitizen": "4.3.1",
     "cz-conventional-changelog": "3.3.0",
     "husky": "9.1.7",
-    "tsup": "8.4.0"
+    "tsup": "8.5.0"
   },
   "scripts": {
     "build": "tsup",