@getpara/core-sdk 2.0.0-alpha.7 → 2.0.0-alpha.70

package/dist/cjs/constants.js

@@ -17,12 +17,15 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var constants_exports = {};
 __export(constants_exports, {
+  ACCOUNT_LINK_CONFLICT: () => ACCOUNT_LINK_CONFLICT,
   EXTERNAL_WALLET_CONNECTION_ONLY_USER_ID: () => EXTERNAL_WALLET_CONNECTION_ONLY_USER_ID,
   LOCAL_STORAGE_AUTH_INFO: () => LOCAL_STORAGE_AUTH_INFO,
   LOCAL_STORAGE_COUNTRY_CODE: () => LOCAL_STORAGE_COUNTRY_CODE,
   LOCAL_STORAGE_CURRENT_WALLET_IDS: () => LOCAL_STORAGE_CURRENT_WALLET_IDS,
   LOCAL_STORAGE_ED25519_WALLETS: () => LOCAL_STORAGE_ED25519_WALLETS,
   LOCAL_STORAGE_EMAIL: () => LOCAL_STORAGE_EMAIL,
+  LOCAL_STORAGE_ENCLAVE_JWT: () => LOCAL_STORAGE_ENCLAVE_JWT,
+  LOCAL_STORAGE_ENCLAVE_REFRESH_JWT: () => LOCAL_STORAGE_ENCLAVE_REFRESH_JWT,
   LOCAL_STORAGE_EXTERNAL_WALLETS: () => LOCAL_STORAGE_EXTERNAL_WALLETS,
   LOCAL_STORAGE_EXTERNAL_WALLET_USER_ID: () => LOCAL_STORAGE_EXTERNAL_WALLET_USER_ID,
   LOCAL_STORAGE_FARCASTER_USERNAME: () => LOCAL_STORAGE_FARCASTER_USERNAME,
@@ -32,6 +35,7 @@ __export(constants_exports, {
   LOCAL_STORAGE_USER_ID: () => LOCAL_STORAGE_USER_ID,
   LOCAL_STORAGE_WALLETS: () => LOCAL_STORAGE_WALLETS,
   PARA_CORE_VERSION: () => PARA_CORE_VERSION,
+  PARA_PREFIX: () => PARA_PREFIX,
   POLLING_INTERVAL_MS: () => POLLING_INTERVAL_MS,
   POLLING_TIMEOUT_MS: () => POLLING_TIMEOUT_MS,
   PREFIX: () => PREFIX,
@@ -39,8 +43,9 @@ __export(constants_exports, {
   SHORT_POLLING_INTERVAL_MS: () => SHORT_POLLING_INTERVAL_MS
 });
 module.exports = __toCommonJS(constants_exports);
-const PARA_CORE_VERSION = "2.0.0-alpha.6";
+const PARA_CORE_VERSION = "2.0.0-alpha.70";
 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`;
@@ -54,19 +59,25 @@ 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";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  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,
@@ -76,6 +87,7 @@ const EXTERNAL_WALLET_CONNECTION_ONLY_USER_ID = "EXTERNAL_WALLET_CONNECTION_ONLY
   LOCAL_STORAGE_USER_ID,
   LOCAL_STORAGE_WALLETS,
   PARA_CORE_VERSION,
+  PARA_PREFIX,
   POLLING_INTERVAL_MS,
   POLLING_TIMEOUT_MS,
   PREFIX,

package/dist/cjs/index.js

@@ -28,23 +28,34 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
 __export(src_exports, {
+  AccountLinkError: () => import_types.AccountLinkError,
   AuthMethod: () => import_user_management_client.AuthMethod,
+  AuthMethodStatus: () => import_user_management_client.AuthMethodStatus,
+  COSMOS_WALLETS: () => import_user_management_client.COSMOS_WALLETS,
+  EVM_WALLETS: () => import_user_management_client.EVM_WALLETS,
+  EXTERNAL_WALLET_TYPES: () => import_user_management_client.EXTERNAL_WALLET_TYPES,
   EmailTheme: () => import_user_management_client.EmailTheme,
   KeyContainer: () => import_KeyContainer.KeyContainer,
+  LINKED_ACCOUNT_TYPES: () => import_user_management_client.LINKED_ACCOUNT_TYPES,
+  LOCAL_STORAGE_CURRENT_WALLET_IDS: () => import_constants.LOCAL_STORAGE_CURRENT_WALLET_IDS,
+  LOCAL_STORAGE_WALLETS: () => import_constants.LOCAL_STORAGE_WALLETS,
   NON_ED25519: () => import_user_management_client.NON_ED25519,
   Network: () => import_user_management_client.Network,
   OAUTH_METHODS: () => import_user_management_client.OAUTH_METHODS,
   OAuthMethod: () => import_user_management_client.OAuthMethod,
   OnRampAsset: () => import_user_management_client.OnRampAsset,
-  OnRampMethod: () => import_types.OnRampMethod,
+  OnRampMethod: () => import_user_management_client.OnRampMethod,
   OnRampProvider: () => import_user_management_client.OnRampProvider,
   OnRampPurchaseStatus: () => import_user_management_client.OnRampPurchaseStatus,
   OnRampPurchaseType: () => import_user_management_client.OnRampPurchaseType,
+  PARA_STORAGE_PREFIX: () => import_constants.PARA_PREFIX,
   PREGEN_IDENTIFIER_TYPES: () => import_user_management_client.PREGEN_IDENTIFIER_TYPES,
   PopupType: () => import_types.PopupType,
   PregenIdentifierType: () => import_types.PregenIdentifierType,
-  RecoveryStatus: () => import_types.RecoveryStatus,
+  RecoveryStatus: () => import_user_management_client.RecoveryStatus,
+  SOLANA_WALLETS: () => import_user_management_client.SOLANA_WALLETS,
   STORAGE_PREFIX: () => import_constants.PREFIX,
+  ThemeMode: () => import_user_management_client.ThemeMode,
   WALLET_SCHEMES: () => import_user_management_client.WALLET_SCHEMES,
   WALLET_TYPES: () => import_user_management_client.WALLET_TYPES,
   WalletScheme: () => import_user_management_client.WalletScheme,
@@ -56,12 +67,15 @@ __export(src_exports, {
   decryptWithKeyPair: () => import_utils2.decryptWithKeyPair,
   decryptWithPrivateKey: () => import_utils2.decryptWithPrivateKey,
   default: () => src_default,
+  dispatchEvent: () => import_utils.dispatchEvent,
   distributeNewShare: () => import_shareDistribution.distributeNewShare,
   encodePrivateKeyToPemHex: () => import_utils2.encodePrivateKeyToPemHex,
   encryptPrivateKey: () => import_utils2.encryptPrivateKey,
   encryptPrivateKeyWithPassword: () => import_utils2.encryptPrivateKeyWithPassword,
   encryptWithDerivedPublicKey: () => import_utils2.encryptWithDerivedPublicKey,
   entityToWallet: () => import_utils.entityToWallet,
+  formatAssetQuantity: () => import_user_management_client.formatAssetQuantity,
+  formatCurrency: () => import_user_management_client.formatCurrency,
   getAsymmetricKeyPair: () => import_utils2.getAsymmetricKeyPair,
   getBaseUrl: () => import_userManagementClient.getBaseUrl,
   getDerivedPrivateKeyAndDecrypt: () => import_utils2.getDerivedPrivateKeyAndDecrypt,
@@ -75,6 +89,7 @@ __export(src_exports, {
   getSHA256HashHex: () => import_utils2.getSHA256HashHex,
   hashPasswordWithSalt: () => import_utils2.hashPasswordWithSalt,
   initClient: () => import_userManagementClient.initClient,
+  isPortal: () => import_utils.isPortal,
   isWalletSupported: () => import_wallet.isWalletSupported,
   mpcComputationClient: () => mpcComputationClient,
   paraVersion: () => paraVersion,
@@ -102,6 +117,7 @@ __reExport(src_exports, require("./errors.js"), module.exports);
 __reExport(src_exports, require("./utils/formatting.js"), module.exports);
 __reExport(src_exports, require("./utils/polling.js"), module.exports);
 __reExport(src_exports, require("./utils/phone.js"), module.exports);
+__reExport(src_exports, require("./utils/config.js"), module.exports);
 var import_wallet = require("./utils/wallet.js");
 var import_onRamps = require("./utils/onRamps.js");
 var import_url = require("./utils/url.js");
@@ -110,9 +126,17 @@ const paraVersion = import_ParaCore.ParaCore.version;
 var src_default = import_ParaCore.ParaCore;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  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,
@@ -122,11 +146,14 @@ var src_default = import_ParaCore.ParaCore;
   OnRampProvider,
   OnRampPurchaseStatus,
   OnRampPurchaseType,
+  PARA_STORAGE_PREFIX,
   PREGEN_IDENTIFIER_TYPES,
   PopupType,
   PregenIdentifierType,
   RecoveryStatus,
+  SOLANA_WALLETS,
   STORAGE_PREFIX,
+  ThemeMode,
   WALLET_SCHEMES,
   WALLET_TYPES,
   WalletScheme,
@@ -137,12 +164,15 @@ var src_default = import_ParaCore.ParaCore;
   decryptPrivateKeyWithPassword,
   decryptWithKeyPair,
   decryptWithPrivateKey,
+  dispatchEvent,
   distributeNewShare,
   encodePrivateKeyToPemHex,
   encryptPrivateKey,
   encryptPrivateKeyWithPassword,
   encryptWithDerivedPublicKey,
   entityToWallet,
+  formatAssetQuantity,
+  formatCurrency,
   getAsymmetricKeyPair,
   getBaseUrl,
   getDerivedPrivateKeyAndDecrypt,
@@ -156,6 +186,7 @@ var src_default = import_ParaCore.ParaCore;
   getSHA256HashHex,
   hashPasswordWithSalt,
   initClient,
+  isPortal,
   isWalletSupported,
   mpcComputationClient,
   paraVersion,
@@ -170,5 +201,6 @@ var src_default = import_ParaCore.ParaCore;
   ...require("./errors.js"),
   ...require("./utils/formatting.js"),
   ...require("./utils/polling.js"),
-  ...require("./utils/phone.js")
+  ...require("./utils/phone.js"),
+  ...require("./utils/config.js")
 });

package/dist/cjs/shares/KeyContainer.js

@@ -61,7 +61,7 @@ class KeyContainer {
       const pubkey = this.getPublicEncryptionKey();
       const data = (0, import_ecies.Encrypt)(pubkey, Buffer.from(backup, "ucs2")).toString("base64");
       return data;
-    } catch (error) {
+    } catch (e) {
       throw Error("Error encrypting backup");
     }
   }
@@ -69,7 +69,7 @@ class KeyContainer {
     try {
       const data = (0, import_ecies.Encrypt)(publicKey, Buffer.from(backup, "ucs2")).toString("base64");
       return data;
-    } catch (error) {
+    } catch (e) {
       throw Error("Error encrypting backup");
     }
   }
@@ -78,7 +78,7 @@ class KeyContainer {
       const buf = Buffer.from(encryptedBackup, "base64");
       const data = (0, import_ecies.Decrypt)(Buffer.from(this.backupDecryptionKey, "hex"), buf);
       return Buffer.from(data.buffer).toString("ucs2");
-    } catch (error) {
+    } catch (e) {
       throw Error("Error decrypting backup");
     }
   }

package/dist/cjs/shares/enclave.js

@@ -0,0 +1,266 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __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 enclave_exports = {};
+__export(enclave_exports, {
+  EnclaveClient: () => EnclaveClient
+});
+module.exports = __toCommonJS(enclave_exports);
+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;
+    });
+  }
+  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);
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnclaveClient
+});

package/dist/cjs/shares/shareDistribution.js

@@ -52,8 +52,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/cjs/transmission/transmissionUtils.js

@@ -54,15 +54,16 @@ module.exports = __toCommonJS(transmissionUtils_exports);
 var import_ecies = require("@celo/utils/lib/ecies.js");
 var import_buffer = require("buffer");
 var eutil = __toESM(require("@ethereumjs/util"));
-var import_crypto = require("crypto");
 function upload(message, userManagementClient) {
   return __async(this, null, function* () {
     let secret;
     let publicKeyUint8Array;
     while (true) {
       try {
-        secret = (0, import_crypto.randomBytes)(32).toString("hex");
-        publicKeyUint8Array = eutil.privateToPublic(import_buffer.Buffer.from(secret, "hex"));
+        const privateKeyUint8Array = new Uint8Array(32);
+        crypto.getRandomValues(privateKeyUint8Array);
+        secret = import_buffer.Buffer.from(privateKeyUint8Array).toString("hex");
+        publicKeyUint8Array = eutil.privateToPublic(privateKeyUint8Array);
         break;
       } catch (e) {
         continue;

package/dist/cjs/types/{theme.js → assets.js}

@@ -11,5 +11,5 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var theme_exports = {};
-module.exports = __toCommonJS(theme_exports);
+var assets_exports = {};
+module.exports = __toCommonJS(assets_exports);

package/dist/cjs/types/{onRamps.js → auth.js}

@@ -15,19 +15,19 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var onRamps_exports = {};
-__export(onRamps_exports, {
-  OnRampMethod: () => OnRampMethod
+var auth_exports = {};
+__export(auth_exports, {
+  AccountLinkError: () => AccountLinkError
 });
-module.exports = __toCommonJS(onRamps_exports);
-var OnRampMethod = /* @__PURE__ */ ((OnRampMethod2) => {
-  OnRampMethod2["ACH"] = "ACH";
-  OnRampMethod2["DEBIT"] = "Debit";
-  OnRampMethod2["CREDIT"] = "Credit";
-  OnRampMethod2["APPLE_PAY"] = "Apple Pay";
-  return OnRampMethod2;
-})(OnRampMethod || {});
+module.exports = __toCommonJS(auth_exports);
+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 || {});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  OnRampMethod
+  AccountLinkError
 });

package/dist/cjs/types/coreApi.js

@@ -17,7 +17,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var coreApi_exports = {};
 __export(coreApi_exports, {
-  PARA_CORE_METHODS: () => PARA_CORE_METHODS
+  PARA_CORE_METHODS: () => PARA_CORE_METHODS,
+  PARA_INTERNAL_METHODS: () => PARA_INTERNAL_METHODS
 });
 module.exports = __toCommonJS(coreApi_exports);
 const PARA_CORE_METHODS = [
@@ -66,9 +67,28 @@ const PARA_CORE_METHODS = [
   "signMessage",
   "signTransaction",
   "initiateOnRampTransaction",
-  "getWalletBalance"
+  "getWalletBalance",
+  "issueJwt",
+  "getLinkedAccounts",
+  "accountLinkInProgress",
+  "addCredential",
+  "exportPrivateKey"
+];
+const PARA_INTERNAL_METHODS = [
+  "linkAccount",
+  "unlinkAccount",
+  "verifyEmailOrPhoneLink",
+  "verifyOAuthLink",
+  "verifyFarcasterLink",
+  "verifyTelegramLink",
+  "verifyExternalWalletLink",
+  "accountLinkInProgress",
+  "prepareLogin",
+  "sendLoginCode",
+  "supportedUserAuthMethods"
 ];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PARA_CORE_METHODS
+  PARA_CORE_METHODS,
+  PARA_INTERNAL_METHODS
 });

package/dist/cjs/types/events.js

@@ -33,6 +33,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 || {});
 // Annotate the CommonJS export names for ESM import in node: