@getpara/core-sdk 2.11.0 → 2.13.0

package/dist/esm/services/WalletService.js

@@ -0,0 +1,514 @@
+import {
+  __async,
+  __objRest,
+  __privateAdd,
+  __privateGet,
+  __privateSet,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-7B52C2XE.js";
+var _authService, _pollingService, _pregenWalletService, _externalWalletService, _paraCoreInterface, _wallets, _currentWalletIds, _isWalletOwned, _getMissingTypes, _encodeWalletBase64;
+import { WALLET_TYPES } from "@getpara/user-management-client";
+import {
+  entityToWallet,
+  getEquivalentTypes,
+  getSchemes,
+  isWalletSupported,
+  migrateWallet,
+  WalletSchemeTypeMap
+} from "../utils/wallet.js";
+import { dispatchEvent, getCosmosAddress, truncateAddress } from "../utils/index.js";
+import { ParaEvent } from "../types/events.js";
+import { LOCAL_STORAGE_CURRENT_WALLET_IDS, LOCAL_STORAGE_WALLETS, SHORT_POLLING_INTERVAL_MS } from "../constants.js";
+import { distributeNewShare } from "../shares/shareDistribution.js";
+import { sendRecoveryForShare } from "../shares/recovery.js";
+class WalletService {
+  constructor(paraCore) {
+    __privateAdd(this, _authService);
+    __privateAdd(this, _pollingService);
+    __privateAdd(this, _pregenWalletService);
+    __privateAdd(this, _externalWalletService);
+    __privateAdd(this, _paraCoreInterface);
+    __privateAdd(this, _wallets);
+    __privateAdd(this, _currentWalletIds, {});
+    this.init = ({
+      authService,
+      pollingService,
+      pregenWalletService,
+      externalWalletService
+    }) => {
+      __privateSet(this, _authService, authService);
+      __privateSet(this, _pollingService, pollingService);
+      __privateSet(this, _pregenWalletService, pregenWalletService);
+      __privateSet(this, _externalWalletService, externalWalletService);
+    };
+    this.setWallets = (wallets) => __async(this, null, function* () {
+      this.wallets = wallets;
+      if (__privateGet(this, _paraCoreInterface).platformUtils.secureStorage) {
+        yield __privateGet(this, _paraCoreInterface).platformUtils.secureStorage.set(LOCAL_STORAGE_WALLETS, JSON.stringify(wallets));
+        return;
+      }
+      yield __privateGet(this, _paraCoreInterface).localStorageSetItem(LOCAL_STORAGE_WALLETS, JSON.stringify(wallets));
+    });
+    this.refreshShare = (_0) => __async(this, [_0], function* ({
+      walletId,
+      share,
+      oldPartnerId,
+      newPartnerId,
+      keyShareProtocolId,
+      redistributeBackupEncryptedShares
+    }) {
+      const { signer, protocolId } = yield __privateGet(this, _paraCoreInterface).platformUtils.refresh(
+        __privateGet(this, _paraCoreInterface).ctx,
+        __privateGet(this, _paraCoreInterface).retrieveSessionCookie(),
+        __privateGet(this, _authService).userId,
+        walletId,
+        share,
+        oldPartnerId,
+        newPartnerId,
+        keyShareProtocolId
+      );
+      const recoverySecret = yield distributeNewShare({
+        ctx: __privateGet(this, _paraCoreInterface).ctx,
+        userId: __privateGet(this, _authService).userId,
+        walletId,
+        userShare: signer,
+        ignoreRedistributingBackupEncryptedShare: !redistributeBackupEncryptedShares,
+        emailProps: __privateGet(this, _paraCoreInterface).getBackupKitEmailProps(),
+        partnerId: newPartnerId,
+        protocolId,
+        isEnclaveUser: __privateGet(this, _authService).isEnclaveUser,
+        walletScheme: this.wallets[walletId].scheme
+      });
+      return { signer, recoverySecret, protocolId };
+    });
+    __privateAdd(this, _isWalletOwned, (wallet) => {
+      return this.isWalletSupported(wallet) && !(wallet == null ? void 0 : wallet.pregenIdentifier) && !(wallet == null ? void 0 : wallet.pregenIdentifierType) && !!__privateGet(this, _authService).userId && (wallet == null ? void 0 : wallet.userId) === __privateGet(this, _authService).userId;
+    });
+    __privateAdd(this, _getMissingTypes, () => __async(this, null, function* () {
+      const { supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
+      return supportedWalletTypes.filter(
+        ({ type: t, optional }) => !optional && Object.values(this.wallets).every((w) => !__privateGet(this, _isWalletOwned).call(this, w) || !WalletSchemeTypeMap[w.scheme][t])
+      ).map(({ type }) => type);
+    }));
+    this.getTypesToCreate = (types) => __async(this, null, function* () {
+      const { supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
+      return getSchemes(types != null ? types : yield __privateGet(this, _getMissingTypes).call(this)).map((scheme) => {
+        switch (scheme) {
+          case "ED25519":
+            return "SOLANA";
+          default:
+            return supportedWalletTypes.some(({ type, optional }) => type === "COSMOS" && !optional) ? "COSMOS" : "EVM";
+        }
+      });
+    });
+    this.populateWalletAddresses = () => __async(this, null, function* () {
+      const res = yield (__privateGet(this, _paraCoreInterface).isPortal() ? __privateGet(this, _paraCoreInterface).ctx.client.getAllWallets : __privateGet(this, _paraCoreInterface).ctx.client.getWallets)(__privateGet(this, _authService).userId, true);
+      const wallets = res.data.wallets;
+      wallets.forEach((entity) => {
+        if (this.wallets[entity.id]) {
+          this.wallets[entity.id] = __spreadValues(__spreadValues({}, entityToWallet(entity)), this.wallets[entity.id]);
+        }
+      });
+      yield this.setWallets(this.wallets);
+    });
+    this.addToCurrentWalletIds = (walletIds, options) => __async(this, null, function* () {
+      const updatedWalletIds = __spreadValues({}, this.currentWalletIds);
+      Object.entries(walletIds).forEach(([type, ids]) => {
+        var _a;
+        updatedWalletIds[type] = [.../* @__PURE__ */ new Set([...(_a = updatedWalletIds[type]) != null ? _a : [], ...ids])];
+      });
+      yield this.setCurrentWalletIds(updatedWalletIds, options);
+    });
+    this.setCurrentWalletIds = (_0, ..._1) => __async(this, [_0, ..._1], function* (currentWalletIds, { needsWallet = false, sessionLookupId, newDeviceSessionLookupId } = {}) {
+      this.currentWalletIds = currentWalletIds;
+      yield __privateGet(this, _paraCoreInterface).localStorageSetItem(
+        LOCAL_STORAGE_CURRENT_WALLET_IDS,
+        JSON.stringify(this.currentWalletIds)
+      );
+      if (sessionLookupId) {
+        yield __privateGet(this, _paraCoreInterface).ctx.client.setCurrentWalletIds(
+          __privateGet(this, _authService).userId,
+          this.currentWalletIds,
+          needsWallet,
+          sessionLookupId,
+          newDeviceSessionLookupId
+        );
+      }
+      dispatchEvent(ParaEvent.WALLETS_CHANGE_EVENT, null);
+    });
+    this.createWallet = (..._0) => __async(this, [..._0], function* ({ type: _type, skipDistribute = false } = {}) {
+      var _a, _b;
+      __privateGet(this, _paraCoreInterface).requireApiKey();
+      const { supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
+      const walletType = yield this.assertIsValidWalletType(
+        _type != null ? _type : (_a = supportedWalletTypes.find(({ optional }) => !optional)) == null ? void 0 : _a.type
+      );
+      let signer;
+      let wallet;
+      let keygenRes;
+      switch (walletType) {
+        case "SOLANA": {
+          keygenRes = yield __privateGet(this, _paraCoreInterface).platformUtils.ed25519Keygen(
+            __privateGet(this, _paraCoreInterface).ctx,
+            __privateGet(this, _authService).userId,
+            __privateGet(this, _paraCoreInterface).retrieveSessionCookie(),
+            __privateGet(this, _paraCoreInterface).getBackupKitEmailProps()
+          );
+          break;
+        }
+        default: {
+          keygenRes = yield __privateGet(this, _paraCoreInterface).platformUtils.keygen(
+            __privateGet(this, _paraCoreInterface).ctx,
+            __privateGet(this, _authService).userId,
+            walletType,
+            null,
+            __privateGet(this, _paraCoreInterface).retrieveSessionCookie(),
+            __privateGet(this, _paraCoreInterface).getBackupKitEmailProps()
+          );
+          break;
+        }
+      }
+      const walletId = keygenRes.walletId;
+      const walletScheme = walletType === "SOLANA" ? "ED25519" : "DKLS";
+      signer = keygenRes.signer;
+      yield __privateGet(this, _pollingService).poll({
+        checkCondition: __privateGet(this, _pollingService).waitForWalletAddress({ walletId }),
+        intervalMs: SHORT_POLLING_INTERVAL_MS,
+        maxPolls: 10
+      });
+      let recoveryShare = null;
+      if (!skipDistribute) {
+        recoveryShare = yield distributeNewShare({
+          ctx: __privateGet(this, _paraCoreInterface).ctx,
+          userId: __privateGet(this, _authService).userId,
+          walletId,
+          userShare: signer,
+          emailProps: __privateGet(this, _paraCoreInterface).getBackupKitEmailProps(),
+          isEnclaveUser: __privateGet(this, _authService).isEnclaveUser,
+          walletScheme
+        });
+      }
+      this.wallets[walletId] = {
+        id: walletId,
+        signer,
+        scheme: walletScheme,
+        type: walletType
+      };
+      wallet = this.wallets[walletId];
+      yield this.populateWalletAddresses();
+      yield this.addToCurrentWalletIds({
+        [walletType]: [.../* @__PURE__ */ new Set([...(_b = this.currentWalletIds[walletType]) != null ? _b : [], walletId])]
+      });
+      const walletNoSigner = __spreadValues({}, wallet);
+      delete walletNoSigner.signer;
+      dispatchEvent(ParaEvent.WALLET_CREATED, {
+        wallet: walletNoSigner,
+        recoverySecret: recoveryShare
+      });
+      return [wallet, recoveryShare];
+    });
+    this.createWalletPerType = (..._0) => __async(this, [..._0], function* ({ skipDistribute = false, types } = {}) {
+      const wallets = [];
+      const walletIds = {};
+      let recoverySecret;
+      for (const type of yield this.getTypesToCreate(types)) {
+        const [wallet, recoveryShare] = yield this.createWallet({ type, skipDistribute });
+        wallets.push(wallet);
+        getEquivalentTypes(type).filter((t) => !!this.isWalletTypeEnabled[t]).forEach((t) => {
+          walletIds[t] = [wallet.id];
+        });
+        if (recoveryShare) {
+          recoverySecret = recoveryShare;
+        }
+      }
+      return { wallets, walletIds, recoverySecret };
+    });
+    this.findWalletId = (walletId, filter = {}) => {
+      if (walletId) {
+        this.assertIsValidWalletId(walletId, filter);
+      } else {
+        for (const id of [...this.currentWalletIdsUnique, ...Object.keys(this.wallets)]) {
+          if (this.isWalletUsable(id, filter)) {
+            walletId = id;
+            break;
+          }
+        }
+        if (!walletId) {
+          throw new Error(`no valid wallet id found`);
+        }
+      }
+      return walletId;
+    };
+    this.findWalletByAddress = (address, filter) => {
+      if (__privateGet(this, _externalWalletService).externalWallets[address]) {
+        return __privateGet(this, _externalWalletService).externalWallets[address];
+      }
+      let wallet;
+      Object.entries(this.currentWalletIds).forEach(([type, walletIds]) => {
+        const pregenWalletIds = Object.keys(this.wallets).filter(
+          (id) => this.wallets[id].type === type && __privateGet(this, _pregenWalletService).isPregenWalletClaimable(this.wallets[id])
+        );
+        [...walletIds, ...pregenWalletIds].forEach((id) => {
+          if (address.toLowerCase() === this.getDisplayAddress(id, { addressType: type }).toLowerCase()) {
+            wallet = this.wallets[id];
+          }
+        });
+      });
+      if (!wallet) {
+        throw new Error(`wallet with address ${address} not found`);
+      }
+      this.assertIsValidWalletId(wallet.id, filter);
+      return wallet;
+    };
+    this.findWallet = (idOrAddress, overrideType, filter = {}) => {
+      var _a, _c, _d;
+      if (!__privateGet(this, _authService).isExternalWalletAuth) {
+        if (!idOrAddress && Object.keys(__privateGet(this, _externalWalletService).externalWallets).length > 0) {
+          return Object.values(__privateGet(this, _externalWalletService).externalWallets)[0];
+        }
+      }
+      if ((_a = __privateGet(this, _externalWalletService).externalWallets) == null ? void 0 : _a[idOrAddress]) {
+        return __privateGet(this, _externalWalletService).externalWallets[idOrAddress];
+      }
+      try {
+        const walletId = this.findWalletId(idOrAddress, filter);
+        if (walletId && !!this.wallets[walletId]) {
+          const _b = this.wallets[walletId], { signer: _signer } = _b, wallet = __objRest(_b, ["signer"]);
+          const type = (_d = overrideType != null ? overrideType : (_c = this.currentWalletIdsArray.find(([id]) => id === walletId)) == null ? void 0 : _c[1]) != null ? _d : wallet.type;
+          return __spreadProps(__spreadValues({}, wallet), {
+            type
+          });
+        }
+      } catch (e) {
+        return void 0;
+      }
+    };
+    this.getDisplayAddress = (walletId, options = {}) => {
+      var _a, _b;
+      if (__privateGet(this, _externalWalletService).externalWallets[walletId]) {
+        const wallet2 = __privateGet(this, _externalWalletService).externalWallets[walletId];
+        return options.truncate ? truncateAddress(wallet2.address, wallet2.type, {
+          prefix: __privateGet(this, _paraCoreInterface).cosmosPrefix,
+          targetLength: options.targetLength
+        }) : wallet2.address;
+      }
+      const wallet = this.findWallet(walletId, options.addressType);
+      if (!wallet) {
+        return void 0;
+      }
+      let str;
+      let prefix;
+      switch (wallet.type) {
+        case "COSMOS":
+          prefix = (_b = (_a = options.cosmosPrefix) != null ? _a : __privateGet(this, _paraCoreInterface).cosmosPrefix) != null ? _b : "cosmos";
+          str = getCosmosAddress(wallet.publicKey, prefix);
+          break;
+        default:
+          prefix = __privateGet(this, _paraCoreInterface).cosmosPrefix;
+          str = wallet.address;
+          break;
+      }
+      return options.truncate ? truncateAddress(str, wallet.type, { prefix, targetLength: options.targetLength }) : str;
+    };
+    this.getIdenticonHash = (walletId, overrideType) => {
+      if (__privateGet(this, _externalWalletService).externalWallets[walletId]) {
+        const wallet2 = __privateGet(this, _externalWalletService).externalWallets[walletId];
+        return `${wallet2.id}-${wallet2.address}-${wallet2.type}`;
+      }
+      const wallet = this.findWallet(walletId, overrideType);
+      return wallet ? `${wallet.id}-${wallet.address}-${wallet.type}` : void 0;
+    };
+    this.isWalletSupported = (wallet) => {
+      var _a, _b;
+      return !((_a = __privateGet(this, _paraCoreInterface).partner) == null ? void 0 : _a.supportedWalletTypes) || isWalletSupported((_b = __privateGet(this, _paraCoreInterface).partner.supportedWalletTypes.map(({ type }) => type)) != null ? _b : [], wallet);
+    };
+    this.isWalletOwned = (wallet) => {
+      return this.isWalletSupported(wallet) && !(wallet == null ? void 0 : wallet.pregenIdentifier) && !(wallet == null ? void 0 : wallet.pregenIdentifierType) && !!__privateGet(this, _authService).userId && (wallet == null ? void 0 : wallet.userId) === __privateGet(this, _authService).userId;
+    };
+    this.isWalletUsable = (walletId, { type: types, scheme: schemes, forbidPregen = false } = {}, throwError = false) => {
+      var _a, _b;
+      let error;
+      if ((_a = __privateGet(this, _externalWalletService).externalWallets) == null ? void 0 : _a[walletId]) {
+        return true;
+      }
+      if (!this.wallets[walletId]) {
+        error = `wallet with id ${walletId} does not exist`;
+      } else {
+        const wallet = this.wallets[walletId];
+        const [isUnclaimed, isOwned] = [__privateGet(this, _pregenWalletService).isPregenWalletUnclaimed(wallet), this.isWalletOwned(wallet)];
+        if (forbidPregen && isUnclaimed && wallet.pregenIdentifierType !== "GUEST_ID") {
+          error = `pre-generated wallet with id ${wallet == null ? void 0 : wallet.id} cannot be selected`;
+        } else if (!isOwned && !isUnclaimed) {
+          error = `wallet with id ${wallet == null ? void 0 : wallet.id} is not owned by the current user`;
+        } else if (!this.isWalletSupported(wallet)) {
+          error = `wallet with id ${wallet.id} and type ${wallet.type} is not supported, supported types are: ${(((_b = __privateGet(this, _paraCoreInterface).partner) == null ? void 0 : _b.supportedWalletTypes) || []).map(({ type }) => type).join(", ")}`;
+        } else if (types && (!getEquivalentTypes(types).includes(wallet == null ? void 0 : wallet.type) || isOwned && !types.some((type) => {
+          var _a2, _b2;
+          return (_b2 = (_a2 = this.currentWalletIds) == null ? void 0 : _a2[type]) == null ? void 0 : _b2.includes(walletId);
+        }))) {
+          error = `wallet with id ${wallet == null ? void 0 : wallet.id} and type ${wallet == null ? void 0 : wallet.type} cannot be selected`;
+        } else if (schemes && !schemes.includes(wallet == null ? void 0 : wallet.scheme)) {
+          error = `wallet with id ${wallet == null ? void 0 : wallet.id} and scheme ${wallet == null ? void 0 : wallet.scheme} cannot be selected`;
+        }
+      }
+      if (error) {
+        if (throwError) {
+          throw new Error(error);
+        }
+        return false;
+      }
+      return true;
+    };
+    this.getWalletsByType = (type) => {
+      return Object.values(this.wallets).filter((w) => this.isWalletUsable(w.id, { type: [type] }));
+    };
+    this.assertIsValidWalletId = (walletId, condition = {}) => {
+      this.isWalletUsable(walletId, condition, true);
+    };
+    this.assertIsValidWalletType = (type, walletTypes) => __async(this, null, function* () {
+      const { supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
+      if (!type || !WALLET_TYPES.includes(type) || !(walletTypes != null ? walletTypes : supportedWalletTypes.map(({ type: type2 }) => type2)).includes(type)) {
+        throw new Error(`wallet type ${type} is not supported`);
+      }
+      return type;
+    });
+    this.fetchWallets = () => __async(this, null, function* () {
+      const res = yield __privateGet(this, _paraCoreInterface).isPortal() || __privateGet(this, _paraCoreInterface).isParaConnect() ? __privateGet(this, _paraCoreInterface).ctx.client.getAllWallets(__privateGet(this, _authService).userId) : __privateGet(this, _paraCoreInterface).ctx.client.getWallets(__privateGet(this, _authService).userId, true);
+      return res.data.wallets.filter(
+        (wallet) => !!wallet.address && wallet.sharesPersisted && (__privateGet(this, _paraCoreInterface).isParaConnect() || !__privateGet(this, _paraCoreInterface).isParaConnect() && this.isWalletSupported(entityToWallet(wallet)))
+      );
+    });
+    this.getWalletBalance = (_0) => __async(this, [_0], function* ({ walletId, rpcUrl }) {
+      return (yield __privateGet(this, _paraCoreInterface).ctx.client.getWalletBalance({ walletId, rpcUrl })).balance;
+    });
+    __privateAdd(this, _encodeWalletBase64, (wallet) => {
+      const walletJson = JSON.stringify(wallet);
+      const base64Wallet = Buffer.from(walletJson).toString("base64");
+      return base64Wallet;
+    });
+    this.getUserShare = () => {
+      if (Object.values(this.wallets).length === 0) {
+        return null;
+      }
+      return Object.values(this.wallets).map((wallet) => __privateGet(this, _encodeWalletBase64).call(this, wallet)).join("-");
+    };
+    this.setUserShare = (base64Wallets) => __async(this, null, function* () {
+      if (!base64Wallets) {
+        return;
+      }
+      const base64WalletsSplit = base64Wallets.split("-");
+      for (const base64Wallet of base64WalletsSplit) {
+        const walletJson = Buffer.from(base64Wallet, "base64").toString();
+        const wallet = migrateWallet(JSON.parse(walletJson));
+        this.wallets[wallet.id] = wallet;
+        yield this.setWallets(this.wallets);
+      }
+    });
+    this.distributeNewWalletShare = (_0) => __async(this, [_0], function* ({
+      walletId,
+      userShare,
+      skipBiometricShareCreation = false,
+      forceRefresh = false
+    }) {
+      let userSigner = userShare;
+      if (!userSigner) {
+        userSigner = this.wallets[walletId].signer;
+      }
+      const recoveryShare = skipBiometricShareCreation ? yield sendRecoveryForShare({
+        ctx: __privateGet(this, _paraCoreInterface).ctx,
+        userId: __privateGet(this, _authService).userId,
+        walletId,
+        userSigner,
+        emailProps: __privateGet(this, _paraCoreInterface).getBackupKitEmailProps(),
+        forceRefresh
+      }) : yield distributeNewShare({
+        ctx: __privateGet(this, _paraCoreInterface).ctx,
+        userId: __privateGet(this, _authService).userId,
+        walletId,
+        userShare: userSigner,
+        emailProps: __privateGet(this, _paraCoreInterface).getBackupKitEmailProps(),
+        isEnclaveUser: __privateGet(this, _authService).isEnclaveUser,
+        walletScheme: this.wallets[walletId].scheme
+      });
+      return recoveryShare;
+    });
+    __privateSet(this, _paraCoreInterface, paraCore.getWalletServiceInterface());
+    this.wallets = {};
+  }
+  get wallets() {
+    return __privateGet(this, _wallets);
+  }
+  set wallets(value) {
+    __privateSet(this, _wallets, value);
+  }
+  get currentWalletIds() {
+    return __privateGet(this, _currentWalletIds);
+  }
+  set currentWalletIds(value) {
+    __privateSet(this, _currentWalletIds, value);
+  }
+  get currentWalletIdsArray() {
+    var _a, _b;
+    return ((_b = (_a = __privateGet(this, _paraCoreInterface).partner) == null ? void 0 : _a.supportedWalletTypes) != null ? _b : Object.keys(this.currentWalletIds).map((type) => ({ type }))).reduce((acc, { type }) => {
+      var _a2;
+      return [
+        ...acc,
+        ...((_a2 = this.currentWalletIds[type]) != null ? _a2 : []).map((id) => {
+          return [id, type];
+        })
+      ];
+    }, []);
+  }
+  get currentWalletIdsUnique() {
+    return [...new Set(Object.values(this.currentWalletIds).flat())];
+  }
+  get isWalletTypeEnabled() {
+    var _a;
+    return (((_a = __privateGet(this, _paraCoreInterface).partner) == null ? void 0 : _a.supportedWalletTypes) || []).reduce((acc, { type }) => {
+      return __spreadProps(__spreadValues({}, acc), { [type]: true });
+    }, {});
+  }
+  get availableWallets() {
+    var _a;
+    return [
+      ...[...this.currentWalletIdsArray, ...__privateGet(this, _pregenWalletService).guestWalletIdsArray].map(([address, type]) => [address, type, false]).map(([id, type]) => {
+        const wallet = this.findWallet(id, type);
+        if (!wallet) return null;
+        const name = wallet.name;
+        const address = this.getDisplayAddress(id, { addressType: type });
+        const addressShort = this.getDisplayAddress(id, { addressType: type, truncate: true });
+        return {
+          id: wallet.id,
+          partner: wallet.partner,
+          type,
+          address,
+          name,
+          addressShort,
+          displayName: name != null ? name : addressShort,
+          ensName: wallet.ensName,
+          ensAvatar: wallet.ensAvatar
+        };
+      }).filter((obj) => obj !== null),
+      ...Object.values((_a = __privateGet(this, _externalWalletService).externalWallets) != null ? _a : {}).map((wallet) => {
+        return __spreadProps(__spreadValues({}, wallet), {
+          addressShort: truncateAddress(wallet.address, wallet.type, { prefix: __privateGet(this, _paraCoreInterface).cosmosPrefix }),
+          displayName: wallet.externalProviderId
+        });
+      })
+    ];
+  }
+}
+_authService = new WeakMap();
+_pollingService = new WeakMap();
+_pregenWalletService = new WeakMap();
+_externalWalletService = new WeakMap();
+_paraCoreInterface = new WeakMap();
+_wallets = new WeakMap();
+_currentWalletIds = new WeakMap();
+_isWalletOwned = new WeakMap();
+_getMissingTypes = new WeakMap();
+_encodeWalletBase64 = new WeakMap();
+export {
+  WalletService
+};