unwallet-client-sdk 0.14.0 → 0.16.0

package/README.md

@@ -1,22 +1,8 @@
 # unWallet client-side SDK
 
-:warning: This SDK works correctly only on web browsers.
-
-## Installation
-
-```
-npm install unwallet-client-sdk
-```
+[![npm version](https://badgen.net/npm/v/unwallet-client-sdk)](https://npm.im/unwallet-client-sdk)
 
-## Initialization
-
-```js
-import { UnWallet } from "unwallet-client-sdk";
-
-const unWallet = await UnWallet.init({
-  clientID: "CLIENT_ID_OF_YOUR_APPLICATION",
-});
-```
+:warning: This SDK works correctly only on web browsers.
 
 ## Usage
 

package/dist/index.d.mts

@@ -0,0 +1,84 @@
+declare const VALID_ENVS: readonly ["prod", "dev"];
+type Env = (typeof VALID_ENVS)[number];
+interface Config {
+    env?: Env;
+    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;
+}
+interface SendTransactionResult {
+    transactionID: string;
+}
+declare class UnWallet {
+    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?: AuthorizationResponseMode;
+        redirectURL: string;
+        nonce?: string;
+        isVirtual?: boolean;
+        chainID?: number;
+    }): void;
+    sign(args: {
+        message: string;
+        ticketToken: string;
+    }): Promise<SignResult>;
+    sendTransaction(args: {
+        chainID: number;
+        toAddress: string;
+        value?: string;
+        data?: string;
+        ticketToken: string;
+    }): Promise<SendTransactionResult>;
+}
+
+export { type AuthorizationResponseMode, type Config, type Env, type SendTransactionResult, type SignResult, UWError, type UWErrorCode, UnWallet };

package/dist/index.d.ts

@@ -1,3 +1,84 @@
-export { Config, SignResult, SendTransactionResult } from "./types";
-export { UnWallet } from "./unwallet";
-//# sourceMappingURL=index.d.ts.map
+declare const VALID_ENVS: readonly ["prod", "dev"];
+type Env = (typeof VALID_ENVS)[number];
+interface Config {
+    env?: Env;
+    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;
+}
+interface SendTransactionResult {
+    transactionID: string;
+}
+declare class UnWallet {
+    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?: AuthorizationResponseMode;
+        redirectURL: string;
+        nonce?: string;
+        isVirtual?: boolean;
+        chainID?: number;
+    }): void;
+    sign(args: {
+        message: string;
+        ticketToken: string;
+    }): Promise<SignResult>;
+    sendTransaction(args: {
+        chainID: number;
+        toAddress: string;
+        value?: string;
+        data?: string;
+        ticketToken: string;
+    }): Promise<SendTransactionResult>;
+}
+
+export { type AuthorizationResponseMode, type Config, type Env, type SendTransactionResult, type SignResult, UWError, type UWErrorCode, UnWallet };

package/dist/index.js

@@ -1,5 +1,371 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnWallet = void 0;
-var unwallet_1 = require("./unwallet");
-Object.defineProperty(exports, "UnWallet", { enumerable: true, get: function () { return unwallet_1.UnWallet; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+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");
+
+// src/config.ts
+var UNWALLET_CONFIG_PROD = {
+  frontend: {
+    baseURL: "https://id.unwallet.world"
+  },
+  xapi: {
+    url: "wss://xapi.id.unwallet.world",
+    connectionTimeout: 1e4
+  }
+};
+var UNWALLET_CONFIG_DEV = {
+  frontend: {
+    baseURL: "http://localhost:4200"
+  },
+  xapi: {
+    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/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();
+  }
+  initListeners() {
+    this.socket.onopen = null;
+    this.socket.onmessage = (event) => {
+      if (this.responseHandler === null) {
+        return;
+      }
+      let resp;
+      {
+        const result = safeParseMessageEventDataToXResponse(event.data);
+        if (!result.success) {
+          this.responseHandler.reject(result.error);
+          return;
+        }
+        resp = result.data;
+      }
+      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;
+          }
+          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;
+      }
+      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) {
+    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 !== 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) {
+        url.searchParams.set("nonce", args.nonce);
+      }
+      if (args.chainID !== void 0) {
+        url.searchParams.set("chain_id", args.chainID.toString());
+      }
+    }
+    location.assign(url);
+  }
+  sign(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;
+      }
+      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.xConnection.id);
+        url.searchParams.set("clientID", this.clientID);
+        url.searchParams.set("message", args.message);
+        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) {
+        reject(
+          new UWError("INVALID_REQUEST", "either value or data is required")
+        );
+        return;
+      }
+      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.xConnection.id);
+        url.searchParams.set("clientID", this.clientID);
+        url.searchParams.set("chainID", args.chainID.toString());
+        url.searchParams.set("toAddress", args.toAddress);
+        url.searchParams.set(
+          "value",
+          args.value !== void 0 ? args.value : "0x0"
+        );
+        url.searchParams.set(
+          "data",
+          args.data !== void 0 ? args.data : "0x"
+        );
+        url.searchParams.set("ticketToken", args.ticketToken);
+      }
+      openWindow(url);
+    });
+  }
+};
+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
+});