@getpara/web-sdk 2.0.0-alpha.3 → 2.0.0-alpha.6

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-M66XENHI.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-M66XENHI.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-M66XENHI.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-M66XENHI.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-M66XENHI.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,204 @@
+"use client";
+import {
+  __async
+} from "../chunk-M66XENHI.js";
+import { setupWorker } from "../workers/workerWrapper.js";
+import { distributeNewShare, waitUntilTrue } from "@getpara/core-sdk";
+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) => __async(this, null, function* () {
+    const 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
+        });
+        worker.terminate();
+        return;
+      }
+      const recoveryShare = yield distributeNewShare({
+        ctx,
+        userId,
+        walletId: res.walletId,
+        userShare: res.signer,
+        emailProps
+      });
+      resolve({
+        signer: res.signer,
+        walletId: res.walletId,
+        recoveryShare
+      });
+      worker.terminate();
+    }));
+    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
+    });
+  }));
+}
+function preKeygen(ctx, pregenIdentifier, pregenIdentifierType, type, secretKey, _skipDistribute = false, partnerId, sessionCookie) {
+  return new Promise((resolve) => __async(this, null, function* () {
+    const 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
+      });
+      worker.terminate();
+    }));
+    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
+    });
+  }));
+}
+function refresh(ctx, sessionCookie, userId, walletId, share, oldPartnerId, newPartnerId, keyShareProtocolId) {
+  return new Promise((resolve) => __async(this, null, function* () {
+    const worker = yield setupWorker(ctx, (res) => __async(this, null, function* () {
+      if (!(yield waitUntilTrue(() => __async(this, null, function* () {
+        return isRefreshComplete(ctx, userId, walletId, newPartnerId);
+      }), 15e3, 1e3))) {
+        throw new Error("refresh failed");
+      }
+      const { protocolId, signer } = res;
+      resolve({
+        signer,
+        protocolId
+      });
+      worker.terminate();
+    }));
+    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
+    });
+  }));
+}
+function ed25519Keygen(ctx, userId, sessionCookie, _emailProps = {}) {
+  return new Promise((resolve) => __async(this, null, function* () {
+    const 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
+      });
+      worker.terminate();
+    }));
+    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
+    });
+  }));
+}
+function ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType, sessionCookie) {
+  return new Promise((resolve) => __async(this, null, function* () {
+    const 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
+      });
+      worker.terminate();
+    }));
+    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
+    });
+  }));
+}
+export {
+  ed25519Keygen,
+  ed25519PreKeygen,
+  keygen,
+  preKeygen,
+  refresh
+};

package/dist/wallet/privateKey.js

@@ -0,0 +1,31 @@
+"use client";
+import {
+  __async
+} from "../chunk-M66XENHI.js";
+import { setupWorker } from "../workers/workerWrapper.js";
+function getPrivateKey(ctx, userId, walletId, share, sessionCookie) {
+  return __async(this, null, function* () {
+    return yield new Promise((resolve) => __async(this, null, function* () {
+      const worker = yield setupWorker(ctx, (res) => __async(this, null, function* () {
+        resolve(res);
+        worker.terminate();
+      }));
+      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
+      });
+    }));
+  });
+}
+export {
+  getPrivateKey
+};

package/dist/wallet/signing.js

@@ -0,0 +1,101 @@
+"use client";
+import {
+  __async
+} from "../chunk-M66XENHI.js";
+import { setupWorker } from "../workers/workerWrapper.js";
+function signTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
+  return __async(this, null, function* () {
+    return yield new Promise((resolve) => __async(this, null, function* () {
+      const worker = yield setupWorker(ctx, (sendTransactionRes) => __async(this, null, function* () {
+        resolve(sendTransactionRes);
+        worker.terminate();
+      }));
+      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
+      });
+    }));
+  });
+}
+function sendTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
+  return __async(this, null, function* () {
+    return yield new Promise((resolve) => __async(this, null, function* () {
+      const worker = yield setupWorker(ctx, (sendTransactionRes) => __async(this, null, function* () {
+        resolve(sendTransactionRes);
+        worker.terminate();
+      }));
+      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
+      });
+    }));
+  });
+}
+function signMessage(ctx, userId, walletId, share, message, sessionCookie, isDKLS, cosmosSignDoc) {
+  return __async(this, null, function* () {
+    return yield new Promise((resolve) => __async(this, null, function* () {
+      const worker = yield setupWorker(ctx, (signMessageRes) => __async(this, null, function* () {
+        resolve(signMessageRes);
+        worker.terminate();
+      }));
+      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
+      });
+    }));
+  });
+}
+function ed25519Sign(ctx, userId, walletId, share, base64Bytes, sessionCookie) {
+  return __async(this, null, function* () {
+    return yield new Promise((resolve) => __async(this, null, function* () {
+      const worker = yield setupWorker(ctx, (signMessageRes) => __async(this, null, function* () {
+        resolve(signMessageRes);
+        worker.terminate();
+      }));
+      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
+      });
+    }));
+  });
+}
+export {
+  ed25519Sign,
+  sendTransaction,
+  signMessage,
+  signTransaction
+};