@getpara/web-sdk 2.0.0-dev.1 → 2.0.0-dev.2

package/dist/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "sideEffects": [
+    "wasm_exec.js"
+  ]
+}

package/dist/utils/emailUtils.js

@@ -0,0 +1,10 @@
+"use client";
+import "../chunk-WLGKV3EF.js";
+function getMailtoLink(email, recoveryShare) {
+  const emailBody = `Hello,%0D%0DBelow is your Para Recovery Secret. Keep this safe!%0D%0D${recoveryShare}%0D%0DPlease get in touch via support@getpara.com if you have any questions`;
+  const mailText = `mailto:${email}?subject=Para%20Recovery%20Secret&body=${emailBody}`;
+  return mailText;
+}
+export {
+  getMailtoLink
+};

package/dist/utils/formattingUtils.js

@@ -0,0 +1,37 @@
+"use client";
+import "../chunk-WLGKV3EF.js";
+function hexStringToBase64(hexString) {
+  if (hexString.substring(0, 2) === "0x") {
+    hexString = hexString.substring(2);
+  }
+  return Buffer.from(hexString, "hex").toString("base64");
+}
+function hexToSignature(hexSig) {
+  return {
+    r: `0x${hexSig.slice(2, 66)}`,
+    s: `0x${hexSig.slice(66, 130)}`,
+    v: BigInt(hexSig.slice(130, 132))
+  };
+}
+function hexToUint8Array(hex) {
+  if (hex.startsWith("0x")) {
+    hex = hex.slice(2);
+  }
+  return new Uint8Array(Buffer.from(hex, "hex"));
+}
+function hexToDecimal(hex) {
+  if (hex.startsWith("0x")) {
+    hex = hex.slice(2);
+  }
+  return `${parseInt(hex, 16)}`;
+}
+function decimalToHex(decimal) {
+  return `0x${parseInt(decimal).toString(16)}`;
+}
+export {
+  decimalToHex,
+  hexStringToBase64,
+  hexToDecimal,
+  hexToSignature,
+  hexToUint8Array
+};

package/dist/utils/isMobile.js

@@ -0,0 +1,47 @@
+"use client";
+import "../chunk-WLGKV3EF.js";
+function isAndroid() {
+  return typeof navigator !== "undefined" && /android/i.test(navigator.userAgent);
+}
+function isSmallIOS() {
+  return typeof navigator !== "undefined" && /iPhone|iPod/.test(navigator.userAgent);
+}
+function isLargeIOS() {
+  return typeof navigator !== "undefined" && (/iPad/.test(navigator.userAgent) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1);
+}
+function isTablet() {
+  return typeof navigator !== "undefined" && /(ipad|tablet|(android(?!.*mobile))|(windows(?!.*phone)(.*touch))|kindle|playbook|silk|(puffin(?!.*(IP|AP|WP))))/.test(
+    navigator.userAgent
+  );
+}
+function isIOS() {
+  return isSmallIOS() || isLargeIOS();
+}
+function isMobile() {
+  return isAndroid() || isIOS();
+}
+function isSafari() {
+  return typeof navigator !== "undefined" && /AppleWebKit/i.test(navigator.userAgent) && !/CriOS/i.test(navigator.userAgent) && !/Chrome/i.test(navigator.userAgent);
+}
+function isIOSWebview() {
+  const isStandalone = typeof navigator !== "undefined" && !navigator.standalone;
+  return typeof navigator !== "undefined" && isIOS() && !isStandalone && !/safari/i.test(navigator.userAgent.toLowerCase());
+}
+function isMobileSafari() {
+  return isMobile() && isSafari();
+}
+function isTelegram() {
+  return typeof window !== "undefined" && (Boolean(window.TelegramWebviewProxy) || Boolean(window.Telegram) || Boolean(window.TelegramWebviewProxyProto));
+}
+export {
+  isAndroid,
+  isIOS,
+  isIOSWebview,
+  isLargeIOS,
+  isMobile,
+  isMobileSafari,
+  isSafari,
+  isSmallIOS,
+  isTablet,
+  isTelegram
+};

package/dist/utils/isPasskeySupported.js

@@ -0,0 +1,17 @@
+"use client";
+import {
+  __async
+} from "../chunk-WLGKV3EF.js";
+import { UAParser } from "ua-parser-js";
+const isPasskeySupported = (userAgent) => __async(void 0, null, function* () {
+  var _a, _b, _c;
+  const directPasskeyCheck = yield (_b = (_a = window == null ? void 0 : window.PublicKeyCredential) == null ? void 0 : _a.isUserVerifyingPlatformAuthenticatorAvailable) == null ? void 0 : _b.call(_a);
+  if (directPasskeyCheck === true || directPasskeyCheck === false) {
+    return directPasskeyCheck;
+  }
+  const osName = (_c = new UAParser(userAgent).getOS().name) == null ? void 0 : _c.toLowerCase();
+  return !!osName && !["linux", "chrome os"].includes(osName);
+});
+export {
+  isPasskeySupported
+};

package/dist/utils/truncateEthAddress.js

@@ -0,0 +1,11 @@
+"use client";
+import "../chunk-WLGKV3EF.js";
+const truncateRegex = /^(0x[a-zA-Z0-9]{4})[a-zA-Z0-9]+([a-zA-Z0-9]{4})$/;
+const truncateEthAddress = (address) => {
+  const match = address.match(truncateRegex);
+  if (!match) return address;
+  return `${match[1]}\u2026${match[2]}`;
+};
+export {
+  truncateEthAddress
+};

package/dist/wallet/keygen.d.ts

@@ -1,11 +1,11 @@
 import { Ctx, TPregenIdentifierType } from '@getpara/core-sdk';
-import { BackupKitEmailProps, WalletType } from '@getpara/user-management-client';
-export declare function keygen(ctx: Ctx, userId: string, type: Exclude<WalletType, WalletType.SOLANA>, secretKey: string | null, skipDistribute?: boolean, sessionCookie?: string, emailProps?: BackupKitEmailProps): Promise<{
+import { BackupKitEmailProps, TWalletType } from '@getpara/user-management-client';
+export declare function keygen(ctx: Ctx, userId: string, type: Exclude<TWalletType, 'SOLANA'>, secretKey: string | null, skipDistribute?: boolean, sessionCookie?: string, emailProps?: BackupKitEmailProps): Promise<{
     signer: string;
     walletId: string;
     recoveryShare: string | null;
 }>;
-export declare function preKeygen(ctx: Ctx, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, type: Exclude<WalletType, WalletType.SOLANA>, secretKey: string | null, _skipDistribute: boolean, partnerId: string, sessionCookie?: string): Promise<{
+export declare function preKeygen(ctx: Ctx, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, type: Exclude<TWalletType, 'SOLANA'>, secretKey: string | null, _skipDistribute: boolean, partnerId: string, sessionCookie?: string): Promise<{
     signer: string;
     walletId: string;
     recoveryShare: string | null;

package/dist/wallet/keygen.js

@@ -0,0 +1,250 @@
+"use client";
+import {
+  __async
+} from "../chunk-WLGKV3EF.js";
+import { setupWorker } from "../workers/workerWrapper.js";
+import { distributeNewShare, waitUntilTrue } from "@getpara/core-sdk";
+import * as uuid from "uuid";
+function isKeygenComplete(ctx, userId, walletId) {
+  return __async(this, null, function* () {
+    const wallets = yield ctx.client.getWallets(userId);
+    const wallet = wallets.data.wallets.find((w) => w.id === walletId);
+    return !!wallet.address;
+  });
+}
+function isRefreshComplete(ctx, userId, walletId, partnerId, protocolId) {
+  return __async(this, null, function* () {
+    const { isDone } = yield ctx.client.isRefreshDone(userId, walletId, partnerId, protocolId);
+    return isDone;
+  });
+}
+function isPreKeygenComplete(ctx, pregenIdentifier, pregenIdentifierType, walletId) {
+  return __async(this, null, function* () {
+    const wallets = yield ctx.client.getPregenWallets({ [pregenIdentifierType]: [pregenIdentifier] });
+    const wallet = wallets.wallets.find((w) => w.id === walletId);
+    return !!wallet.address;
+  });
+}
+function keygen(ctx, userId, type, secretKey, skipDistribute = false, sessionCookie, emailProps = {}) {
+  return new Promise((resolve, reject) => __async(this, null, function* () {
+    const workId = uuid.v4();
+    let worker = null;
+    worker = yield setupWorker(
+      ctx,
+      (res) => __async(this, null, function* () {
+        yield waitUntilTrue(() => __async(this, null, function* () {
+          return isKeygenComplete(ctx, userId, res.walletId);
+        }), 15e3, 1e3);
+        if (skipDistribute) {
+          resolve({
+            signer: res.signer,
+            walletId: res.walletId,
+            recoveryShare: null
+          });
+          return;
+        }
+        const recoveryShare = yield distributeNewShare({
+          ctx,
+          userId,
+          walletId: res.walletId,
+          userShare: res.signer,
+          emailProps
+        });
+        resolve({
+          signer: res.signer,
+          walletId: res.walletId,
+          recoveryShare
+        });
+      }),
+      (error) => {
+        reject(error);
+      },
+      workId
+    );
+    worker.postMessage({
+      env: ctx.env,
+      apiKey: ctx.apiKey,
+      cosmosPrefix: ctx.cosmosPrefix,
+      params: { userId, secretKey, type },
+      functionType: "KEYGEN",
+      offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+      disableWorkers: ctx.disableWorkers,
+      sessionCookie,
+      useDKLS: ctx.useDKLS,
+      disableWebSockets: ctx.disableWebSockets,
+      wasmOverride: ctx.wasmOverride,
+      workId
+    });
+  }));
+}
+function preKeygen(ctx, pregenIdentifier, pregenIdentifierType, type, secretKey, _skipDistribute = false, partnerId, sessionCookie) {
+  return new Promise((resolve, reject) => __async(this, null, function* () {
+    const workId = uuid.v4();
+    let worker = null;
+    worker = yield setupWorker(
+      ctx,
+      (res) => __async(this, null, function* () {
+        yield waitUntilTrue(
+          () => __async(this, null, function* () {
+            return isPreKeygenComplete(ctx, pregenIdentifier, pregenIdentifierType, res.walletId);
+          }),
+          15e3,
+          1e3
+        );
+        resolve({
+          signer: res.signer,
+          walletId: res.walletId,
+          recoveryShare: null
+        });
+      }),
+      (error) => {
+        reject(error);
+      },
+      workId
+    );
+    const email = void 0;
+    const params = { pregenIdentifier, pregenIdentifierType, type, secretKey, partnerId, email };
+    if (pregenIdentifierType === "EMAIL") {
+      params.email = pregenIdentifier;
+    }
+    worker.postMessage({
+      env: ctx.env,
+      apiKey: ctx.apiKey,
+      cosmosPrefix: ctx.cosmosPrefix,
+      params,
+      functionType: "PREKEYGEN",
+      offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+      disableWorkers: ctx.disableWorkers,
+      sessionCookie,
+      useDKLS: ctx.useDKLS,
+      disableWebSockets: ctx.disableWebSockets,
+      wasmOverride: ctx.wasmOverride,
+      workId
+    });
+  }));
+}
+function refresh(ctx, sessionCookie, userId, walletId, share, oldPartnerId, newPartnerId, keyShareProtocolId) {
+  return new Promise((resolve, reject) => __async(this, null, function* () {
+    const workId = uuid.v4();
+    let worker = null;
+    worker = yield setupWorker(
+      ctx,
+      (res) => __async(this, null, function* () {
+        if (!(yield waitUntilTrue(() => __async(this, null, function* () {
+          return isRefreshComplete(ctx, userId, walletId, newPartnerId);
+        }), 15e3, 1e3))) {
+          reject(new Error("refresh failed"));
+          return;
+        }
+        const { protocolId, signer } = res;
+        resolve({
+          signer,
+          protocolId
+        });
+      }),
+      (error) => {
+        reject(error);
+      },
+      workId
+    );
+    worker.postMessage({
+      env: ctx.env,
+      apiKey: ctx.apiKey,
+      params: { userId, walletId, share, oldPartnerId, newPartnerId, keyShareProtocolId },
+      functionType: "REFRESH",
+      disableWorkers: ctx.disableWorkers,
+      sessionCookie,
+      useDKLS: ctx.useDKLS,
+      disableWebSockets: ctx.disableWebSockets,
+      wasmOverride: ctx.wasmOverride,
+      returnObject: true,
+      workId
+    });
+  }));
+}
+function ed25519Keygen(ctx, userId, sessionCookie, _emailProps = {}) {
+  return new Promise((resolve, reject) => __async(this, null, function* () {
+    const workId = uuid.v4();
+    let worker = null;
+    worker = yield setupWorker(
+      ctx,
+      (res) => __async(this, null, function* () {
+        yield waitUntilTrue(() => __async(this, null, function* () {
+          return isKeygenComplete(ctx, userId, res.walletId);
+        }), 15e3, 1e3);
+        resolve({
+          signer: res.signer,
+          walletId: res.walletId,
+          recoveryShare: null
+        });
+      }),
+      (error) => {
+        reject(error);
+      },
+      workId
+    );
+    worker.postMessage({
+      env: ctx.env,
+      apiKey: ctx.apiKey,
+      cosmosPrefix: ctx.cosmosPrefix,
+      params: { userId },
+      functionType: "ED25519_KEYGEN",
+      disableWorkers: ctx.disableWorkers,
+      sessionCookie,
+      disableWebSockets: ctx.disableWebSockets,
+      wasmOverride: ctx.wasmOverride,
+      workId
+    });
+  }));
+}
+function ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType, sessionCookie) {
+  return new Promise((resolve, reject) => __async(this, null, function* () {
+    const workId = uuid.v4();
+    let worker = null;
+    worker = yield setupWorker(
+      ctx,
+      (res) => __async(this, null, function* () {
+        yield waitUntilTrue(
+          () => __async(this, null, function* () {
+            return isPreKeygenComplete(ctx, pregenIdentifier, pregenIdentifierType, res.walletId);
+          }),
+          15e3,
+          1e3
+        );
+        resolve({
+          signer: res.signer,
+          walletId: res.walletId,
+          recoveryShare: null
+        });
+      }),
+      (error) => {
+        reject(error);
+      },
+      workId
+    );
+    const email = void 0;
+    const params = { pregenIdentifier, pregenIdentifierType, email };
+    if (pregenIdentifierType === "EMAIL") {
+      params.email = pregenIdentifier;
+    }
+    worker.postMessage({
+      env: ctx.env,
+      apiKey: ctx.apiKey,
+      cosmosPrefix: ctx.cosmosPrefix,
+      params,
+      functionType: "ED25519_PREKEYGEN",
+      disableWorkers: ctx.disableWorkers,
+      sessionCookie,
+      disableWebSockets: ctx.disableWebSockets,
+      wasmOverride: ctx.wasmOverride,
+      workId
+    });
+  }));
+}
+export {
+  ed25519Keygen,
+  ed25519PreKeygen,
+  keygen,
+  preKeygen,
+  refresh
+};

package/dist/wallet/privateKey.js

@@ -0,0 +1,41 @@
+"use client";
+import {
+  __async
+} from "../chunk-WLGKV3EF.js";
+import { setupWorker } from "../workers/workerWrapper.js";
+import * as uuid from "uuid";
+function getPrivateKey(ctx, userId, walletId, share, sessionCookie) {
+  return __async(this, null, function* () {
+    return new Promise((resolve, reject) => __async(this, null, function* () {
+      const workId = uuid.v4();
+      let worker = null;
+      worker = yield setupWorker(
+        ctx,
+        (res) => __async(this, null, function* () {
+          resolve((res == null ? void 0 : res.privateKey) || res);
+        }),
+        (error) => {
+          reject(error);
+        },
+        workId
+      );
+      worker.postMessage({
+        env: ctx.env,
+        apiKey: ctx.apiKey,
+        cosmosPrefix: ctx.cosmosPrefix,
+        params: { share, walletId, userId },
+        functionType: "GET_PRIVATE_KEY",
+        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+        disableWorkers: ctx.disableWorkers,
+        sessionCookie,
+        useDKLS: ctx.useDKLS,
+        disableWebSockets: ctx.disableWebSockets,
+        wasmOverride: ctx.wasmOverride,
+        workId
+      });
+    }));
+  });
+}
+export {
+  getPrivateKey
+};

package/dist/wallet/signing.js

@@ -0,0 +1,140 @@
+"use client";
+import {
+  __async
+} from "../chunk-WLGKV3EF.js";
+import { setupWorker } from "../workers/workerWrapper.js";
+import * as uuid from "uuid";
+function signTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
+  return __async(this, null, function* () {
+    return new Promise((resolve, reject) => __async(this, null, function* () {
+      const workId = uuid.v4();
+      let worker = null;
+      worker = yield setupWorker(
+        ctx,
+        (sendTransactionRes) => __async(this, null, function* () {
+          resolve(sendTransactionRes);
+        }),
+        (error) => {
+          reject(error);
+        },
+        workId
+      );
+      worker.postMessage({
+        env: ctx.env,
+        apiKey: ctx.apiKey,
+        cosmosPrefix: ctx.cosmosPrefix,
+        params: { share, walletId, userId, tx, chainId },
+        functionType: "SIGN_TRANSACTION",
+        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+        disableWorkers: ctx.disableWorkers,
+        sessionCookie,
+        useDKLS: isDKLS,
+        disableWebSockets: ctx.disableWebSockets,
+        wasmOverride: ctx.wasmOverride,
+        workId
+      });
+    }));
+  });
+}
+function sendTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
+  return __async(this, null, function* () {
+    return new Promise((resolve, reject) => __async(this, null, function* () {
+      const workId = uuid.v4();
+      let worker = null;
+      worker = yield setupWorker(
+        ctx,
+        (sendTransactionRes) => __async(this, null, function* () {
+          resolve(sendTransactionRes);
+        }),
+        (error) => {
+          reject(error);
+        },
+        workId
+      );
+      worker.postMessage({
+        env: ctx.env,
+        apiKey: ctx.apiKey,
+        cosmosPrefix: ctx.cosmosPrefix,
+        params: { share, walletId, userId, tx, chainId },
+        functionType: "SEND_TRANSACTION",
+        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+        disableWorkers: ctx.disableWorkers,
+        sessionCookie,
+        useDKLS: isDKLS,
+        disableWebSockets: ctx.disableWebSockets,
+        wasmOverride: ctx.wasmOverride,
+        workId
+      });
+    }));
+  });
+}
+function signMessage(ctx, userId, walletId, share, message, sessionCookie, isDKLS, cosmosSignDoc) {
+  return __async(this, null, function* () {
+    return new Promise((resolve, reject) => __async(this, null, function* () {
+      const workId = uuid.v4();
+      let worker = null;
+      worker = yield setupWorker(
+        ctx,
+        (signMessageRes) => __async(this, null, function* () {
+          resolve(signMessageRes);
+        }),
+        (error) => {
+          console.error(`Worker error in signMessage for userId ${userId}, walletId ${walletId}:`, error);
+          reject(error);
+        },
+        workId
+      );
+      worker.postMessage({
+        env: ctx.env,
+        apiKey: ctx.apiKey,
+        cosmosPrefix: ctx.cosmosPrefix,
+        params: { share, walletId, userId, message, cosmosSignDoc },
+        functionType: "SIGN_MESSAGE",
+        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+        disableWorkers: ctx.disableWorkers,
+        sessionCookie,
+        useDKLS: isDKLS,
+        disableWebSockets: ctx.disableWebSockets,
+        wasmOverride: ctx.wasmOverride,
+        workId
+      });
+    }));
+  });
+}
+function ed25519Sign(ctx, userId, walletId, share, base64Bytes, sessionCookie) {
+  return __async(this, null, function* () {
+    return new Promise((resolve, reject) => __async(this, null, function* () {
+      const workId = uuid.v4();
+      let worker = null;
+      worker = yield setupWorker(
+        ctx,
+        (signMessageRes) => __async(this, null, function* () {
+          resolve(signMessageRes);
+        }),
+        (error) => {
+          console.error(`Worker error in ed25519Sign for userId ${userId}, walletId ${walletId}:`, error);
+          reject(error);
+        },
+        workId
+      );
+      worker.postMessage({
+        env: ctx.env,
+        apiKey: ctx.apiKey,
+        cosmosPrefix: ctx.cosmosPrefix,
+        params: { share, walletId, userId, base64Bytes },
+        functionType: "ED25519_SIGN",
+        disableWorkers: ctx.disableWorkers,
+        sessionCookie,
+        disableWebSockets: ctx.disableWebSockets,
+        wasmOverride: ctx.wasmOverride,
+        workId
+      });
+    }));
+  });
+}
+export {
+  ed25519Sign,
+  sendTransaction,
+  signMessage,
+  signTransaction
+};