@getpara/core-sdk 2.0.0-fc.3 → 2.1.0

package/dist/esm/utils/url.js

@@ -3,31 +3,32 @@ import {
 } from "../chunk-7B52C2XE.js";
 import { upload } from "../transmission/transmissionUtils.js";
 import { Environment } from "../types/index.js";
-function getPortalDomain(env, isE2E) {
+function getPortalDomain(env, isE2E, isLegacy) {
   if (isE2E) {
     return `localhost`;
   }
+  const domainRoot = isLegacy ? "usecapsule" : "getpara";
   switch (env) {
     case Environment.DEV:
       return "localhost";
     case Environment.SANDBOX:
-      return "app.sandbox.usecapsule.com";
+      return `app.sandbox.${domainRoot}.com`;
     case Environment.BETA:
-      return "app.beta.usecapsule.com";
+      return `app.beta.${domainRoot}.com`;
     case Environment.PROD:
-      return "app.usecapsule.com";
+      return `app.${domainRoot}.com`;
     default:
       throw new Error(`env: ${env} not supported`);
   }
 }
-function getPortalBaseURL({ env, isE2E }, useLocalIp, isForWasm) {
+function getPortalBaseURL({ env, isE2E }, useLocalIp, isForWasm, isLegacy) {
   if (isE2E) {
     if (isForWasm) {
-      return `https://app.sandbox.usecapsule.com`;
+      return `https://app.sandbox.getpara.com`;
     }
     return `http://localhost:3003`;
   }
-  const domain = getPortalDomain(env);
+  const domain = getPortalDomain(env, false, isLegacy);
   if (env === Environment.DEV) {
     if (useLocalIp) {
       return `http://127.0.0.1:3003`;
@@ -71,11 +72,11 @@ function constructUrl({
   });
   return url.toString();
 }
-function shortenUrl(ctx, url) {
+function shortenUrl(ctx, url, isLegacy) {
   return __async(this, null, function* () {
     const compressedUrl = yield upload(url, ctx.client);
     return constructUrl({
-      base: getPortalBaseURL(ctx),
+      base: getPortalBaseURL(ctx, false, false, isLegacy),
       path: `/short/${compressedUrl}`
     });
   });

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,

package/dist/esm/utils/window.js

@@ -0,0 +1,16 @@
+import "../chunk-7B52C2XE.js";
+import { getPortalBaseURL } from "./url.js";
+function isPortal(ctx, env) {
+  var _a, _b;
+  if (typeof window === "undefined") return false;
+  const normalizedUrl = (_b = (_a = window.location) == null ? void 0 : _a.host) == null ? void 0 : _b.replace("usecapsule", "getpara");
+  const isOnPortalDomain = getPortalBaseURL(env ? { env } : ctx).includes(normalizedUrl);
+  if (!isOnPortalDomain) return false;
+  const isInIframe = window.parent !== window && !window.opener;
+  const isInPopup = window.opener && window.parent === window;
+  const isDirectAccess = window.parent === window && !window.opener;
+  return isInIframe || isInPopup || isDirectAccess;
+}
+export {
+  isPortal
+};

package/dist/types/ParaCore.d.ts

@@ -1,13 +1,16 @@
-import { AuthMethod, AuthExtras, CurrentWalletIds, EmailTheme, TWalletType, PregenIds, BiometricLocationHint, Auth, SupportedWalletTypes, AuthIdentifier, AuthType, ExternalWalletInfo, PrimaryAuthInfo, SessionInfo, PrimaryAuth, PrimaryAuthType, AccountMetadata, LinkedAccounts, VerifyLinkParams, VerifyExternalWalletParams, SupportedAccountLinks } from '@getpara/user-management-client';
+import { AuthMethod, AuthExtras, CurrentWalletIds, EmailTheme, PartnerEntity, TWalletType, PregenIds, BiometricLocationHint, Auth, SupportedWalletTypes, AuthIdentifier, AuthType, ExternalWalletInfo, ServerAuthStateLogin, ServerAuthStateSignup, PrimaryAuthInfo, SessionInfo, PrimaryAuth, PrimaryAuthType, AccountMetadata, LinkedAccounts, VerifyLinkParams, VerifyExternalWalletParams, SupportedAccountLinks, OnRampPurchase, BalancesConfig, Theme, ServerAuthStateDone } from '@getpara/user-management-client';
 import type { pki as pkiType } from 'node-forge';
-import { Ctx, Environment, Theme, WalletFilters, Wallet, PortalUrlOptions, ConstructorOpts, CoreAuthInfo, PortalUrlType, CoreMethodParams, CoreMethodResponse, NewCredentialUrlParams, LoginUrlParams, CoreInterface, ExternalWalletConnectionType, AccountLinkInProgress, InternalMethodParams, InternalMethodResponse } from './types/index.js';
+import { Ctx, Environment, WalletFilters, Wallet, PortalUrlOptions, ConstructorOpts, CoreAuthInfo, PortalUrlType, CoreMethodParams, CoreMethodResponse, NewCredentialUrlParams, LoginUrlParams, CoreInterface, ExternalWalletConnectionType, AccountLinkInProgress, InternalMethodParams, InternalMethodResponse, AvailableWallet } from './types/index.js';
 import { PlatformUtils } from './PlatformUtils.js';
 export declare abstract class ParaCore implements CoreInterface {
     #private;
+    popupWindow: Window | null;
     static version?: string;
     ctx: Ctx;
+    protected isSwitchingWallets: boolean;
     protected isNativePasskey: boolean;
     protected isPartnerOptional?: boolean;
+    protected setModalError(_error?: string): void;
     isReady: boolean;
     get authInfo(): CoreAuthInfo | undefined;
     get email(): AuthIdentifier<'email'> | undefined;
@@ -16,13 +19,18 @@ export declare abstract class ParaCore implements CoreInterface {
     get telegramUserId(): AuthIdentifier<'telegram'> | undefined;
     get externalWalletWithParaAuth(): Wallet | undefined;
     get externalWalletConnectionType(): ExternalWalletConnectionType;
+    protected partner?: PartnerEntity;
     userId?: string;
     accountLinkInProgress: AccountLinkInProgress | undefined;
     private sessionCookie?;
+    isEnclaveUser: boolean;
+    private enclaveJwt?;
+    private enclaveRefreshJwt?;
     private isAwaitingAccountCreation;
     private isAwaitingLogin;
     private isAwaitingFarcaster;
     private isAwaitingOAuth;
+    private isWorkerInitialized;
     get isEmail(): boolean;
     get isPhone(): boolean;
     get isFarcaster(): boolean;
@@ -30,6 +38,8 @@ export declare abstract class ParaCore implements CoreInterface {
     get isExternalWalletAuth(): boolean;
     get isExternalWalletWithVerification(): boolean;
     get partnerId(): string | undefined;
+    protected get partnerName(): string | undefined;
+    protected get partnerLogo(): string | undefined;
     /**
      * The IDs of the currently active wallets, for each supported wallet type. Any signer integrations will default to the first viable wallet ID in this dictionary.
      */
@@ -115,7 +125,7 @@ export declare abstract class ParaCore implements CoreInterface {
     portalPrimaryButtonTextColor?: string;
     /**
      * Theme to use for the portal
-     * @deprecated configure theming through the developer portal
+     * WARNING: This theme will override portal options set within the developer portal.
      */
     portalTheme?: Theme;
     /**
@@ -129,7 +139,12 @@ export declare abstract class ParaCore implements CoreInterface {
     get cosmosPrefix(): string | undefined;
     get supportedAccountLinks(): SupportedAccountLinks;
     get isWalletTypeEnabled(): Partial<Record<TWalletType, boolean>>;
-    private platformUtils;
+    protected onRampPopup: {
+        window: Window;
+        onRampPurchase: OnRampPurchase;
+    } | undefined;
+    protected platformUtils: PlatformUtils;
+    protected nonPersistedStorageKeys: string[];
     private localStorageGetItem;
     private localStorageSetItem;
     private localStorageRemoveItem;
@@ -138,6 +153,10 @@ export declare abstract class ParaCore implements CoreInterface {
     private sessionStorageRemoveItem;
     retrieveSessionCookie: () => string | undefined;
     persistSessionCookie: (cookie: string) => void;
+    retrieveEnclaveJwt: () => string;
+    persistEnclaveJwt: (jwt: string) => void;
+    retrieveEnclaveRefreshJwt: () => string;
+    persistEnclaveRefreshJwt: (jwt: string) => void;
     /**
      * Remove all local storage and prefixed session storage.
      * @param {'local' | 'session' | 'secure' | 'all'} type - Type of storage to clear. Defaults to 'all'.
@@ -145,7 +164,7 @@ export declare abstract class ParaCore implements CoreInterface {
     clearStorage: (type?: CoreMethodParams<"clearStorage">) => CoreMethodResponse<"clearStorage">;
     private convertBigInt;
     private convertEncryptionKeyPair;
-    private isPortal;
+    protected isPortal(envOverride?: Environment): boolean;
     private isParaConnect;
     private requireApiKey;
     private isWalletSupported;
@@ -153,6 +172,7 @@ export declare abstract class ParaCore implements CoreInterface {
     private isPregenWalletUnclaimed;
     private isPregenWalletClaimable;
     private isWalletUsable;
+    private truncateAddress;
     /**
      * Returns the formatted address for the desired wallet ID, depending on your app settings.
      * @param {string} walletId the ID of the wallet address to display.
@@ -179,24 +199,28 @@ export declare abstract class ParaCore implements CoreInterface {
     protected abstract getPlatformUtils(): PlatformUtils;
     abstract isPasskeySupported(): Promise<boolean>;
     protected constructPortalUrl(type: PortalUrlType, opts?: PortalUrlOptions): Promise<string>;
+    static resolveEnvironment(env: Environment | undefined, apiKey: string | undefined): Environment;
     /**
      * Constructs a new `ParaCore` instance.
-     * @param env - `Environment` to use.
+     * @param env - `Environment` to use. Optional if the apiKey contains an environment prefix (e.g., "prod_your_api_key"). Updated API keys can be found at https://developer.getpara.com.
      * @param apiKey - API key to use.
      * @param opts - Additional constructor options; see `ConstructorOpts`.
      * @returns - A new ParaCore instance.
      */
-    constructor(env: Environment, apiKey: string, opts?: ConstructorOpts);
+    constructor(env: Environment | undefined, apiKey: string, opts?: ConstructorOpts);
+    constructor(apiKey: string, opts?: ConstructorOpts);
     private trackError;
     private wrapMethodsWithErrorTracking;
     private initializeFromStorage;
     private updateAuthInfoFromStorage;
+    private updateEnclaveJwtFromStorage;
     private updateUserIdFromStorage;
     private updateWalletsFromStorage;
     private updateWalletIdsFromStorage;
     private updateSessionCookieFromStorage;
     private updateLoginEncryptionKeyPairFromStorage;
     private updateExternalWalletsFromStorage;
+    protected initializeWorker: () => Promise<void>;
     touchSession(regenerate?: boolean): Promise<SessionInfo>;
     private getVerificationEmailProps;
     private getBackupKitEmailProps;
@@ -206,12 +230,29 @@ export declare abstract class ParaCore implements CoreInterface {
      * Init only needs to be called for storage that is async.
      */
     init(): Promise<void>;
-    protected abstract ready(): Promise<void>;
+    /**
+     * Call this method to perform initial setup for the `ParaCore` instance.
+     *
+     * This method will be called automatically if you use the React `ParaProvider` or when you call any methods that request an updated session.
+     */
+    abstract ready(): Promise<void>;
     protected setAuth(auth: PrimaryAuth, { extras, userId }?: {
         extras?: AuthExtras;
         userId?: string;
     }): Promise<typeof this.authInfo>;
-    protected assertUserId(): string;
+    /**
+     * Display an error message in the modal (if available)
+     * @internal
+     */
+    protected displayModalError(error?: string): void;
+    /**
+     * Handle specific touchSession errors with user-friendly messages
+     * @private
+     */
+    private handleTouchSessionError;
+    protected assertUserId({ allowGuestMode }?: {
+        allowGuestMode?: boolean;
+    }): string;
     protected assertIsAuthSet(allowed?: AuthType[]): PrimaryAuthInfo;
     /**
      * Sets the email associated with the `ParaCore` instance.
@@ -240,6 +281,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param externalType - Type of external wallet to set.
      */
     setExternalWallet(externalWallet: ExternalWalletInfo[] | ExternalWalletInfo): Promise<void>;
+    protected addExternalWallets(externalWallets: ExternalWalletInfo[]): Promise<void>;
     /**
      * Sets the user id associated with the `ParaCore` instance.
      * @param userId - User id to set.
@@ -252,9 +294,9 @@ export declare abstract class ParaCore implements CoreInterface {
     setWallets(wallets: Record<string, Wallet>): Promise<void>;
     /**
      * Sets the external wallets associated with the `ParaCore` instance.
-     * @param externalWallets - External wallets to set.
+     * @param externalWallets - External wallets to set, or a function that modifies the current wallets.
      */
-    setExternalWallets(externalWallets: Record<string, Wallet>): Promise<void>;
+    setExternalWallets(externalWallets: Record<string, Wallet> | ((current: Record<string, Wallet>) => Record<string, Wallet>)): Promise<void>;
     /**
      * Sets the login encryption key pair associated with the `ParaCore` instance.
      * @param keyPair - Encryption key pair generated from loginEncryptionKey.
@@ -311,7 +353,7 @@ export declare abstract class ParaCore implements CoreInterface {
      */
     findWalletByAddress(address: string, filter?: WalletFilters | undefined): any;
     findWallet(idOrAddress?: string, overrideType?: TWalletType, filter?: WalletFilters): Omit<Wallet, 'signer'> | undefined;
-    get availableWallets(): Pick<Wallet, 'id' | 'type' | 'name' | 'address' | 'isExternal' | 'externalProviderId' | 'isExternalConnectionOnly'>[];
+    get availableWallets(): AvailableWallet[];
     /**
      * Retrieves all usable wallets with the provided type (`'EVM' | 'COSMOS' | 'SOLANA'`)
      * @param {string} type the wallet type to filter by.
@@ -328,7 +370,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param partnerId: string - id of the partner to get the portal URL for
      * @returns - portal URL
      */
-    protected getPortalURL(): Promise<string>;
+    protected getPortalURL(isLegacy?: boolean): Promise<string>;
     /**
      * Gets the private key for the given wallet.
      * @param {string } [walletId] id of the wallet to get the private key for. Will default to the first wallet if not provided.
@@ -340,7 +382,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @returns {WalletEntity[]} wallets that were fetched.
      */
     fetchWallets(): CoreMethodResponse<'fetchWallets'>;
-    private populateWalletAddresses;
+    protected populateWalletAddresses(): Promise<void>;
     private populatePregenWalletAddresses;
     /**
      * Logs in or creates a new user using an external wallet address.
@@ -349,8 +391,13 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {TWalletType} opts.type type of external wallet to use for identification.
      * @param {string} opts.provider the name of the provider for the external wallet.
      */
-    loginExternalWallet({ externalWallet, ...urlOptions }: CoreMethodParams<'loginExternalWallet'>): CoreMethodResponse<'loginExternalWallet'>;
-    verifyExternalWallet({ externalWallet, signedMessage, cosmosPublicKeyHex, cosmosSigner, ...urlOptions }: CoreMethodParams<'verifyExternalWallet'>): CoreMethodResponse<'verifyExternalWallet'>;
+    loginExternalWallet({ externalWallet, chainId, uri, ...urlOptions }: CoreMethodParams<'loginExternalWallet'>): CoreMethodResponse<'loginExternalWallet'>;
+    verifyExternalWallet(params: {
+        serverAuthState: ServerAuthStateSignup | ServerAuthStateLogin | ServerAuthStateDone;
+    } & Omit<CoreMethodParams<'verifyExternalWallet'>, keyof VerifyExternalWalletParams>): CoreMethodResponse<'verifyExternalWallet'>;
+    verifyExternalWallet(params: VerifyExternalWalletParams & {
+        serverAuthState?: undefined;
+    } & Omit<CoreMethodParams<'verifyExternalWallet'>, 'serverAuthState'>): CoreMethodResponse<'verifyExternalWallet'>;
     protected verifyExternalWalletLink(opts: InternalMethodParams<'verifyExternalWalletLink'>): InternalMethodResponse<'verifyExternalWalletLink'>;
     protected verifyTelegramProcess(opts: CoreMethodParams<'verifyTelegram'> & {
         isLinkAccount: false;
@@ -394,7 +441,15 @@ export declare abstract class ParaCore implements CoreInterface {
      **/
     isFullyLoggedIn(): CoreMethodResponse<'isFullyLoggedIn'>;
     get isGuestMode(): boolean;
+    /**
+     * Get the auth methods available to an existing user
+     * @deprecated Use supportedUserAuthMethods instead
+     */
     protected supportedAuthMethods(auth: Auth<PrimaryAuthType | 'userId'>): Promise<Set<AuthMethod>>;
+    /**
+     * Get the auth methods available to an existing user
+     */
+    protected supportedUserAuthMethods(): Promise<Set<AuthMethod>>;
     /**
      * Get hints associated with the users stored biometrics.
      * @deprecated
@@ -439,7 +494,15 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {boolean} [opts.skipSessionRefresh] whether to skip refreshing the session.
      * @returns {Object} `{ isComplete: boolean; isError: boolean; needsWallet: boolean; partnerId: string; }` the result data
      **/
-    waitForLogin({ isCanceled, onCancel, onPoll, skipSessionRefresh, }?: CoreMethodParams<'waitForLogin'>): CoreMethodResponse<'waitForLogin'>;
+    waitForLogin(args: CoreMethodParams<'waitForLogin'>): CoreMethodResponse<'waitForLogin'>;
+    protected waitForWalletSwitching(args: CoreMethodParams<'waitForLogin'>): CoreMethodResponse<'waitForLogin'>;
+    /**
+     * Gets the switch wallets URL for wallet selection.
+     * The authMethod is automatically included in the URL if available.
+     *
+     * @returns {Promise<{ url: string; authMethod: TAuthMethod }>} The switch wallets URL and authMethod
+     */
+    protected getSwitchWalletsUrl(): Promise<string>;
     /**
      * Updates the session with the user management server, possibly
      * opening a popup to refresh the session.
@@ -662,13 +725,14 @@ export declare abstract class ParaCore implements CoreInterface {
      * Doesn't work for all types of logging.
      **/
     toString(): string;
-    protected devLog(...s: string[]): void;
-    protected getNewCredentialAndUrl({ authMethod, isForNewDevice, portalTheme, shorten, }?: NewCredentialUrlParams): Promise<{
+    protected devLog(...s: any[]): void;
+    protected getNewCredentialAndUrl({ authMethod: optsAuthMethod, isForNewDevice, portalTheme, shorten, }?: NewCredentialUrlParams): Promise<{
         credentialId: string;
         url?: string;
     }>;
+    addCredential({ authMethod }: Pick<NewCredentialUrlParams, 'authMethod'>): Promise<string>;
     /**
-     * Returns a Para Portal URL for logging in with a WebAuth passkey or a password.
+     * Returns a Para Portal URL for logging in with a WebAuth passkey, password, PIN or OTP.
      * @param {Object} opts the options object
      * @param {String} opts.auth - the user auth to sign up or log in with, in the form ` { email: string } | { phone: `+${number}` } `
      * @param {boolean} opts.useShortUrls - whether to shorten the generated portal URLs
@@ -676,6 +740,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @returns {SignUpOrLogInResponse} an object in the form of either: `{ stage: 'verify' }` or `{ stage: 'login'; passkeyUrl?: string; passwordUrl?: string; biometricHints?: BiometricLocationHint[] }`
      */
     protected getLoginUrl({ authMethod, shorten, portalTheme, sessionId, }: LoginUrlParams): Promise<string>;
+    protected prepareLogin(): InternalMethodResponse<'prepareLogin'>;
     signUpOrLogIn({ auth, ...urlOptions }: CoreMethodParams<'signUpOrLogIn'>): CoreMethodResponse<'signUpOrLogIn'>;
     verifyNewAccount({ verificationCode, ...urlOptions }: CoreMethodParams<'verifyNewAccount'>): CoreMethodResponse<'verifyNewAccount'>;
     getLinkedAccounts({ withMetadata, }?: CoreMethodParams<'getLinkedAccounts'>): CoreMethodResponse<'getLinkedAccounts'>;
@@ -685,4 +750,10 @@ export declare abstract class ParaCore implements CoreInterface {
         accountLinkInProgress?: AccountLinkInProgress;
     } & Partial<Pick<VerifyLinkParams, 'verificationCode' | 'telegramAuthResponse'> & VerifyExternalWalletParams>): Promise<LinkedAccounts>;
     protected verifyEmailOrPhoneLink({ verificationCode, }: InternalMethodParams<'verifyEmailOrPhoneLink'>): InternalMethodResponse<'verifyEmailOrPhoneLink'>;
+    protected getProfileBalance({ config, refetch }?: {
+        config?: BalancesConfig;
+        refetch?: boolean;
+    }): Promise<import("@getpara/user-management-client").ProfileBalance>;
+    protected sendLoginCode(): Promise<void>;
+    exportPrivateKey(args?: CoreMethodParams<'exportPrivateKey'>): CoreMethodResponse<'exportPrivateKey'>;
 }

package/dist/types/PlatformUtils.d.ts

@@ -42,5 +42,6 @@ export interface PlatformUtils {
     disableProviderModal?: boolean;
     openPopup(popupUrl: string, opts?: {
         type: PopupType;
-    }): Window;
+    }): Promise<Window>;
+    initializeWorker(ctx: Ctx): Promise<void>;
 }

package/dist/types/constants.d.ts

@@ -1,5 +1,6 @@
 export declare const PARA_CORE_VERSION: string;
 export declare const PREFIX = "@CAPSULE/";
+export declare const PARA_PREFIX = "@PARA/";
 export declare const LOCAL_STORAGE_AUTH_INFO = "@CAPSULE/authInfo";
 export declare const LOCAL_STORAGE_EMAIL = "@CAPSULE/e-mail";
 export declare const LOCAL_STORAGE_PHONE = "@CAPSULE/phone";
@@ -13,6 +14,8 @@ export declare const LOCAL_STORAGE_WALLETS = "@CAPSULE/wallets";
 export declare const LOCAL_STORAGE_EXTERNAL_WALLETS = "@CAPSULE/externalWallets";
 export declare const LOCAL_STORAGE_CURRENT_WALLET_IDS = "@CAPSULE/currentWalletIds";
 export declare const LOCAL_STORAGE_SESSION_COOKIE = "@CAPSULE/sessionCookie";
+export declare const LOCAL_STORAGE_ENCLAVE_JWT = "@CAPSULE/enclaveJwt";
+export declare const LOCAL_STORAGE_ENCLAVE_REFRESH_JWT = "@CAPSULE/enclaveRefreshJwt";
 export declare const SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR = "@CAPSULE/loginEncryptionKeyPair";
 export declare const POLLING_INTERVAL_MS = 2000;
 export declare const SHORT_POLLING_INTERVAL_MS = 1000;

package/dist/types/index.d.ts

@@ -1,11 +1,11 @@
 import { ParaCore } from './ParaCore.js';
-export { type Auth, type AuthInfo, type PrimaryAuthInfo, type VerifiedAuthInfo, type VerifiedAuth, AuthMethod, type AuthExtras, type CurrentWalletIds, EmailTheme, type PartnerEntity, type WalletEntity, Network, WalletType, type TWalletType, WalletScheme, type TWalletScheme, OnRampAsset, OnRampPurchaseType, OnRampProvider, OnRampPurchaseStatus, type OnRampConfig, type OnRampAllowedAssets, type OnRampPurchase, OAuthMethod, type TOAuthMethod, type TLinkedAccountType, type SupportedAccountLinks, type SupportedWalletTypes, type TPregenIdentifierType, type PregenIds, type LinkedAccount, type LinkedAccounts, type TExternalWallet, type ExternalWalletInfo, type PregenAuth, type Setup2faResponse, type TelegramAuthResponse, type VerifyExternalWalletParams, NON_ED25519, PREGEN_IDENTIFIER_TYPES, WALLET_TYPES, WALLET_SCHEMES, OAUTH_METHODS, LINKED_ACCOUNT_TYPES, EXTERNAL_WALLET_TYPES, EVM_WALLETS, SOLANA_WALLETS, COSMOS_WALLETS, } from '@getpara/user-management-client';
-export { OnRampMethod, PopupType, PregenIdentifierType, RecoveryStatus, type AuthStateSignup, type AuthStateVerify, type AuthStateLogin, type AuthState, type OAuthResponse, type CoreAuthInfo, type ProviderAssetInfo, type SignatureRes, type FullSignatureRes, type SuccessfulSignatureRes, type DeniedSignatureRes, type DeniedSignatureResWithUrl, type OnRampAssetInfo, type Theme, type Wallet, type GetWalletBalanceParams, type AccountLinkInProgress, AccountLinkError, type InternalInterface, } from './types/index.js';
+export { type Auth, type AuthInfo, type PrimaryAuthInfo, type VerifiedAuthInfo, type VerifiedAuth, AuthMethod, type TAuthMethod, AuthMethodStatus, type AuthExtras, type CurrentWalletIds, EmailTheme, type PartnerEntity, type WalletEntity, Network, type TNetwork, WalletType, type TWalletType, WalletScheme, type TWalletScheme, OnRampAsset, type TOnRampAsset, OnRampPurchaseType, OnRampProvider, OnRampPurchaseStatus, type OnRampConfig, type OnRampAssets, type OnRampPurchase, type OnRampAssetInfo, type ProviderAssetInfo, OnRampMethod, type Theme, OAuthMethod, type TOAuthMethod, type TLinkedAccountType, type SupportedAccountLinks, type SupportedWalletTypes, type TPregenIdentifierType, type PregenIds, type LinkedAccount, type LinkedAccounts, type TExternalWallet, type ExternalWalletInfo, type PregenAuth, type Setup2faResponse, type TelegramAuthResponse, type VerifyExternalWalletParams, type AssetMetadata, type AssetMetadataIndexed, type AssetValue, type BalancesConfig, type WalletBalance, type ProfileBalance, type OfframpDepositRequest, type WalletWithMetadata, RecoveryStatus, ThemeMode, NON_ED25519, PREGEN_IDENTIFIER_TYPES, WALLET_TYPES, WALLET_SCHEMES, OAUTH_METHODS, LINKED_ACCOUNT_TYPES, EXTERNAL_WALLET_TYPES, EVM_WALLETS, SOLANA_WALLETS, COSMOS_WALLETS, formatAssetQuantity, formatCurrency, type EstimateTransactionOpts, type EstimateTransactionResult, type BroadcastTransactionOpts, type BroadcastTransactionResult, } from '@getpara/user-management-client';
+export { PopupType, PregenIdentifierType, type AuthStateSignup, type AuthStateVerify, type AuthStateLogin, type AuthState, type OAuthResponse, type CoreAuthInfo, type SignatureRes, type FullSignatureRes, type SuccessfulSignatureRes, type DeniedSignatureRes, type DeniedSignatureResWithUrl, type Wallet, type AvailableWallet, type GetWalletBalanceParams, type AccountLinkInProgress, AccountLinkError, type InternalInterface, } from './types/index.js';
 export * from './types/coreApi.js';
 export * from './types/events.js';
 export * from './types/config.js';
-export { getPortalDomain, entityToWallet, constructUrl, shortenUrl } from './utils/index.js';
-export { PREFIX as STORAGE_PREFIX } from './constants.js';
+export { getPortalDomain, dispatchEvent, entityToWallet, constructUrl, shortenUrl, isPortal } from './utils/index.js';
+export { PREFIX as STORAGE_PREFIX, PARA_PREFIX as PARA_STORAGE_PREFIX, LOCAL_STORAGE_CURRENT_WALLET_IDS, LOCAL_STORAGE_WALLETS, } from './constants.js';
 export { distributeNewShare } from './shares/shareDistribution.js';
 export { KeyContainer } from './shares/KeyContainer.js';
 export type { PlatformUtils } from './PlatformUtils.js';
@@ -18,9 +18,11 @@ export * from './errors.js';
 export * from './utils/formatting.js';
 export * from './utils/polling.js';
 export * from './utils/phone.js';
+export * from './utils/config.js';
 export { isWalletSupported } from './utils/wallet.js';
 export { getNetworkPrefix, getOnRampAssets, getOnRampNetworks, toAssetInfoArray } from './utils/onRamps.js';
 export { getPortalBaseURL } from './utils/url.js';
 export { retrieve as transmissionUtilsRetrieve } from './transmission/transmissionUtils.js';
+export type { ShareData } from './shares/enclave.js';
 export declare const paraVersion: string;
 export default ParaCore;

package/dist/types/shares/enclave.d.ts

@@ -0,0 +1,83 @@
+import UserManagementClient from '@getpara/user-management-client';
+export interface ShareData {
+    userId: string;
+    walletId: string;
+    walletScheme: string;
+    partnerId?: string;
+    protocolId?: string;
+    signer: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface ShareQuery {
+    userId: string;
+    walletId?: string;
+    partnerId?: string;
+}
+export interface EncryptedPayload {
+    encryptedData: string;
+    keyId: string;
+    algorithm: string;
+    ephemeral: string;
+}
+/**
+ * Enclave client for secure key share operations
+ * Handles encryption/decryption and communication with the enclave service
+ */
+export declare class EnclaveClient {
+    private userManagementClient;
+    private enclavePublicKey;
+    private frontendKeyPair;
+    private retrieveJwt;
+    private persistJwt;
+    private retrieveRefreshJwt;
+    private persistRefreshJwt;
+    constructor({ userManagementClient, retrieveJwt, persistJwt, retrieveRefreshJwt, persistRefreshJwt, }: {
+        userManagementClient: UserManagementClient;
+        retrieveJwt: () => string;
+        persistJwt: (jwt: string) => void;
+        retrieveRefreshJwt: () => string;
+        persistRefreshJwt: (refreshJwt: string) => void;
+    });
+    private refreshJwt;
+    private withJwtRefreshRetry;
+    issueEnclaveJwt(): Promise<void>;
+    /**
+     * Generate a P-256 keypair for the frontend to receive encrypted responses
+     */
+    private generateFrontendKeyPair;
+    /**
+     * Get the enclave's public key from the user-management service
+     */
+    private getEnclavePublicKey;
+    /**
+     * Import a PEM-formatted public key for use with Web Crypto API
+     */
+    private importPublicKeyFromPEM;
+    /**
+     * Export a public key to PEM format
+     */
+    private exportPublicKeyToPEM;
+    /**
+     * Encrypt data using P-256 ECIES for the enclave
+     */
+    private encryptForEnclave;
+    /**
+     * Decrypt response encrypted for the frontend
+     */
+    private decryptForFrontend;
+    /**
+     * Persist key shares to the enclave
+     * @param shares Array of share data to persist
+     */
+    private persistShares;
+    /**
+     * Retrieve key shares from the enclave
+     * @param query Query parameters for finding shares (single query or array of queries)
+     */
+    private retrieveShares;
+    deleteShares(): Promise<void>;
+    retrieveSharesWithRetry(query: ShareQuery[]): Promise<ShareData[]>;
+    persistSharesWithRetry(shares: ShareData[]): Promise<any>;
+    deleteSharesWithRetry(): Promise<void>;
+}

package/dist/types/shares/shareDistribution.d.ts

@@ -1,6 +1,6 @@
-import { BackupKitEmailProps } from '@getpara/user-management-client';
+import { BackupKitEmailProps, TWalletScheme } from '@getpara/user-management-client';
 import { Ctx } from '../types/index.js';
-export declare function distributeNewShare({ ctx, userId, walletId, userShare, ignoreRedistributingBackupEncryptedShare, emailProps, partnerId, protocolId, }: {
+export declare function distributeNewShare({ ctx, userId, walletId, userShare, ignoreRedistributingBackupEncryptedShare, emailProps, partnerId, protocolId, isEnclaveUser, walletScheme, }: {
     ctx: Ctx;
     userId: string;
     walletId: string;
@@ -9,4 +9,6 @@ export declare function distributeNewShare({ ctx, userId, walletId, userShare, i
     emailProps?: BackupKitEmailProps;
     partnerId?: string;
     protocolId?: string;
+    isEnclaveUser: boolean;
+    walletScheme: TWalletScheme;
 }): Promise<string>;

package/dist/types/types/assets.d.ts

@@ -0,0 +1,14 @@
+import { TNetwork, TOnRampAsset } from '@getpara/user-management-client';
+import { Wallet } from './wallet.js';
+export type AssetTransferType = 'INBOUND' | 'OUTBOUND';
+export type AssetTransfer = {
+    wallet: Omit<Wallet, 'signer'>;
+    type: AssetTransferType;
+    sourceAddress: string;
+    destinationAddress: string;
+    asset: TOnRampAsset;
+    network: TNetwork;
+    quantity: string;
+    chainId?: string;
+    contractAddress?: string;
+};

package/dist/types/types/config.d.ts

@@ -1,6 +1,6 @@
 import { AxiosInstance } from 'axios';
-import Client, { EmailTheme, Network, OnRampAsset, OnRampProvider, PregenAuth, TWalletScheme, TWalletType } from '@getpara/user-management-client';
-import { Theme } from './theme.js';
+import Client, { EmailTheme, Network, OnRampAsset, OnRampProvider, PregenAuth, TWalletScheme, TWalletType, Theme } from '@getpara/user-management-client';
+import { EnclaveClient } from '../shares/enclave.js';
 export declare enum Environment {
     DEV = "DEV",
     SANDBOX = "SANDBOX",
@@ -13,6 +13,7 @@ export interface Ctx {
     env: Environment;
     apiKey: string;
     client: Client;
+    enclaveClient?: EnclaveClient;
     disableWorkers?: boolean;
     offloadMPCComputationURL?: string;
     mpcComputationClient?: AxiosInstance;