@getpara/core-sdk 1.2.0 → 1.3.1

package/dist/esm/PlatformUtils.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/StorageUtils.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/constants.js

@@ -1,17 +0,0 @@
-export const PARA_CORE_VERSION = '1.2.0';
-export const PREFIX = '@CAPSULE/';
-export const LOCAL_STORAGE_EMAIL = `${PREFIX}e-mail`;
-export const LOCAL_STORAGE_PHONE = `${PREFIX}phone`;
-export const LOCAL_STORAGE_COUNTRY_CODE = `${PREFIX}countryCode`;
-export const LOCAL_STORAGE_FARCASTER_USERNAME = `${PREFIX}farcasterUsername`;
-export const LOCAL_STORAGE_TELEGRAM_USER_ID = `${PREFIX}telegramUserId`;
-export const LOCAL_STORAGE_USER_ID = `${PREFIX}userId`;
-export const LOCAL_STORAGE_ED25519_WALLETS = `${PREFIX}ed25519Wallets`;
-export const LOCAL_STORAGE_WALLETS = `${PREFIX}wallets`;
-export const LOCAL_STORAGE_EXTERNAL_WALLETS = `${PREFIX}externalWallets`;
-export const LOCAL_STORAGE_CURRENT_WALLET_IDS = `${PREFIX}currentWalletIds`;
-export const LOCAL_STORAGE_CURRENT_EXTERNAL_WALLET_ADDRESSES = `${PREFIX}currentExternalWalletAddresses`;
-export const LOCAL_STORAGE_SESSION_COOKIE = `${PREFIX}sessionCookie`;
-export const SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR = `${PREFIX}loginEncryptionKeyPair`;
-export const POLLING_INTERVAL_MS = 2000;
-export const SHORT_POLLING_INTERVAL_MS = 1000;

package/dist/esm/cryptography/utils.js

@@ -1,226 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import base64url from 'base64url';
-import forge from 'node-forge';
-import { getPortalBaseURL } from '../utils/index.js';
-const rsa = forge.pki.rsa;
-const RSA_ENCRYPTION_SCHEME = 'RSA-OAEP';
-// ivs can be constant only because every key is only ever used to encrypt one message
-const CONSTANT_IV = '794241bc819a125a7b78ea313decc0bc';
-const CONSTANT_IV_AES = new Uint8Array([23, 66, 157, 146, 179, 158, 117, 120, 184, 73, 123, 81]);
-export function getSHA256HashHex(str) {
-    const md = forge.md.sha256.create();
-    md.update(str);
-    return md.digest().toHex();
-}
-export function getPublicKeyHex(keyPair) {
-    const pem = forge.pki.publicKeyToRSAPublicKeyPem(keyPair.publicKey);
-    return Buffer.from(pem, 'utf-8').toString('hex');
-}
-export function publicKeyFromHex(publicKeyHex) {
-    const pem = publicKeyHexToPem(publicKeyHex);
-    return forge.pki.publicKeyFromPem(pem);
-}
-export function publicKeyHexToPem(publicKeyHex) {
-    return Buffer.from(publicKeyHex, 'hex').toString('utf-8');
-}
-export function encodePrivateKeyToPemHex(keyPair) {
-    const pem = forge.pki.privateKeyToPem(keyPair.privateKey);
-    return Buffer.from(pem, 'utf-8').toString('hex');
-}
-export function decodePrivateKeyPemHex(privateKeyPemHex) {
-    const pem = Buffer.from(privateKeyPemHex, 'hex').toString('utf-8');
-    return forge.pki.privateKeyFromPem(pem);
-}
-export function encryptPrivateKey(keyPair, key) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const privateKeyPemHex = encodePrivateKeyToPemHex(keyPair);
-        const cryptoKey = yield window.crypto.subtle.importKey('raw', Buffer.from(key, 'base64'), {
-            name: 'AES-GCM',
-            length: 256,
-        }, true, ['encrypt', 'decrypt']);
-        const encodedPlaintext = new TextEncoder().encode(privateKeyPemHex);
-        const ciphertext = yield window.crypto.subtle.encrypt({ name: 'AES-GCM', iv: CONSTANT_IV_AES }, cryptoKey, encodedPlaintext);
-        return Buffer.from(ciphertext).toString('base64');
-    });
-}
-export function decryptPrivateKey(encryptedPrivateKeyPemHex, key) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const secretKey = yield crypto.subtle.importKey('raw', Buffer.from(key, 'base64'), {
-            name: 'AES-GCM',
-            length: 256,
-        }, true, ['encrypt', 'decrypt']);
-        const cleartext = yield crypto.subtle.decrypt({ name: 'AES-GCM', iv: CONSTANT_IV_AES }, secretKey, Buffer.from(encryptedPrivateKeyPemHex, 'base64'));
-        const privateKeyPemHex = new TextDecoder().decode(cleartext);
-        const privateKey = decodePrivateKeyPemHex(privateKeyPemHex);
-        return privateKey;
-    });
-}
-export function getAsymmetricKeyPair(ctx, seedValue) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const prng = forge.random.createInstance();
-        if (seedValue) {
-            prng.seedFileSync = (_n) => seedValue;
-            prng.seedFile = (_n, cb) => {
-                cb(null, seedValue);
-            };
-        }
-        const options = {
-            bits: 2048,
-            e: 65537,
-            prng,
-        };
-        if (!ctx.disableWorkers) {
-            options.workLoad = 100;
-            // only using 1 web worker as more makes the call non-deterministic
-            // -1 uses optimal amount of web workers
-            options.workers = seedValue ? 1 : -1;
-            const workerRes = yield fetch(`${getPortalBaseURL(ctx)}/static/js/prime.worker.min.js`);
-            const workerBlob = new Blob([yield workerRes.text()], { type: 'application/javascript' });
-            options.workerScript = URL.createObjectURL(workerBlob);
-        }
-        return new Promise((resolve, reject) => rsa.generateKeyPair(options, (err, keypair) => {
-            if (err) {
-                reject(err);
-            }
-            resolve(keypair);
-        }));
-    });
-}
-export function getPublicKeyFromSignature(ctx, userHandle) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const encodedUserHandle = base64url.encode(userHandle);
-        const keyPair = yield getAsymmetricKeyPair(ctx, encodedUserHandle);
-        return getPublicKeyHex(keyPair);
-    });
-}
-// only use for one time key encryptions as iv is constant
-export function symmetricKeyEncryptMessage(message) {
-    const key = forge.random.getBytesSync(16);
-    const cipher = forge.cipher.createCipher('AES-CBC', key);
-    // iv can be constant only because every key is only ever used to encrypt one message
-    cipher.start({ iv: CONSTANT_IV });
-    cipher.update(forge.util.createBuffer(message));
-    cipher.finish();
-    const encryptedMessageHex = cipher.output.toHex();
-    return { key, encryptedMessageHex };
-}
-function decipherEncryptedMessageHex(key, encryptedMessageHex) {
-    const decipher = forge.cipher.createDecipher('AES-CBC', key);
-    // iv can be constant only because every key is only ever used to encrypt one message
-    decipher.start({ iv: CONSTANT_IV });
-    decipher.update(forge.util.createBuffer(forge.util.hexToBytes(encryptedMessageHex)));
-    decipher.finish();
-    return decipher.output.toString();
-}
-// Deprecated in favor of decryptWithPrivateKey
-export function decryptWithKeyPair(keyPair, encryptedMessageHex, encryptedKeyHex) {
-    const encryptedKey = Buffer.from(encryptedKeyHex, 'hex').toString('utf-8');
-    const key = keyPair.privateKey.decrypt(encryptedKey, RSA_ENCRYPTION_SCHEME);
-    return decipherEncryptedMessageHex(key, encryptedMessageHex);
-}
-export function decryptWithPrivateKey(privateKey, encryptedMessageHex, encryptedKeyHex) {
-    const encryptedKey = Buffer.from(encryptedKeyHex, 'hex').toString('utf-8');
-    const key = privateKey.decrypt(encryptedKey, RSA_ENCRYPTION_SCHEME);
-    return decipherEncryptedMessageHex(key, encryptedMessageHex);
-}
-function decryptWithDerivedPrivateKey(ctx, { seedValue, encryptedMessageHex, encryptedKeyHex, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const keyPair = yield getAsymmetricKeyPair(ctx, seedValue);
-        return decryptWithPrivateKey(keyPair.privateKey, encryptedMessageHex, encryptedKeyHex);
-    });
-}
-export function getDerivedPrivateKeyAndDecrypt(ctx, seedValue, encryptedShares) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return Promise.all(encryptedShares.map((share) => __awaiter(this, void 0, void 0, function* () {
-            return ({
-                walletId: share.walletId,
-                walletScheme: share.walletScheme,
-                partnerId: share.partnerId,
-                signer: yield decryptWithDerivedPrivateKey(ctx, {
-                    seedValue,
-                    encryptedMessageHex: share.encryptedShare,
-                    encryptedKeyHex: share.encryptedKey,
-                }),
-                protocolId: share.protocolId,
-            });
-        })));
-    });
-}
-export function decryptPrivateKeyAndDecryptShare(encryptionKey, encryptedShares, encryptedPrivateKey) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let privateKey;
-        try {
-            privateKey = yield decryptPrivateKey(encryptedPrivateKey, encryptionKey);
-        }
-        catch (e) { }
-        try {
-            privateKey = yield decryptPrivateKeyWithPassword(encryptedPrivateKey, encryptionKey);
-        }
-        catch (e) { }
-        if (!privateKey) {
-            throw new Error('Could not decrypt private key');
-        }
-        return encryptedShares.map(share => ({
-            walletId: share.walletId,
-            walletScheme: share.walletScheme,
-            partnerId: share.partnerId,
-            signer: decryptWithPrivateKey(privateKey, share.encryptedShare, share.encryptedKey),
-            protocolId: share.protocolId,
-        }));
-    });
-}
-export function encryptWithDerivedPublicKey(publicKeyHex, message) {
-    const { key, encryptedMessageHex } = symmetricKeyEncryptMessage(message);
-    const publicKeyPem = publicKeyHexToPem(publicKeyHex);
-    const publicKey = forge.pki.publicKeyFromPem(publicKeyPem);
-    const encryptedKey = publicKey.encrypt(key, RSA_ENCRYPTION_SCHEME);
-    const encryptedKeyHex = Buffer.from(encryptedKey, 'utf-8').toString('hex');
-    return { encryptedMessageHex, encryptedKeyHex };
-}
-export function hashPasswordWithSalt(password) {
-    const salt = generateSalt();
-    const saltedPassword = salt + password;
-    const hash = getSHA256HashHex(saltedPassword);
-    return { salt, hash };
-}
-function generateSalt(length = 16) {
-    return forge.util.bytesToHex(forge.random.getBytesSync(length));
-}
-function deriveCryptoKeyFromPassword(hashedPassword) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const keyBuffer = Buffer.from(hashedPassword, 'hex');
-        return yield window.crypto.subtle.importKey('raw', keyBuffer, {
-            name: 'AES-GCM',
-            length: 256,
-        }, true, ['encrypt', 'decrypt']);
-    });
-}
-export function encryptPrivateKeyWithPassword(keyPair, hashedPassword) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const cryptoKey = yield deriveCryptoKeyFromPassword(hashedPassword);
-        const privateKeyPemHex = encodePrivateKeyToPemHex(keyPair);
-        const encodedPlaintext = new TextEncoder().encode(privateKeyPemHex);
-        const ciphertext = yield window.crypto.subtle.encrypt({ name: 'AES-GCM', iv: CONSTANT_IV_AES }, cryptoKey, encodedPlaintext);
-        return Buffer.from(ciphertext).toString('base64');
-    });
-}
-export function decryptPrivateKeyWithPassword(encryptedPrivateKeyPemHex, hashedPassword) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const secretKey = yield crypto.subtle.importKey('raw', Buffer.from(hashedPassword, 'hex'), {
-            name: 'AES-GCM',
-            length: 256,
-        }, true, ['encrypt', 'decrypt']);
-        const cleartext = yield crypto.subtle.decrypt({ name: 'AES-GCM', iv: CONSTANT_IV_AES }, secretKey, Buffer.from(encryptedPrivateKeyPemHex, 'base64'));
-        const privateKeyPemHex = new TextDecoder().decode(cleartext);
-        const privateKey = decodePrivateKeyPemHex(privateKeyPemHex);
-        return privateKey;
-    });
-}

package/dist/esm/errors.js

@@ -1,21 +0,0 @@
-export class TransactionReviewError extends Error {
-    constructor(transactionReviewUrl) {
-        super('transaction review error');
-        this.name = 'TransactionReviewError';
-        this.transactionReviewUrl = transactionReviewUrl;
-    }
-}
-export class TransactionReviewDenied extends Error {
-    constructor() {
-        super('transaction review has been denied by the user');
-        this.name = 'TransactionReviewDenied';
-    }
-}
-export class TransactionReviewTimeout extends Error {
-    constructor(transactionReviewUrl, pendingTransactionId) {
-        super('transaction review has timed out');
-        this.name = 'TransactionReviewTimeout';
-        this.transactionReviewUrl = transactionReviewUrl;
-        this.pendingTransactionId = pendingTransactionId;
-    }
-}

package/dist/esm/external/mpcComputationClient.js

@@ -1,26 +0,0 @@
-import axios from 'axios';
-export function initClient(baseURL, useAdapter) {
-    const client = axios.create({ baseURL });
-    if (useAdapter) {
-        client.defaults.adapter = function (config) {
-            return fetch(config.baseURL + config.url, {
-                method: config.method,
-                headers: config.headers,
-                body: config.data,
-                credentials: config.withCredentials ? 'include' : undefined,
-            })
-                .then(response => response.text().then(text => ({
-                data: text,
-                status: response.status,
-                statusText: response.statusText,
-                headers: response.headers,
-                config: config,
-                request: fetch,
-            })))
-                .catch(function (reason) {
-                throw reason;
-            });
-        };
-    }
-    return client;
-}

package/dist/esm/external/userManagementClient.js

@@ -1,56 +0,0 @@
-import Client from '@getpara/user-management-client';
-import { Environment } from '../types/index.js';
-export function getBaseOAuthUrl(env) {
-    switch (env) {
-        case Environment.DEV:
-            return 'http://localhost:8080/';
-        case Environment.SANDBOX:
-            return 'https://api.sandbox.usecapsule.com/';
-        case Environment.BETA:
-            return 'https://api.beta.usecapsule.com/';
-        case Environment.PROD:
-            return 'https://api.usecapsule.com/';
-        default:
-            throw new Error(`unsupported env: ${env}`);
-    }
-}
-export function getBaseUrl(env) {
-    switch (env) {
-        case Environment.DEV:
-            return 'http://localhost:8080/';
-        case Environment.SANDBOX:
-            return 'https://api.sandbox.getpara.com/';
-        case Environment.BETA:
-            return 'https://api.beta.getpara.com/';
-        case Environment.PROD:
-            return 'https://api.getpara.com/';
-        default:
-            throw new Error(`unsupported env: ${env}`);
-    }
-}
-export function getBaseMPCNetworkUrl(env, useWebsocket) {
-    const prefix = useWebsocket ? 'ws' : 'http';
-    switch (env) {
-        case Environment.DEV:
-            return `${prefix}://localhost:3000`;
-        case Environment.SANDBOX:
-            return `${prefix}s://mpc-network.sandbox.getpara.com`;
-        case Environment.BETA:
-            return `${prefix}s://mpc-network.beta.getpara.com`;
-        case Environment.PROD:
-            return `${prefix}s://mpc-network.prod.getpara.com`;
-        default:
-            throw new Error(`unsupported env: ${env}`);
-    }
-}
-export function initClient({ env, version, apiKey, partnerId, useFetchAdapter = false, retrieveSessionCookie, persistSessionCookie, }) {
-    return new Client({
-        userManagementHost: getBaseUrl(env),
-        version: [Environment.DEV, Environment.SANDBOX].includes(env) ? 'dev' : version,
-        apiKey: apiKey,
-        partnerId,
-        opts: { useFetchAdapter },
-        retrieveSessionCookie,
-        persistSessionCookie,
-    });
-}

package/dist/esm/package.json

@@ -1 +0,0 @@
-{"type":"module","sideEffects":false}

package/dist/esm/shares/KeyContainer.js

@@ -1,57 +0,0 @@
-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';
-export class KeyContainer {
-    constructor(walletId, keyshare, address) {
-        this.walletId = walletId;
-        this.keyshare = keyshare;
-        this.address = address;
-        this.backupDecryptionKey = Buffer.from(forge.random.getBytesSync(32), 'binary').toString('hex');
-    }
-    static buildFrom(serializedContainer) {
-        try {
-            const parsedObject = JSON.parse(serializedContainer);
-            return Object.assign(new KeyContainer('', '', ''), parsedObject);
-        }
-        catch (e) {
-            const container = new KeyContainer('', '', '');
-            container.backupDecryptionKey = serializedContainer.split('|')[0];
-            return container;
-        }
-    }
-    getPublicEncryptionKey() {
-        return Buffer.from(eutil.privateToPublic(Buffer.from(this.backupDecryptionKey, 'hex')));
-    }
-    getPublicEncryptionKeyHex() {
-        return this.getPublicEncryptionKey().toString('hex');
-    }
-    encryptForSelf(backup) {
-        try {
-            const pubkey = this.getPublicEncryptionKey();
-            const data = ECIESEncrypt(pubkey, Buffer.from(backup, 'ucs2')).toString('base64');
-            return data;
-        }
-        catch (error) {
-            throw Error('Error encrypting backup');
-        }
-    }
-    static encryptWithPublicKey(publicKey, backup) {
-        try {
-            const data = ECIESEncrypt(publicKey, Buffer.from(backup, 'ucs2')).toString('base64');
-            return data;
-        }
-        catch (error) {
-            throw Error('Error encrypting backup');
-        }
-    }
-    decrypt(encryptedBackup) {
-        try {
-            const buf = Buffer.from(encryptedBackup, 'base64');
-            const data = ECIESDecrypt(Buffer.from(this.backupDecryptionKey, 'hex'), buf);
-            return Buffer.from(data.buffer).toString('ucs2');
-        }
-        catch (error) {
-            throw Error('Error decrypting backup');
-        }
-    }
-}

package/dist/esm/shares/recovery.js

@@ -1,58 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { EncryptorType, KeyShareType } from '@getpara/user-management-client';
-import { KeyContainer } from './KeyContainer.js';
-export function sendRecoveryForShare({ ctx, userId, walletId, otherEncryptedShares = [], userSigner, ignoreRedistributingBackupEncryptedShare = false, emailProps = {}, forceRefresh = false, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (ignoreRedistributingBackupEncryptedShare) {
-            yield ctx.client.uploadUserKeyShares(userId, otherEncryptedShares.map(share => (Object.assign({ walletId }, share))));
-            return '';
-        }
-        let userBackupKeyShareOptsArr;
-        let recoveryPrivateKeyContainer;
-        const { recoveryPublicKeys } = yield ctx.client.getRecoveryPublicKeys(userId);
-        if (forceRefresh || !(recoveryPublicKeys === null || recoveryPublicKeys === void 0 ? void 0 : recoveryPublicKeys.length)) {
-            recoveryPrivateKeyContainer = new KeyContainer(walletId, '', '');
-            const { recoveryPublicKeys } = yield ctx.client.persistRecoveryPublicKeys(userId, [
-                recoveryPrivateKeyContainer.getPublicEncryptionKeyHex(),
-            ]);
-            const encryptedUserBackup = recoveryPrivateKeyContainer.encryptForSelf(userSigner);
-            userBackupKeyShareOptsArr = [
-                {
-                    walletId,
-                    encryptedShare: encryptedUserBackup,
-                    type: KeyShareType.USER,
-                    encryptor: EncryptorType.RECOVERY,
-                    recoveryPublicKeyId: recoveryPublicKeys[0].id,
-                },
-            ];
-        }
-        else {
-            userBackupKeyShareOptsArr = recoveryPublicKeys.map(recoveryPublicKey => {
-                const { id: recoveryPublicKeyId, publicKey } = recoveryPublicKey;
-                const encryptedUserBackup = KeyContainer.encryptWithPublicKey(Buffer.from(publicKey, 'hex'), userSigner);
-                return {
-                    walletId,
-                    encryptedShare: encryptedUserBackup,
-                    type: KeyShareType.USER,
-                    encryptor: EncryptorType.RECOVERY,
-                    recoveryPublicKeyId,
-                };
-            });
-        }
-        yield ctx.client.uploadUserKeyShares(userId, [
-            ...otherEncryptedShares.map(share => (Object.assign({ walletId }, share))),
-            ...(ignoreRedistributingBackupEncryptedShare ? [] : userBackupKeyShareOptsArr),
-        ]);
-        yield ctx.client.distributeParaShare(Object.assign({ userId,
-            walletId, useDKLS: ctx.useDKLS }, emailProps));
-        return recoveryPrivateKeyContainer ? JSON.stringify(recoveryPrivateKeyContainer) : '';
-    });
-}

package/dist/esm/shares/shareDistribution.js

@@ -1,63 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { EncryptorType, KeyShareType } from '@getpara/user-management-client';
-import { encryptWithDerivedPublicKey } from '../cryptography/utils.js';
-import { sendRecoveryForShare } from './recovery.js';
-// function to call on new user share to perform all necessary distribution
-export function distributeNewShare({ ctx, userId, walletId, userShare, ignoreRedistributingBackupEncryptedShare = false, emailProps = {}, partnerId, protocolId, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const publicKeysRes = yield ctx.client.getSessionPublicKeys(userId);
-        const biometricEncryptedShares = publicKeysRes.data.keys
-            .map(key => {
-            if (!key.publicKey) {
-                return;
-            }
-            const { encryptedMessageHex, encryptedKeyHex } = encryptWithDerivedPublicKey(key.sigDerivedPublicKey, userShare);
-            return {
-                encryptedShare: encryptedMessageHex,
-                encryptedKey: encryptedKeyHex,
-                type: KeyShareType.USER,
-                encryptor: EncryptorType.BIOMETRICS,
-                biometricPublicKey: key.sigDerivedPublicKey,
-                partnerId,
-                protocolId,
-            };
-        })
-            .filter(Boolean);
-        const passwords = yield ctx.client.getPasswords({ userId });
-        const passwordEncryptedShares = passwords
-            .map(password => {
-            if (password.status === 'PENDING') {
-                return;
-            }
-            const { encryptedMessageHex, encryptedKeyHex } = encryptWithDerivedPublicKey(password.sigDerivedPublicKey, userShare);
-            return {
-                encryptedShare: encryptedMessageHex,
-                encryptedKey: encryptedKeyHex,
-                type: KeyShareType.USER,
-                encryptor: EncryptorType.PASSWORD,
-                passwordId: password.id,
-                partnerId,
-                protocolId,
-            };
-        })
-            .filter(Boolean);
-        const allEncryptedShares = [...biometricEncryptedShares, ...passwordEncryptedShares];
-        return yield sendRecoveryForShare({
-            ctx,
-            userId,
-            walletId,
-            otherEncryptedShares: allEncryptedShares,
-            userSigner: userShare,
-            ignoreRedistributingBackupEncryptedShare,
-            emailProps,
-        });
-    });
-}

package/dist/esm/transmission/transmissionUtils.js

@@ -1,45 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { randomBytes } from 'crypto';
-import { Encrypt as ECIESEncrypt, Decrypt as ECIESDecrypt } from '@celo/utils/lib/ecies.js';
-import { Buffer } from 'buffer';
-import * as eutil from 'ethereumjs-util';
-export function upload(message, userManagementClient) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let secret;
-        let publicKeyUint8Array;
-        while (true) {
-            try {
-                secret = randomBytes(32).toString('hex');
-                // privateToPublic throws error when private key is larger than group order
-                // so we want to keep trying until we get a valid private key
-                publicKeyUint8Array = eutil.privateToPublic(Buffer.from(secret, 'hex'));
-                break;
-            }
-            catch (e) {
-                continue;
-            }
-        }
-        const pubkey = Buffer.from(publicKeyUint8Array);
-        const data = ECIESEncrypt(pubkey, Buffer.from(message, 'ucs2')).toString('base64');
-        const { data: { id }, } = yield userManagementClient.tempTrasmissionInit(data);
-        return encodeURIComponent(id + '|' + secret);
-    });
-}
-export function retrieve(uriEncodedMessage, userManagementClient) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const [id, secret] = decodeURIComponent(uriEncodedMessage).split('|');
-        const response = yield userManagementClient.tempTrasmission(id);
-        const data = response.data.message;
-        const buf = Buffer.from(data, 'base64');
-        const res = Buffer.from(ECIESDecrypt(Buffer.from(secret, 'hex'), buf).buffer).toString('ucs2');
-        return res;
-    });
-}

package/dist/esm/types/config.js

@@ -1,19 +0,0 @@
-import { WalletType, } from '@getpara/user-management-client';
-export var Environment;
-(function (Environment) {
-    // Internal Environments
-    Environment["DEV"] = "DEV";
-    Environment["SANDBOX"] = "SANDBOX";
-    Environment["BETA"] = "BETA";
-    Environment["PROD"] = "PROD";
-    // Customer-Facing Environments
-    // NOTE: these resolve to the corresponding internal environments for convenience
-    Environment["DEVELOPMENT"] = "BETA";
-    Environment["PRODUCTION"] = "PROD";
-})(Environment || (Environment = {}));
-export var EnabledFlow;
-(function (EnabledFlow) {
-    EnabledFlow["BUY"] = "BUY";
-    EnabledFlow["RECEIVE"] = "RECEIVE";
-    EnabledFlow["WITHDRAW"] = "WITHDRAW";
-})(EnabledFlow || (EnabledFlow = {}));

package/dist/esm/types/events.js

@@ -1,14 +0,0 @@
-const EVENT_PREFIX = 'para';
-export var ParaEvent;
-(function (ParaEvent) {
-    ParaEvent["LOGIN_EVENT"] = "paraLogin";
-    ParaEvent["ACCOUNT_CREATION_EVENT"] = "paraAccountCreation";
-    ParaEvent["ACCOUNT_SETUP_EVENT"] = "paraAccountSetup";
-    ParaEvent["LOGOUT_EVENT"] = "paraLogout";
-    ParaEvent["SIGN_MESSAGE_EVENT"] = "paraSignMessage";
-    ParaEvent["SIGN_TRANSACTION_EVENT"] = "paraSignTransaction";
-    ParaEvent["EXTERNAL_WALLET_CHANGE_EVENT"] = "paraExternalWalletChange";
-    ParaEvent["WALLETS_CHANGE_EVENT"] = "paraWalletsChange";
-    ParaEvent["WALLET_CREATED"] = "paraWalletCreated";
-    ParaEvent["PREGEN_WALLET_CLAIMED"] = "paraPregenWalletClaimed";
-})(ParaEvent || (ParaEvent = {}));

package/dist/esm/types/index.js

@@ -1,9 +0,0 @@
-export * from './config.js';
-export * from './wallet.js';
-export * from './params.js';
-export * from './theme.js';
-export * from './onRamps.js';
-export * from './popup.js';
-export * from './recovery.js';
-export * from './events.js';
-export { Network, OnRampAsset, OnRampProvider, OnRampPurchaseStatus, } from '@getpara/user-management-client';

package/dist/esm/types/onRamps.js

@@ -1,7 +0,0 @@
-export var OnRampMethod;
-(function (OnRampMethod) {
-    OnRampMethod["ACH"] = "ACH";
-    OnRampMethod["DEBIT"] = "Debit";
-    OnRampMethod["CREDIT"] = "Credit";
-    OnRampMethod["APPLE_PAY"] = "Apple Pay";
-})(OnRampMethod || (OnRampMethod = {}));

package/dist/esm/types/params.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/types/popup.js

@@ -1,9 +0,0 @@
-export var PopupType;
-(function (PopupType) {
-    PopupType["SIGN_TRANSACTION_REVIEW"] = "SIGN_TRANSACTION_REVIEW";
-    PopupType["SIGN_MESSAGE_REVIEW"] = "SIGN_MESSAGE_REVIEW";
-    PopupType["LOGIN_PASSKEY"] = "LOGIN_PASSKEY";
-    PopupType["CREATE_PASSKEY"] = "CREATE_PASSKEY";
-    PopupType["OAUTH"] = "OAUTH";
-    PopupType["ON_RAMP_TRANSACTION"] = "ON_RAMP_TRANSACTION";
-})(PopupType || (PopupType = {}));