@getpara/core-sdk 2.0.0-fc.2 → 2.0.0

package/dist/esm/constants.js

@@ -1,6 +1,7 @@
 import "./chunk-7B52C2XE.js";
-const PARA_CORE_VERSION = "2.0.0-fc.1";
+const PARA_CORE_VERSION = "2.0.0";
 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,6 +15,8 @@ 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;
@@ -28,6 +31,8 @@ export {
   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,
@@ -37,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/index.js

@@ -2,6 +2,7 @@ import "./chunk-7B52C2XE.js";
 import { ParaCore } from "./ParaCore.js";
 import {
   AuthMethod,
+  AuthMethodStatus,
   EmailTheme,
   Network,
   WalletType,
@@ -10,7 +11,10 @@ import {
   OnRampPurchaseType,
   OnRampProvider,
   OnRampPurchaseStatus,
+  OnRampMethod,
   OAuthMethod,
+  RecoveryStatus,
+  ThemeMode,
   NON_ED25519,
   PREGEN_IDENTIFIER_TYPES,
   WALLET_TYPES,
@@ -20,20 +24,25 @@ import {
   EXTERNAL_WALLET_TYPES,
   EVM_WALLETS,
   SOLANA_WALLETS,
-  COSMOS_WALLETS
+  COSMOS_WALLETS,
+  formatAssetQuantity,
+  formatCurrency
 } 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, isPortal } from "./utils/index.js";
+import {
+  PREFIX,
+  PARA_PREFIX,
+  LOCAL_STORAGE_CURRENT_WALLET_IDS,
+  LOCAL_STORAGE_WALLETS
+} from "./constants.js";
 import { distributeNewShare } from "./shares/shareDistribution.js";
 import { KeyContainer } from "./shares/KeyContainer.js";
 import { getBaseUrl, initClient } from "./external/userManagementClient.js";
@@ -61,6 +70,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";
@@ -70,12 +80,15 @@ var src_default = ParaCore;
 export {
   AccountLinkError,
   AuthMethod,
+  AuthMethodStatus,
   COSMOS_WALLETS,
   EVM_WALLETS,
   EXTERNAL_WALLET_TYPES,
   EmailTheme,
   KeyContainer,
   LINKED_ACCOUNT_TYPES,
+  LOCAL_STORAGE_CURRENT_WALLET_IDS,
+  LOCAL_STORAGE_WALLETS,
   NON_ED25519,
   Network,
   OAUTH_METHODS,
@@ -85,12 +98,14 @@ export {
   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,
@@ -102,12 +117,15 @@ export {
   decryptWithKeyPair,
   decryptWithPrivateKey,
   src_default as default,
+  dispatchEvent,
   distributeNewShare,
   encodePrivateKeyToPemHex,
   encryptPrivateKey,
   encryptPrivateKeyWithPassword,
   encryptWithDerivedPublicKey,
   entityToWallet,
+  formatAssetQuantity,
+  formatCurrency,
   getAsymmetricKeyPair,
   getBaseUrl,
   getDerivedPrivateKeyAndDecrypt,
@@ -121,6 +139,7 @@ export {
   getSHA256HashHex,
   hashPasswordWithSalt,
   initClient,
+  isPortal,
   isWalletSupported,
   mpcComputationClient,
   paraVersion,

package/dist/esm/shares/KeyContainer.js

@@ -30,7 +30,7 @@ class KeyContainer {
       const pubkey = this.getPublicEncryptionKey();
       const data = ECIESEncrypt(pubkey, Buffer.from(backup, "ucs2")).toString("base64");
       return data;
-    } catch (error) {
+    } catch (e) {
       throw Error("Error encrypting backup");
     }
   }
@@ -38,7 +38,7 @@ class KeyContainer {
     try {
       const data = ECIESEncrypt(publicKey, Buffer.from(backup, "ucs2")).toString("base64");
       return data;
-    } catch (error) {
+    } catch (e) {
       throw Error("Error encrypting backup");
     }
   }
@@ -47,7 +47,7 @@ class KeyContainer {
       const buf = Buffer.from(encryptedBackup, "base64");
       const data = ECIESDecrypt(Buffer.from(this.backupDecryptionKey, "hex"), buf);
       return Buffer.from(data.buffer).toString("ucs2");
-    } catch (error) {
+    } catch (e) {
       throw Error("Error decrypting backup");
     }
   }

package/dist/esm/shares/enclave.js

@@ -0,0 +1,247 @@
+import {
+  __async
+} from "../chunk-7B52C2XE.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 (e) {
+        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({ encryptedPayload: 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;
+    });
+  }
+  deleteShares() {
+    return __async(this, null, function* () {
+      yield this.issueEnclaveJwt();
+      const frontendKeyPair = yield this.generateFrontendKeyPair();
+      const responsePublicKeyPEM = yield this.exportPublicKeyToPEM(frontendKeyPair.publicKey);
+      const payload = {
+        responsePublicKey: responsePublicKeyPEM,
+        jwt: this.retrieveJwt()
+      };
+      const encryptedPayload = yield this.encryptForEnclave(JSON.stringify(payload));
+      const encryptedPayloadStr = JSON.stringify(encryptedPayload);
+      yield this.userManagementClient.deleteEnclaveShares(encryptedPayloadStr);
+    });
+  }
+  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);
+    });
+  }
+  deleteSharesWithRetry() {
+    return __async(this, null, function* () {
+      return yield this.withJwtRefreshRetry(() => __async(this, null, function* () {
+        return this.deleteShares();
+      }));
+    });
+  }
+}
+export {
+  EnclaveClient
+};

package/dist/esm/shares/shareDistribution.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

@@ -4,15 +4,16 @@ import {
 import { Encrypt as ECIESEncrypt, Decrypt as ECIESDecrypt } from "@celo/utils/lib/ecies.js";
 import { Buffer } from "buffer";
 import * as eutil from "@ethereumjs/util";
-import { randomBytes } from "crypto";
 function upload(message, userManagementClient) {
   return __async(this, null, function* () {
     let secret;
     let publicKeyUint8Array;
     while (true) {
       try {
-        secret = randomBytes(32).toString("hex");
-        publicKeyUint8Array = eutil.privateToPublic(Buffer.from(secret, "hex"));
+        const privateKeyUint8Array = new Uint8Array(32);
+        crypto.getRandomValues(privateKeyUint8Array);
+        secret = Buffer.from(privateKeyUint8Array).toString("hex");
+        publicKeyUint8Array = eutil.privateToPublic(privateKeyUint8Array);
         break;
       } catch (e) {
         continue;

package/dist/esm/types/coreApi.js

@@ -48,7 +48,9 @@ const PARA_CORE_METHODS = [
   "getWalletBalance",
   "issueJwt",
   "getLinkedAccounts",
-  "accountLinkInProgress"
+  "accountLinkInProgress",
+  "addCredential",
+  "exportPrivateKey"
 ];
 const PARA_INTERNAL_METHODS = [
   "linkAccount",
@@ -58,7 +60,10 @@ const PARA_INTERNAL_METHODS = [
   "verifyFarcasterLink",
   "verifyTelegramLink",
   "verifyExternalWalletLink",
-  "accountLinkInProgress"
+  "accountLinkInProgress",
+  "prepareLogin",
+  "sendLoginCode",
+  "supportedUserAuthMethods"
 ];
 export {
   PARA_CORE_METHODS,

package/dist/esm/types/events.js

@@ -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,23 +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

@@ -6,6 +6,7 @@ var PopupType = /* @__PURE__ */ ((PopupType2) => {
   PopupType2["CREATE_PASSKEY"] = "CREATE_PASSKEY";
   PopupType2["OAUTH"] = "OAUTH";
   PopupType2["ON_RAMP_TRANSACTION"] = "ON_RAMP_TRANSACTION";
+  PopupType2["EXPORT_PRIVATE_KEY"] = "EXPORT_PRIVATE_KEY";
   return PopupType2;
 })(PopupType || {});
 export {

package/dist/esm/utils/config.js

@@ -0,0 +1,86 @@
+import "../chunk-7B52C2XE.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
+};

package/dist/esm/utils/index.js

@@ -1,4 +1,5 @@
 export * from "./autobind.js";
+export * from "./config.js";
 export * from "./events.js";
 export * from "./formatting.js";
 export * from "./json.js";
@@ -9,3 +10,4 @@ export * from "./polling.js";
 export * from "./types.js";
 export * from "./url.js";
 export * from "./wallet.js";
+export * from "./window.js";

package/dist/esm/utils/onRamps.js

@@ -1,5 +1,4 @@
 import "../chunk-7B52C2XE.js";
-import { Network } from "@getpara/user-management-client";
 function toAssetInfoArray(data) {
   const result = [];
   Object.keys(data).forEach((walletType) => {
@@ -51,8 +50,8 @@ function getOnRampAssets(data, {
   ];
 }
 const NETWORK_PREFIXES = {
-  [Network.COSMOS]: "cosmos",
-  [Network.NOBLE]: "noble"
+  COSMOS: "cosmos",
+  NOBLE: "noble"
 };
 function getNetworkPrefix(network) {
   return NETWORK_PREFIXES[network];

package/dist/esm/utils/wallet.js

@@ -59,7 +59,10 @@ function getEquivalentTypes(types) {
   return getWalletTypes(getSchemes(Array.isArray(types) ? types : [types]));
 }
 function entityToWallet(w) {
+  var _a;
   return __spreadProps(__spreadValues({}, w), {
+    createdAt: typeof w.createdAt === "string" ? w.createdAt : w.createdAt.toISOString(),
+    lastUsedAt: typeof w.lastUsedAt === "string" ? w.lastUsedAt : (_a = w.lastUsedAt) == null ? void 0 : _a.toISOString(),
     scheme: w.scheme,
     type: w.type,
     pregenIdentifierType: w.pregenIdentifierType
@@ -88,8 +91,22 @@ function mergeCurrentWalletIds(original, additional) {
 function newUuid() {
   return uuid.v4();
 }
+function currentWalletIdsEq(a, b) {
+  if (!a && !b) return true;
+  if (!a || !b) return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  return aKeys.every((key) => {
+    var _a, _b;
+    const aIds = ((_a = a[key]) == null ? void 0 : _a.sort()) || [];
+    const bIds = ((_b = b[key]) == null ? void 0 : _b.sort()) || [];
+    return aIds.length === bIds.length && aIds.every((id, index) => id === bIds[index]);
+  });
+}
 export {
   WalletSchemeTypeMap,
+  currentWalletIdsEq,
   entityToWallet,
   getEquivalentTypes,
   getSchemes,