@getpara/core-sdk 2.11.0 → 2.13.0

package/dist/cjs/services/PregenWalletService.js

@@ -0,0 +1,442 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var PregenWalletService_exports = {};
+__export(PregenWalletService_exports, {
+  PregenWalletService: () => PregenWalletService
+});
+module.exports = __toCommonJS(PregenWalletService_exports);
+var import_user_management_client = require("@getpara/user-management-client");
+var import_wallet2 = require("../utils/wallet.js");
+var import_utils = require("../utils/index.js");
+var import_events = require("../types/events.js");
+var import_shareDistribution = require("../shares/shareDistribution.js");
+var import_constants = require("../constants.js");
+var import_stateListener = require("../utils/stateListener.js");
+var _stateManager, _authService, _walletService, _pollingService, _paraCoreInterface, _isCreateGuestWalletsPending, _fetchOverridePromise;
+class PregenWalletService {
+  constructor(paraCore) {
+    __privateAdd(this, _stateManager);
+    __privateAdd(this, _authService);
+    __privateAdd(this, _walletService);
+    __privateAdd(this, _pollingService);
+    __privateAdd(this, _paraCoreInterface);
+    __privateAdd(this, _isCreateGuestWalletsPending, false);
+    __privateAdd(this, _fetchOverridePromise, null);
+    this.init = ({
+      authService,
+      walletService,
+      pollingService,
+      stateManager
+    }) => {
+      __privateSet(this, _walletService, walletService);
+      __privateSet(this, _authService, authService);
+      __privateSet(this, _pollingService, pollingService);
+      __privateSet(this, _stateManager, stateManager);
+    };
+    this.isPregenWalletUnclaimed = (wallet) => {
+      return __privateGet(this, _walletService).isWalletSupported(wallet) && (!(wallet == null ? void 0 : wallet.userId) || (wallet == null ? void 0 : wallet.isPregen) && !!(wallet == null ? void 0 : wallet.pregenIdentifier) && !!(wallet == null ? void 0 : wallet.pregenIdentifierType));
+    };
+    this.isPregenWalletClaimable = (wallet) => {
+      return __privateGet(this, _walletService).isWalletSupported(wallet) && this.isPregenWalletUnclaimed(wallet) && (!["EMAIL", "PHONE", "TELEGRAM"].includes(wallet == null ? void 0 : wallet.pregenIdentifierType) || (0, import_wallet2.isPregenIdentifierMatch)(
+        (wallet == null ? void 0 : wallet.pregenIdentifierType) === "EMAIL" ? __privateGet(this, _authService).email : (wallet == null ? void 0 : wallet.pregenIdentifierType) === "TELEGRAM" ? __privateGet(this, _authService).telegramUserId : __privateGet(this, _authService).phone,
+        wallet == null ? void 0 : wallet.pregenIdentifier,
+        wallet == null ? void 0 : wallet.pregenIdentifierType
+      ));
+    };
+    this.fetchPregenWalletsFromOverride = (_0) => __async(this, [_0], function* ({ authInfo }) {
+      if (__privateGet(this, _paraCoreInterface).fetchPregenWalletsOverride && (0, import_user_management_client.isPregenAuth)(authInfo)) {
+        const previous = __privateGet(this, _fetchOverridePromise);
+        __privateSet(this, _fetchOverridePromise, (() => __async(this, null, function* () {
+          if (previous !== null) yield previous.catch(() => {
+          });
+          try {
+            const { userShare } = yield __privateGet(this, _paraCoreInterface).fetchPregenWalletsOverride({ pregenId: authInfo });
+            if (userShare) {
+              yield __privateGet(this, _walletService).setUserShare(userShare);
+            }
+          } finally {
+            __privateSet(this, _fetchOverridePromise, null);
+          }
+        }))());
+        yield __privateGet(this, _fetchOverridePromise);
+      }
+    });
+    this.performClaimPregenWallets = () => __async(this, null, function* () {
+      if (__privateGet(this, _fetchOverridePromise) !== null) {
+        try {
+          yield __privateGet(this, _fetchOverridePromise);
+        } catch (e) {
+        }
+      }
+      const { supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
+      const pregenWallets = yield this.getPregenWallets();
+      let recoverySecret, walletIds = {};
+      if (pregenWallets.length > 0) {
+        try {
+          const shares = yield __privateGet(this, _paraCoreInterface).ctx.enclaveClient.getPregenShares({
+            userId: __privateGet(this, _authService).userId,
+            walletIds: pregenWallets.map((w) => w.id),
+            partnerId: pregenWallets[0].partnerId
+          });
+          for (const share of shares) {
+            const wallet = pregenWallets.find((w) => w.id === share.walletId);
+            if (wallet) {
+              __privateGet(this, _walletService).wallets[wallet.id] = {
+                id: wallet.id,
+                address: wallet.address,
+                scheme: wallet.scheme,
+                type: wallet.type,
+                partnerId: wallet.partnerId,
+                isPregen: wallet.isPregen,
+                pregenIdentifier: wallet.pregenIdentifier,
+                pregenIdentifierType: wallet.pregenIdentifierType,
+                signer: share.signer,
+                createdAt: String(wallet.createdAt)
+              };
+            }
+          }
+        } catch (err) {
+          console.warn("[performClaimPregenWallets] Failed to fetch pregen shares:", err);
+        }
+        recoverySecret = yield this.claimPregenWallets();
+        walletIds = supportedWalletTypes.reduce((acc, { type }) => {
+          const wallet = pregenWallets.find((w) => !!import_wallet2.WalletSchemeTypeMap[w.scheme][type]);
+          if (!wallet) {
+            return acc;
+          }
+          return __spreadProps(__spreadValues({}, acc), {
+            [type]: [wallet.id]
+          });
+        }, {});
+      }
+      yield __privateGet(this, _walletService).addToCurrentWalletIds(walletIds);
+      const resp = { walletIds, recoverySecret };
+      return resp;
+    });
+    this.claimPregenWallets = (..._0) => __async(this, [..._0], function* ({ pregenId } = {}) {
+      var _a;
+      __privateGet(this, _paraCoreInterface).requireApiKey();
+      const pregenWallets = pregenId ? yield this.getPregenWallets({ pregenId }) : yield this.getPregenWallets();
+      if (pregenWallets.length === 0) {
+        return void 0;
+      }
+      const missingWallets = pregenWallets.filter((wallet) => !__privateGet(this, _walletService).wallets[wallet.id]);
+      if (missingWallets.length > 0) {
+        throw new Error(
+          `Cannot claim pregen wallets because wallet data is missing. Please call setUserShare first to load the wallet data for the following wallet IDs: ${missingWallets.map((w) => w.id).join(", ")}`
+        );
+      }
+      let newRecoverySecret;
+      const { walletIds } = yield __privateGet(this, _paraCoreInterface).ctx.client.claimPregenWallets({
+        userId: __privateGet(this, _authService).userId,
+        walletIds: pregenWallets.map((w) => w.id)
+      });
+      for (const walletId of walletIds) {
+        const wallet = __privateGet(this, _walletService).wallets[walletId];
+        let refreshedShare;
+        if (wallet.scheme === "ED25519") {
+          const distributeRes = yield (0, import_shareDistribution.distributeNewShare)({
+            ctx: __privateGet(this, _paraCoreInterface).ctx,
+            userId: __privateGet(this, _authService).userId,
+            walletId: wallet.id,
+            userShare: __privateGet(this, _walletService).wallets[wallet.id].signer,
+            emailProps: __privateGet(this, _paraCoreInterface).getBackupKitEmailProps(),
+            partnerId: wallet.partnerId,
+            isEnclaveUser: __privateGet(this, _authService).isEnclaveUser,
+            walletScheme: wallet.scheme
+          });
+          if (distributeRes.length > 0) {
+            newRecoverySecret = distributeRes;
+          }
+        } else {
+          refreshedShare = yield __privateGet(this, _walletService).refreshShare({
+            walletId: wallet.id,
+            share: __privateGet(this, _walletService).wallets[wallet.id].signer,
+            oldPartnerId: wallet.partnerId,
+            newPartnerId: wallet.partnerId,
+            redistributeBackupEncryptedShares: true
+          });
+          if (refreshedShare.recoverySecret) {
+            newRecoverySecret = refreshedShare.recoverySecret;
+          }
+        }
+        __privateGet(this, _walletService).wallets[wallet.id] = __spreadProps(__spreadValues({}, __privateGet(this, _walletService).wallets[wallet.id]), {
+          signer: (_a = refreshedShare == null ? void 0 : refreshedShare.signer) != null ? _a : wallet.signer,
+          userId: __privateGet(this, _authService).userId,
+          pregenIdentifier: void 0,
+          pregenIdentifierType: void 0
+        });
+        const walletNoSigner = __spreadValues({}, __privateGet(this, _walletService).wallets[wallet.id]);
+        delete walletNoSigner.signer;
+        (0, import_utils.dispatchEvent)(import_events.ParaEvent.PREGEN_WALLET_CLAIMED, {
+          wallet: walletNoSigner,
+          recoverySecret: newRecoverySecret
+        });
+      }
+      yield __privateGet(this, _walletService).setWallets(__privateGet(this, _walletService).wallets);
+      return newRecoverySecret;
+    });
+    this.getPregenWallets = (..._0) => __async(this, [..._0], function* ({ pregenId } = {}) {
+      const pregenIds = pregenId ? (0, import_user_management_client.toPregenIds)(pregenId) : this.pregenIds;
+      if (!pregenIds || Object.keys(pregenIds).length === 0) {
+        return [];
+      }
+      __privateGet(this, _paraCoreInterface).requireApiKey();
+      const res = yield __privateGet(this, _paraCoreInterface).ctx.client.getPregenWallets(
+        pregenIds,
+        __privateGet(this, _paraCoreInterface).isPortal(),
+        __privateGet(this, _authService).userId
+      );
+      return res.wallets.filter((w) => __privateGet(this, _walletService).isWalletSupported((0, import_wallet2.entityToWallet)(w)));
+    });
+    this.populatePregenWalletAddresses = () => __async(this, null, function* () {
+      const res = yield this.getPregenWallets();
+      res.forEach((entity) => {
+        if (__privateGet(this, _walletService).wallets[entity.id]) {
+          __privateGet(this, _walletService).wallets[entity.id] = __spreadValues(__spreadValues({}, (0, import_wallet2.entityToWallet)(entity)), __privateGet(this, _walletService).wallets[entity.id]);
+        }
+      });
+      yield __privateGet(this, _walletService).setWallets(__privateGet(this, _walletService).wallets);
+    });
+    this.createPregenWallet = (params) => __async(this, null, function* () {
+      var _a, _b;
+      const { supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
+      const { type: _type = (_a = supportedWalletTypes.find(({ optional }) => !optional)) == null ? void 0 : _a.type, pregenId } = params;
+      __privateGet(this, _paraCoreInterface).requireApiKey();
+      const walletType = yield __privateGet(this, _walletService).assertIsValidWalletType(
+        _type != null ? _type : (_b = supportedWalletTypes.find(({ optional }) => !optional)) == null ? void 0 : _b.type
+      );
+      const [pregenIdentifierType, pregenIdentifier] = (0, import_user_management_client.toPregenTypeAndId)(pregenId);
+      let keygenRes;
+      switch (walletType) {
+        case "SOLANA":
+          keygenRes = yield __privateGet(this, _paraCoreInterface).platformUtils.ed25519PreKeygen(
+            __privateGet(this, _paraCoreInterface).ctx,
+            pregenIdentifier,
+            pregenIdentifierType,
+            __privateGet(this, _paraCoreInterface).retrieveSessionCookie()
+          );
+          break;
+        default:
+          keygenRes = yield __privateGet(this, _paraCoreInterface).platformUtils.preKeygen(
+            __privateGet(this, _paraCoreInterface).ctx,
+            void 0,
+            pregenIdentifier,
+            pregenIdentifierType,
+            walletType,
+            null,
+            __privateGet(this, _paraCoreInterface).retrieveSessionCookie()
+          );
+          break;
+      }
+      const { signer, walletId } = keygenRes;
+      __privateGet(this, _walletService).wallets[walletId] = {
+        id: walletId,
+        signer,
+        scheme: walletType === "SOLANA" ? "ED25519" : "DKLS",
+        type: walletType,
+        isPregen: true,
+        pregenIdentifier,
+        pregenIdentifierType
+      };
+      yield __privateGet(this, _pollingService).poll({
+        checkCondition: __privateGet(this, _pollingService).waitForPregenWalletAddress({ walletId }),
+        intervalMs: import_constants.SHORT_POLLING_INTERVAL_MS,
+        maxPolls: 10,
+        id: "waitForPregenWalletAddress"
+      });
+      yield this.populatePregenWalletAddresses();
+      return __privateGet(this, _walletService).wallets[walletId];
+    });
+    this.createPregenWalletPerType = (_0) => __async(this, [_0], function* ({ types, pregenId }) {
+      const wallets = [];
+      for (const type of yield __privateGet(this, _walletService).getTypesToCreate(types)) {
+        const wallet = yield this.createPregenWallet({ type, pregenId });
+        wallets.push(wallet);
+      }
+      return wallets;
+    });
+    this.updatePregenWalletIdentifier = (_0) => __async(this, [_0], function* ({ walletId, newPregenId }) {
+      __privateGet(this, _paraCoreInterface).requireApiKey();
+      const [newPregenIdentifierType, newPregenIdentifier] = (0, import_user_management_client.toPregenTypeAndId)(newPregenId);
+      yield __privateGet(this, _paraCoreInterface).ctx.client.updatePregenWallet(walletId, {
+        pregenIdentifier: newPregenIdentifier,
+        pregenIdentifierType: newPregenIdentifierType
+      });
+      if (!!__privateGet(this, _walletService).wallets[walletId]) {
+        __privateGet(this, _walletService).wallets[walletId] = __spreadProps(__spreadValues({}, __privateGet(this, _walletService).wallets[walletId]), {
+          pregenIdentifier: newPregenIdentifier,
+          pregenIdentifierType: newPregenIdentifierType
+        });
+        yield __privateGet(this, _walletService).setWallets(__privateGet(this, _walletService).wallets);
+      }
+    });
+    this.hasPregenWallet = (_0) => __async(this, [_0], function* ({ pregenId }) {
+      __privateGet(this, _paraCoreInterface).requireApiKey();
+      const [pregenIdentifierType, pregenIdentifier] = (0, import_user_management_client.toPregenTypeAndId)(pregenId);
+      const wallets = yield this.getPregenWallets({ pregenId });
+      const wallet = wallets.find(
+        (w) => w.pregenIdentifier === pregenIdentifier && w.pregenIdentifierType === pregenIdentifierType
+      );
+      if (!wallet) {
+        return false;
+      }
+      return true;
+    });
+    this.performCreateGuestWallets = () => __async(this, null, function* () {
+      let error;
+      if (__privateGet(this, _isCreateGuestWalletsPending)) {
+        error = new Error("Guest wallets creation already in progress");
+        (0, import_utils.dispatchEvent)(import_events.ParaEvent.GUEST_WALLETS_CREATED, null, error.message);
+        throw error;
+      }
+      if (this.isGuestMode) {
+        error = new Error("Guest wallets already created");
+        (0, import_utils.dispatchEvent)(import_events.ParaEvent.GUEST_WALLETS_CREATED, null, error.message);
+        throw error;
+      }
+      try {
+        __privateSet(this, _isCreateGuestWalletsPending, true);
+        const { supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
+        const wallets = [];
+        const guestId = (0, import_wallet2.newUuid)();
+        for (const type of yield __privateGet(this, _walletService).getTypesToCreate(
+          supportedWalletTypes.filter(({ optional }) => !optional).map(({ type: type2 }) => type2)
+        )) {
+          const wallet = yield this.createPregenWallet({ type, pregenId: { guestId } });
+          wallets.push(wallet);
+        }
+        (0, import_utils.dispatchEvent)(import_events.ParaEvent.GUEST_WALLETS_CREATED, wallets);
+        __privateSet(this, _isCreateGuestWalletsPending, false);
+        return wallets;
+      } catch (error2) {
+        (0, import_utils.dispatchEvent)(import_events.ParaEvent.GUEST_WALLETS_CREATED, null, error2 == null ? void 0 : error2.message);
+        __privateSet(this, _isCreateGuestWalletsPending, false);
+        throw error2;
+      }
+    });
+    this.createGuestWallets = () => __async(this, null, function* () {
+      __privateGet(this, _stateManager).send({ type: "INITIALIZE_GUEST_MODE" });
+      return yield (0, import_stateListener.waitForCoreStateChange)({
+        stateManager: __privateGet(this, _stateManager),
+        resolvePhases: [{ phase: "guest_mode", onPhase: (state) => state.guestWallets }]
+      });
+    });
+    __privateSet(this, _paraCoreInterface, paraCore.getPregenWalletServiceInterface());
+  }
+  /**
+   * A map of pre-generated wallet identifiers that can be claimed in the current instance.
+   */
+  get pregenIds() {
+    return __spreadValues({}, Object.values(__privateGet(this, _walletService).wallets).filter((wallet) => !__privateGet(this, _authService).userId || this.isPregenWalletClaimable(wallet)).reduce((acc, wallet) => {
+      var _a, _b;
+      if (((_a = acc[wallet.pregenIdentifierType]) != null ? _a : []).includes(wallet.pregenIdentifier)) {
+        return acc;
+      }
+      return __spreadProps(__spreadValues({}, acc), {
+        [wallet.pregenIdentifierType]: [
+          .../* @__PURE__ */ new Set([...(_b = acc[wallet.pregenIdentifierType]) != null ? _b : [], wallet.pregenIdentifier])
+        ]
+      });
+    }, {}));
+  }
+  get guestWalletIds() {
+    var _a, _b, _c;
+    if (!((_a = __privateGet(this, _paraCoreInterface).partner) == null ? void 0 : _a.supportedWalletTypes)) {
+      return {};
+    }
+    const guestId = (_c = (_b = this.pregenIds) == null ? void 0 : _b.GUEST_ID) == null ? void 0 : _c[0];
+    return !!guestId ? Object.entries(__privateGet(this, _walletService).wallets).reduce((acc, [id, wallet]) => {
+      if (wallet.isPregen && !wallet.userId && wallet.pregenIdentifierType === "GUEST_ID" && wallet.pregenIdentifier === guestId) {
+        return __spreadValues(__spreadValues({}, acc), (0, import_wallet2.getEquivalentTypes)(wallet.type).filter((type) => __privateGet(this, _paraCoreInterface).partner.supportedWalletTypes.some((entry) => entry.type === type)).reduce((acc2, eqType) => {
+          var _a2;
+          return __spreadProps(__spreadValues({}, acc2), { [eqType]: [.../* @__PURE__ */ new Set([...(_a2 = acc2[eqType]) != null ? _a2 : [], id])] });
+        }, {}));
+      }
+      return acc;
+    }, {}) : {};
+  }
+  get guestWalletIdsArray() {
+    return Object.entries(this.guestWalletIds).reduce((acc, [type, ids]) => {
+      return [...acc, ...ids.map((id) => [id, type])];
+    }, []);
+  }
+  get isGuestMode() {
+    return this.guestWalletIdsArray.length > 0 && Object.values(__privateGet(this, _walletService).wallets).every(
+      ({ userId, partnerId }) => {
+        var _a;
+        return partnerId === ((_a = __privateGet(this, _paraCoreInterface).partner) == null ? void 0 : _a.id) && (!userId || userId !== __privateGet(this, _authService).userId);
+      }
+    );
+  }
+}
+_stateManager = new WeakMap();
+_authService = new WeakMap();
+_walletService = new WeakMap();
+_pollingService = new WeakMap();
+_paraCoreInterface = new WeakMap();
+_isCreateGuestWalletsPending = new WeakMap();
+_fetchOverridePromise = new WeakMap();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PregenWalletService
+});