@getpara/core-sdk 2.0.0-alpha.6 → 2.0.0-alpha.60

package/dist/esm/{chunk-7B52C2XE.js → chunk-W5CT3TVS.js}

@@ -7,6 +7,7 @@ var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
+var __pow = Math.pow;
 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 = {}))
@@ -59,6 +60,7 @@ var __async = (__this, __arguments, generator) => {
 };
 
 export {
+  __pow,
   __spreadValues,
   __spreadProps,
   __objRest,

package/dist/esm/constants.js

@@ -1,6 +1,7 @@
-import "./chunk-7B52C2XE.js";
-const PARA_CORE_VERSION = "2.0.0-alpha.6";
+import "./chunk-W5CT3TVS.js";
+const PARA_CORE_VERSION = "2.0.0-alpha.60";
 const PREFIX = "@CAPSULE/";
+const PARA_PREFIX = "@PARA/";
 const LOCAL_STORAGE_AUTH_INFO = `${PREFIX}authInfo`;
 const LOCAL_STORAGE_EMAIL = `${PREFIX}e-mail`;
 const LOCAL_STORAGE_PHONE = `${PREFIX}phone`;
@@ -14,18 +15,24 @@ const LOCAL_STORAGE_WALLETS = `${PREFIX}wallets`;
 const LOCAL_STORAGE_EXTERNAL_WALLETS = `${PREFIX}externalWallets`;
 const LOCAL_STORAGE_CURRENT_WALLET_IDS = `${PREFIX}currentWalletIds`;
 const LOCAL_STORAGE_SESSION_COOKIE = `${PREFIX}sessionCookie`;
+const LOCAL_STORAGE_ENCLAVE_JWT = `${PREFIX}enclaveJwt`;
+const LOCAL_STORAGE_ENCLAVE_REFRESH_JWT = `${PREFIX}enclaveRefreshJwt`;
 const SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR = `${PREFIX}loginEncryptionKeyPair`;
 const POLLING_INTERVAL_MS = 2e3;
 const SHORT_POLLING_INTERVAL_MS = 1e3;
 const POLLING_TIMEOUT_MS = 3e5;
 const EXTERNAL_WALLET_CONNECTION_ONLY_USER_ID = "EXTERNAL_WALLET_CONNECTION_ONLY";
+const ACCOUNT_LINK_CONFLICT = "Account already linked";
 export {
+  ACCOUNT_LINK_CONFLICT,
   EXTERNAL_WALLET_CONNECTION_ONLY_USER_ID,
   LOCAL_STORAGE_AUTH_INFO,
   LOCAL_STORAGE_COUNTRY_CODE,
   LOCAL_STORAGE_CURRENT_WALLET_IDS,
   LOCAL_STORAGE_ED25519_WALLETS,
   LOCAL_STORAGE_EMAIL,
+  LOCAL_STORAGE_ENCLAVE_JWT,
+  LOCAL_STORAGE_ENCLAVE_REFRESH_JWT,
   LOCAL_STORAGE_EXTERNAL_WALLETS,
   LOCAL_STORAGE_EXTERNAL_WALLET_USER_ID,
   LOCAL_STORAGE_FARCASTER_USERNAME,
@@ -35,6 +42,7 @@ export {
   LOCAL_STORAGE_USER_ID,
   LOCAL_STORAGE_WALLETS,
   PARA_CORE_VERSION,
+  PARA_PREFIX,
   POLLING_INTERVAL_MS,
   POLLING_TIMEOUT_MS,
   PREFIX,

package/dist/esm/cryptography/utils.js

@@ -1,6 +1,6 @@
 import {
   __async
-} from "../chunk-7B52C2XE.js";
+} from "../chunk-W5CT3TVS.js";
 import base64url from "base64url";
 import forge from "node-forge";
 import { getPortalBaseURL } from "../utils/index.js";

package/dist/esm/errors.js

@@ -1,4 +1,4 @@
-import "./chunk-7B52C2XE.js";
+import "./chunk-W5CT3TVS.js";
 class TransactionReviewError extends Error {
   constructor(transactionReviewUrl) {
     super("transaction review error");

package/dist/esm/external/mpcComputationClient.js

@@ -1,4 +1,4 @@
-import "../chunk-7B52C2XE.js";
+import "../chunk-W5CT3TVS.js";
 import axios from "axios";
 function initClient(baseURL, useAdapter) {
   const client = axios.create({ baseURL });

package/dist/esm/external/userManagementClient.js

@@ -1,4 +1,4 @@
-import "../chunk-7B52C2XE.js";
+import "../chunk-W5CT3TVS.js";
 import Client from "@getpara/user-management-client";
 import { Environment } from "../types/index.js";
 function getBaseOAuthUrl(env) {

package/dist/esm/index.js

@@ -1,30 +1,41 @@
-import "./chunk-7B52C2XE.js";
+import "./chunk-W5CT3TVS.js";
 import { ParaCore } from "./ParaCore.js";
 import {
   AuthMethod,
+  AuthMethodStatus,
   EmailTheme,
   Network,
+  WalletType,
+  WalletScheme,
   OnRampAsset,
   OnRampPurchaseType,
   OnRampProvider,
   OnRampPurchaseStatus,
+  OnRampMethod,
+  OAuthMethod,
+  RecoveryStatus,
+  ThemeMode,
   NON_ED25519,
   PREGEN_IDENTIFIER_TYPES,
   WALLET_TYPES,
   WALLET_SCHEMES,
-  OAUTH_METHODS
+  OAUTH_METHODS,
+  LINKED_ACCOUNT_TYPES,
+  EXTERNAL_WALLET_TYPES,
+  EVM_WALLETS,
+  SOLANA_WALLETS,
+  COSMOS_WALLETS
 } from "@getpara/user-management-client";
 import {
-  OnRampMethod,
   PopupType,
   PregenIdentifierType,
-  RecoveryStatus
+  AccountLinkError
 } from "./types/index.js";
 export * from "./types/coreApi.js";
 export * from "./types/events.js";
 export * from "./types/config.js";
-import { getPortalDomain, entityToWallet, constructUrl, shortenUrl } from "./utils/index.js";
-import { PREFIX } from "./constants.js";
+import { getPortalDomain, dispatchEvent, entityToWallet, constructUrl, shortenUrl } from "./utils/index.js";
+import { PREFIX, PARA_PREFIX } from "./constants.js";
 import { distributeNewShare } from "./shares/shareDistribution.js";
 import { KeyContainer } from "./shares/KeyContainer.js";
 import { getBaseUrl, initClient } from "./external/userManagementClient.js";
@@ -52,6 +63,7 @@ export * from "./errors.js";
 export * from "./utils/formatting.js";
 export * from "./utils/polling.js";
 export * from "./utils/phone.js";
+export * from "./utils/config.js";
 import { isWalletSupported } from "./utils/wallet.js";
 import { getNetworkPrefix, getOnRampAssets, getOnRampNetworks, toAssetInfoArray } from "./utils/onRamps.js";
 import { getPortalBaseURL } from "./utils/url.js";
@@ -59,24 +71,36 @@ import { retrieve } from "./transmission/transmissionUtils.js";
 const paraVersion = ParaCore.version;
 var src_default = ParaCore;
 export {
+  AccountLinkError,
   AuthMethod,
+  AuthMethodStatus,
+  COSMOS_WALLETS,
+  EVM_WALLETS,
+  EXTERNAL_WALLET_TYPES,
   EmailTheme,
   KeyContainer,
+  LINKED_ACCOUNT_TYPES,
   NON_ED25519,
   Network,
   OAUTH_METHODS,
+  OAuthMethod,
   OnRampAsset,
   OnRampMethod,
   OnRampProvider,
   OnRampPurchaseStatus,
   OnRampPurchaseType,
+  PARA_PREFIX as PARA_STORAGE_PREFIX,
   PREGEN_IDENTIFIER_TYPES,
   PopupType,
   PregenIdentifierType,
   RecoveryStatus,
+  SOLANA_WALLETS,
   PREFIX as STORAGE_PREFIX,
+  ThemeMode,
   WALLET_SCHEMES,
   WALLET_TYPES,
+  WalletScheme,
+  WalletType,
   constructUrl,
   decryptPrivateKey,
   decryptPrivateKeyAndDecryptShare,
@@ -84,6 +108,7 @@ export {
   decryptWithKeyPair,
   decryptWithPrivateKey,
   src_default as default,
+  dispatchEvent,
   distributeNewShare,
   encodePrivateKeyToPemHex,
   encryptPrivateKey,

package/dist/esm/shares/KeyContainer.js

@@ -1,4 +1,4 @@
-import "../chunk-7B52C2XE.js";
+import "../chunk-W5CT3TVS.js";
 import { Encrypt as ECIESEncrypt, Decrypt as ECIESDecrypt } from "@celo/utils/lib/ecies.js";
 import * as eutil from "@ethereumjs/util";
 import * as forge from "node-forge";

package/dist/esm/shares/enclave.js

@@ -0,0 +1,226 @@
+import {
+  __async
+} from "../chunk-W5CT3TVS.js";
+class EnclaveClient {
+  constructor({
+    userManagementClient,
+    retrieveJwt,
+    persistJwt,
+    retrieveRefreshJwt,
+    persistRefreshJwt
+  }) {
+    this.enclavePublicKey = null;
+    this.frontendKeyPair = null;
+    this.userManagementClient = userManagementClient;
+    this.retrieveJwt = retrieveJwt;
+    this.persistJwt = persistJwt;
+    this.retrieveRefreshJwt = retrieveRefreshJwt;
+    this.persistRefreshJwt = persistRefreshJwt;
+  }
+  refreshJwt() {
+    return __async(this, null, function* () {
+      const frontendKeyPair = yield this.generateFrontendKeyPair();
+      const responsePublicKeyPEM = yield this.exportPublicKeyToPEM(frontendKeyPair.publicKey);
+      const payload = {
+        refreshJwt: this.retrieveRefreshJwt(),
+        responsePublicKey: responsePublicKeyPEM
+      };
+      const encryptedPayload = yield this.encryptForEnclave(JSON.stringify(payload));
+      const response = yield this.userManagementClient.refreshEnclaveJwt(JSON.stringify(encryptedPayload));
+      const decryptedResponse = yield this.decryptForFrontend(JSON.parse(response.payload));
+      this.persistJwt(decryptedResponse.jwt);
+      this.persistRefreshJwt(decryptedResponse.refreshJwt);
+    });
+  }
+  withJwtRefreshRetry(fn) {
+    return __async(this, null, function* () {
+      try {
+        return yield fn();
+      } catch (error) {
+        yield this.refreshJwt();
+        return yield fn();
+      }
+    });
+  }
+  issueEnclaveJwt() {
+    return __async(this, null, function* () {
+      const frontendKeyPair = yield this.generateFrontendKeyPair();
+      const responsePublicKeyPEM = yield this.exportPublicKeyToPEM(frontendKeyPair.publicKey);
+      const payload = {
+        responsePublicKey: responsePublicKeyPEM
+      };
+      const encryptedPayload = yield this.encryptForEnclave(JSON.stringify(payload));
+      const response = yield this.userManagementClient.issueEnclaveJwt(JSON.stringify(encryptedPayload));
+      const decryptedResponse = yield this.decryptForFrontend(JSON.parse(response));
+      this.persistJwt(decryptedResponse.jwt);
+    });
+  }
+  /**
+   * Generate a P-256 keypair for the frontend to receive encrypted responses
+   */
+  generateFrontendKeyPair() {
+    return __async(this, null, function* () {
+      if (this.frontendKeyPair) {
+        return this.frontendKeyPair;
+      }
+      this.frontendKeyPair = yield crypto.subtle.generateKey({ name: "ECDH", namedCurve: "P-256" }, true, ["deriveBits"]);
+      return this.frontendKeyPair;
+    });
+  }
+  /**
+   * Get the enclave's public key from the user-management service
+   */
+  getEnclavePublicKey() {
+    return __async(this, null, function* () {
+      if (this.enclavePublicKey) {
+        return this.enclavePublicKey;
+      }
+      const response = yield this.userManagementClient.getEnclavePublicKey();
+      this.enclavePublicKey = response.publicKey;
+      return this.enclavePublicKey;
+    });
+  }
+  /**
+   * Import a PEM-formatted public key for use with Web Crypto API
+   */
+  importPublicKeyFromPEM(pemString) {
+    return __async(this, null, function* () {
+      const pemContents = pemString.replace("-----BEGIN PUBLIC KEY-----", "").replace("-----END PUBLIC KEY-----", "").replace(/\s/g, "");
+      const keyData = Uint8Array.from(atob(pemContents), (c) => c.charCodeAt(0));
+      return yield crypto.subtle.importKey("spki", keyData, { name: "ECDH", namedCurve: "P-256" }, false, []);
+    });
+  }
+  /**
+   * Export a public key to PEM format
+   */
+  exportPublicKeyToPEM(publicKey) {
+    return __async(this, null, function* () {
+      const exported = yield crypto.subtle.exportKey("spki", publicKey);
+      const exportedAsBase64 = btoa(String.fromCharCode(...new Uint8Array(exported)));
+      return `-----BEGIN PUBLIC KEY-----
+${exportedAsBase64}
+-----END PUBLIC KEY-----`;
+    });
+  }
+  /**
+   * Encrypt data using P-256 ECIES for the enclave
+   */
+  encryptForEnclave(plaintext) {
+    return __async(this, null, function* () {
+      const enclavePublicKeyPEM = yield this.getEnclavePublicKey();
+      const enclavePublicKey = yield this.importPublicKeyFromPEM(enclavePublicKeyPEM);
+      const ephemeralKeyPair = yield crypto.subtle.generateKey({ name: "ECDH", namedCurve: "P-256" }, true, ["deriveBits"]);
+      const sharedSecretBits = yield crypto.subtle.deriveBits(
+        { name: "ECDH", public: enclavePublicKey },
+        ephemeralKeyPair.privateKey,
+        256
+        // 32 bytes = 256 bits
+      );
+      const encryptionKeyBuffer = yield crypto.subtle.digest("SHA-256", sharedSecretBits);
+      const encryptionKey = yield crypto.subtle.importKey("raw", encryptionKeyBuffer, { name: "AES-GCM" }, false, ["encrypt"]);
+      const iv = crypto.getRandomValues(new Uint8Array(12));
+      const encrypted = yield crypto.subtle.encrypt(
+        { name: "AES-GCM", iv },
+        encryptionKey,
+        new TextEncoder().encode(plaintext)
+      );
+      const encryptedArray = new Uint8Array(encrypted);
+      const combined = new Uint8Array(iv.length + encryptedArray.length);
+      combined.set(iv);
+      combined.set(encryptedArray, iv.length);
+      const ephemeralPublicKeyBuffer = yield crypto.subtle.exportKey("spki", ephemeralKeyPair.publicKey);
+      return {
+        encryptedData: btoa(String.fromCharCode(...combined)),
+        keyId: "",
+        // Will be set by the enclave
+        algorithm: "ECIES-P256-AES256-SHA256",
+        ephemeral: btoa(String.fromCharCode(...new Uint8Array(ephemeralPublicKeyBuffer)))
+      };
+    });
+  }
+  /**
+   * Decrypt response encrypted for the frontend
+   */
+  decryptForFrontend(encryptedPayload) {
+    return __async(this, null, function* () {
+      if (!this.frontendKeyPair) {
+        throw new Error("Frontend keypair not available");
+      }
+      const encryptedData = Uint8Array.from(atob(encryptedPayload.encryptedData), (c) => c.charCodeAt(0));
+      const ephemeralPublicKeyData = Uint8Array.from(atob(encryptedPayload.ephemeral), (c) => c.charCodeAt(0));
+      const ephemeralPublicKey = yield crypto.subtle.importKey(
+        "spki",
+        ephemeralPublicKeyData,
+        { name: "ECDH", namedCurve: "P-256" },
+        false,
+        []
+      );
+      const sharedSecretBits = yield crypto.subtle.deriveBits(
+        { name: "ECDH", public: ephemeralPublicKey },
+        this.frontendKeyPair.privateKey,
+        256
+      );
+      const encryptionKeyBuffer = yield crypto.subtle.digest("SHA-256", sharedSecretBits);
+      const encryptionKey = yield crypto.subtle.importKey("raw", encryptionKeyBuffer, { name: "AES-GCM" }, false, ["decrypt"]);
+      const iv = encryptedData.slice(0, 12);
+      const ciphertext = encryptedData.slice(12);
+      const decrypted = yield crypto.subtle.decrypt({ name: "AES-GCM", iv }, encryptionKey, ciphertext);
+      return JSON.parse(new TextDecoder().decode(decrypted));
+    });
+  }
+  /**
+   * Persist key shares to the enclave
+   * @param shares Array of share data to persist
+   */
+  persistShares(shares) {
+    return __async(this, null, function* () {
+      const payload = {
+        shares,
+        jwt: this.retrieveJwt()
+      };
+      const encryptedPayload = yield this.encryptForEnclave(JSON.stringify(payload));
+      const encryptedPayloadStr = JSON.stringify(encryptedPayload);
+      return yield this.userManagementClient.persistEnclaveShares(encryptedPayloadStr);
+    });
+  }
+  /**
+   * Retrieve key shares from the enclave
+   * @param query Query parameters for finding shares (single query or array of queries)
+   */
+  retrieveShares(query) {
+    return __async(this, null, function* () {
+      yield this.issueEnclaveJwt();
+      const frontendKeyPair = yield this.generateFrontendKeyPair();
+      const responsePublicKeyPEM = yield this.exportPublicKeyToPEM(frontendKeyPair.publicKey);
+      const fullQuery = query.map((q) => ({
+        userId: q.userId
+      }));
+      const payload = {
+        query: fullQuery,
+        responsePublicKey: responsePublicKeyPEM,
+        jwt: this.retrieveJwt()
+      };
+      const encryptedPayload = yield this.encryptForEnclave(JSON.stringify(payload));
+      const encryptedPayloadStr = JSON.stringify(encryptedPayload);
+      const response = yield this.userManagementClient.retrieveEnclaveShares(encryptedPayloadStr);
+      const encryptedResponse = JSON.parse(response.payload);
+      const decryptedData = yield this.decryptForFrontend(encryptedResponse);
+      return decryptedData.shares;
+    });
+  }
+  retrieveSharesWithRetry(query) {
+    return __async(this, null, function* () {
+      return yield this.withJwtRefreshRetry(() => __async(this, null, function* () {
+        return this.retrieveShares(query);
+      }));
+    });
+  }
+  persistSharesWithRetry(shares) {
+    return __async(this, null, function* () {
+      return yield this.persistShares(shares);
+    });
+  }
+}
+export {
+  EnclaveClient
+};

package/dist/esm/shares/recovery.js

@@ -1,7 +1,7 @@
 import {
   __async,
   __spreadValues
-} from "../chunk-7B52C2XE.js";
+} from "../chunk-W5CT3TVS.js";
 import { EncryptorType, KeyShareType } from "@getpara/user-management-client";
 import { KeyContainer } from "./KeyContainer.js";
 function sendRecoveryForShare(_0) {

package/dist/esm/shares/shareDistribution.js

@@ -1,6 +1,6 @@
 import {
   __async
-} from "../chunk-7B52C2XE.js";
+} from "../chunk-W5CT3TVS.js";
 import { EncryptorType, KeyShareType } from "@getpara/user-management-client";
 import { encryptWithDerivedPublicKey } from "../cryptography/utils.js";
 import { sendRecoveryForShare } from "./recovery.js";
@@ -13,8 +13,23 @@ function distributeNewShare(_0) {
     ignoreRedistributingBackupEncryptedShare = false,
     emailProps = {},
     partnerId,
-    protocolId
+    protocolId,
+    isEnclaveUser,
+    walletScheme
   }) {
+    if (isEnclaveUser) {
+      yield ctx.enclaveClient.persistSharesWithRetry([
+        {
+          userId,
+          walletId,
+          walletScheme,
+          signer: userShare,
+          partnerId,
+          protocolId
+        }
+      ]);
+      return "";
+    }
     const publicKeysRes = yield ctx.client.getSessionPublicKeys(userId);
     const biometricEncryptedShares = publicKeysRes.data.keys.map((key) => {
       if (!key.publicKey) {

package/dist/esm/transmission/transmissionUtils.js

@@ -1,6 +1,6 @@
 import {
   __async
-} from "../chunk-7B52C2XE.js";
+} from "../chunk-W5CT3TVS.js";
 import { Encrypt as ECIESEncrypt, Decrypt as ECIESDecrypt } from "@celo/utils/lib/ecies.js";
 import { Buffer } from "buffer";
 import * as eutil from "@ethereumjs/util";

package/dist/esm/types/auth.js

@@ -0,0 +1,11 @@
+import "../chunk-W5CT3TVS.js";
+var AccountLinkError = /* @__PURE__ */ ((AccountLinkError2) => {
+  AccountLinkError2["NotAuthenticated"] = "No user is currently authenticated";
+  AccountLinkError2["Conflict"] = "Account already linked";
+  AccountLinkError2["Canceled"] = "Account linking was canceled";
+  AccountLinkError2["Unknown"] = "An unknown error occurred";
+  return AccountLinkError2;
+})(AccountLinkError || {});
+export {
+  AccountLinkError
+};

package/dist/esm/types/config.js

@@ -1,4 +1,4 @@
-import "../chunk-7B52C2XE.js";
+import "../chunk-W5CT3TVS.js";
 var Environment = /* @__PURE__ */ ((Environment2) => {
   Environment2["DEV"] = "DEV";
   Environment2["SANDBOX"] = "SANDBOX";

package/dist/esm/types/coreApi.js

@@ -1,4 +1,4 @@
-import "../chunk-7B52C2XE.js";
+import "../chunk-W5CT3TVS.js";
 const PARA_CORE_METHODS = [
   "getAuthInfo",
   "signUpOrLogIn",
@@ -45,8 +45,24 @@ const PARA_CORE_METHODS = [
   "signMessage",
   "signTransaction",
   "initiateOnRampTransaction",
-  "getWalletBalance"
+  "getWalletBalance",
+  "issueJwt",
+  "getLinkedAccounts",
+  "accountLinkInProgress"
+];
+const PARA_INTERNAL_METHODS = [
+  "linkAccount",
+  "unlinkAccount",
+  "verifyEmailOrPhoneLink",
+  "verifyOAuthLink",
+  "verifyFarcasterLink",
+  "verifyTelegramLink",
+  "verifyExternalWalletLink",
+  "accountLinkInProgress",
+  "prepareLogin",
+  "sendLoginCode"
 ];
 export {
-  PARA_CORE_METHODS
+  PARA_CORE_METHODS,
+  PARA_INTERNAL_METHODS
 };

package/dist/esm/types/events.js

@@ -1,4 +1,4 @@
-import "../chunk-7B52C2XE.js";
+import "../chunk-W5CT3TVS.js";
 const EVENT_PREFIX = "para";
 var ParaEvent = ((ParaEvent2) => {
   ParaEvent2["LOGIN_EVENT"] = `${EVENT_PREFIX}Login`;
@@ -12,6 +12,8 @@ var ParaEvent = ((ParaEvent2) => {
   ParaEvent2["WALLET_CREATED"] = `${EVENT_PREFIX}WalletCreated`;
   ParaEvent2["PREGEN_WALLET_CLAIMED"] = `${EVENT_PREFIX}PregenWalletClaimed`;
   ParaEvent2["GUEST_WALLETS_CREATED"] = `${EVENT_PREFIX}GuestWalletsCreated`;
+  ParaEvent2["ASSET_TRANSFERRED"] = `${EVENT_PREFIX}AssetTransferred`;
+  ParaEvent2["ONRAMP_TRANSACTION_COMPLETE"] = `${EVENT_PREFIX}OnRampTransactionComplete`;
   return ParaEvent2;
 })(ParaEvent || {});
 export {

package/dist/esm/types/index.js

@@ -1,22 +1,7 @@
-import "../chunk-7B52C2XE.js";
+export * from "./auth.js";
 export * from "./config.js";
 export * from "./coreApi.js";
 export * from "./wallet.js";
 export * from "./methods.js";
-export * from "./theme.js";
-export * from "./onRamps.js";
 export * from "./popup.js";
-export * from "./recovery.js";
 export * from "./events.js";
-import {
-  Network,
-  OnRampAsset,
-  OnRampProvider,
-  OnRampPurchaseStatus
-} from "@getpara/user-management-client";
-export {
-  Network,
-  OnRampAsset,
-  OnRampProvider,
-  OnRampPurchaseStatus
-};

package/dist/esm/types/popup.js

@@ -1,4 +1,4 @@
-import "../chunk-7B52C2XE.js";
+import "../chunk-W5CT3TVS.js";
 var PopupType = /* @__PURE__ */ ((PopupType2) => {
   PopupType2["SIGN_TRANSACTION_REVIEW"] = "SIGN_TRANSACTION_REVIEW";
   PopupType2["SIGN_MESSAGE_REVIEW"] = "SIGN_MESSAGE_REVIEW";

package/dist/esm/types/wallet.js

@@ -1,4 +1,4 @@
-import "../chunk-7B52C2XE.js";
+import "../chunk-W5CT3TVS.js";
 var PregenIdentifierType = /* @__PURE__ */ ((PregenIdentifierType2) => {
   PregenIdentifierType2["EMAIL"] = "EMAIL";
   PregenIdentifierType2["PHONE"] = "PHONE";

package/dist/esm/utils/autobind.js

@@ -1,4 +1,4 @@
-import "../chunk-7B52C2XE.js";
+import "../chunk-W5CT3TVS.js";
 function autoBind(instance) {
   let proto = instance;
   while (proto && proto !== Object.prototype) {

package/dist/esm/utils/config.js

@@ -0,0 +1,86 @@
+import "../chunk-W5CT3TVS.js";
+import { NETWORKS } from "@getpara/user-management-client";
+function validateBalancesConfig(obj) {
+  if (!obj || typeof obj !== "object") {
+    return false;
+  }
+  if (!obj.displayType || obj.displayType !== "AGGREGATED" && obj.displayType !== "CUSTOM_ASSET") {
+    return false;
+  }
+  if (obj.displayType === "AGGREGATED") {
+    if (obj.excludeStandardAssets !== void 0 && typeof obj.excludeStandardAssets !== "boolean") {
+      return false;
+    }
+    if (obj.additionalAssets !== void 0) {
+      if (!Array.isArray(obj.additionalAssets)) {
+        return false;
+      }
+      for (const asset of obj.additionalAssets) {
+        if (!validateCustomAsset(asset)) {
+          return false;
+        }
+        const hasPriceUrl = typeof asset.priceUrl === "string" && asset.priceUrl.trim();
+        const hasPrice = asset.price && typeof asset.price === "object" && typeof asset.price.value === "number" && asset.price.value > 0 && typeof asset.price.currency === "string" && asset.price.currency.trim();
+        if (!hasPriceUrl && !hasPrice) {
+          return false;
+        }
+        if (hasPriceUrl && hasPrice) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  if (obj.displayType === "CUSTOM_ASSET") {
+    if (!obj.asset) {
+      return false;
+    }
+    if (!validateCustomAsset(obj.asset)) {
+      return false;
+    }
+    const hasPriceUrl = typeof obj.asset.priceUrl === "string" && obj.asset.priceUrl.trim();
+    const hasPrice = obj.asset.price && typeof obj.asset.price === "object" && typeof obj.asset.price.value === "number" && obj.asset.price.value > 0 && typeof obj.asset.price.currency === "string" && obj.asset.price.currency.trim();
+    if (hasPriceUrl && hasPrice) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+function validateCustomAsset(obj) {
+  if (!obj || typeof obj !== "object") {
+    return false;
+  }
+  if (typeof obj.name !== "string" || !obj.name.trim() || typeof obj.symbol !== "string" || !obj.symbol.trim()) {
+    return false;
+  }
+  if (!Array.isArray(obj.implementations) || obj.implementations.length === 0) {
+    return false;
+  }
+  for (const network of obj.implementations) {
+    if (!network || typeof network !== "object") {
+      return false;
+    }
+    if (typeof network.network === "string") {
+      if (!NETWORKS.includes(network.network)) {
+        return false;
+      }
+      if (typeof network.contractAddress !== "string" || !network.contractAddress.trim()) {
+        return false;
+      }
+    } else if (typeof network.network === "object") {
+      if (typeof network.network.name !== "string" || !network.network.name.trim() || typeof network.network.rpcUrl !== "string" || !network.network.rpcUrl.trim() || typeof network.network.evmChainId !== "string" || !network.network.evmChainId.trim()) {
+        return false;
+      }
+      if (network.contractAddress !== void 0 && (typeof network.contractAddress !== "string" || !network.contractAddress.trim())) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+export {
+  validateBalancesConfig
+};