@getpara/core-sdk 0.1.0

package/dist/cjs/PlatformUtils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/StorageUtils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/cryptography/utils.js

@@ -0,0 +1,251 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decryptPrivateKeyWithPassword = exports.encryptPrivateKeyWithPassword = exports.hashPasswordWithSalt = exports.encryptWithDerivedPublicKey = exports.decryptPrivateKeyAndDecryptShare = exports.getDerivedPrivateKeyAndDecrypt = exports.decryptWithPrivateKey = exports.decryptWithKeyPair = exports.symmetricKeyEncryptMessage = exports.getPublicKeyFromSignature = exports.getAsymmetricKeyPair = exports.decryptPrivateKey = exports.encryptPrivateKey = exports.decodePrivateKeyPemHex = exports.encodePrivateKeyToPemHex = exports.publicKeyHexToPem = exports.publicKeyFromHex = exports.getPublicKeyHex = exports.getSHA256HashHex = void 0;
+const base64url_1 = __importDefault(require("base64url"));
+const node_forge_1 = __importDefault(require("node-forge"));
+const definitions_js_1 = require("../definitions.js");
+const rsa = node_forge_1.default.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]);
+function getSHA256HashHex(str) {
+    const md = node_forge_1.default.md.sha256.create();
+    md.update(str);
+    return md.digest().toHex();
+}
+exports.getSHA256HashHex = getSHA256HashHex;
+function getPublicKeyHex(keyPair) {
+    const pem = node_forge_1.default.pki.publicKeyToRSAPublicKeyPem(keyPair.publicKey);
+    return Buffer.from(pem, 'utf-8').toString('hex');
+}
+exports.getPublicKeyHex = getPublicKeyHex;
+function publicKeyFromHex(publicKeyHex) {
+    const pem = publicKeyHexToPem(publicKeyHex);
+    return node_forge_1.default.pki.publicKeyFromPem(pem);
+}
+exports.publicKeyFromHex = publicKeyFromHex;
+function publicKeyHexToPem(publicKeyHex) {
+    return Buffer.from(publicKeyHex, 'hex').toString('utf-8');
+}
+exports.publicKeyHexToPem = publicKeyHexToPem;
+function encodePrivateKeyToPemHex(keyPair) {
+    const pem = node_forge_1.default.pki.privateKeyToPem(keyPair.privateKey);
+    return Buffer.from(pem, 'utf-8').toString('hex');
+}
+exports.encodePrivateKeyToPemHex = encodePrivateKeyToPemHex;
+function decodePrivateKeyPemHex(privateKeyPemHex) {
+    const pem = Buffer.from(privateKeyPemHex, 'hex').toString('utf-8');
+    return node_forge_1.default.pki.privateKeyFromPem(pem);
+}
+exports.decodePrivateKeyPemHex = decodePrivateKeyPemHex;
+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');
+    });
+}
+exports.encryptPrivateKey = encryptPrivateKey;
+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;
+    });
+}
+exports.decryptPrivateKey = decryptPrivateKey;
+function getAsymmetricKeyPair(ctx, seedValue) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const prng = node_forge_1.default.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(`${(0, definitions_js_1.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);
+        }));
+    });
+}
+exports.getAsymmetricKeyPair = getAsymmetricKeyPair;
+function getPublicKeyFromSignature(ctx, userHandle) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const encodedUserHandle = base64url_1.default.encode(userHandle);
+        const keyPair = yield getAsymmetricKeyPair(ctx, encodedUserHandle);
+        return getPublicKeyHex(keyPair);
+    });
+}
+exports.getPublicKeyFromSignature = getPublicKeyFromSignature;
+// only use for one time key encryptions as iv is constant
+function symmetricKeyEncryptMessage(message) {
+    const key = node_forge_1.default.random.getBytesSync(16);
+    const cipher = node_forge_1.default.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(node_forge_1.default.util.createBuffer(message));
+    cipher.finish();
+    const encryptedMessageHex = cipher.output.toHex();
+    return { key, encryptedMessageHex };
+}
+exports.symmetricKeyEncryptMessage = symmetricKeyEncryptMessage;
+function decipherEncryptedMessageHex(key, encryptedMessageHex) {
+    const decipher = node_forge_1.default.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(node_forge_1.default.util.createBuffer(node_forge_1.default.util.hexToBytes(encryptedMessageHex)));
+    decipher.finish();
+    return decipher.output.toString();
+}
+// Deprecated in favor of decryptWithPrivateKey
+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);
+}
+exports.decryptWithKeyPair = decryptWithKeyPair;
+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);
+}
+exports.decryptWithPrivateKey = decryptWithPrivateKey;
+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);
+    });
+}
+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,
+            });
+        })));
+    });
+}
+exports.getDerivedPrivateKeyAndDecrypt = getDerivedPrivateKeyAndDecrypt;
+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,
+        }));
+    });
+}
+exports.decryptPrivateKeyAndDecryptShare = decryptPrivateKeyAndDecryptShare;
+function encryptWithDerivedPublicKey(publicKeyHex, message) {
+    const { key, encryptedMessageHex } = symmetricKeyEncryptMessage(message);
+    const publicKeyPem = publicKeyHexToPem(publicKeyHex);
+    const publicKey = node_forge_1.default.pki.publicKeyFromPem(publicKeyPem);
+    const encryptedKey = publicKey.encrypt(key, RSA_ENCRYPTION_SCHEME);
+    const encryptedKeyHex = Buffer.from(encryptedKey, 'utf-8').toString('hex');
+    return { encryptedMessageHex, encryptedKeyHex };
+}
+exports.encryptWithDerivedPublicKey = encryptWithDerivedPublicKey;
+function hashPasswordWithSalt(password) {
+    const salt = generateSalt();
+    const saltedPassword = salt + password;
+    const hash = getSHA256HashHex(saltedPassword);
+    return { salt, hash };
+}
+exports.hashPasswordWithSalt = hashPasswordWithSalt;
+function generateSalt(length = 16) {
+    return node_forge_1.default.util.bytesToHex(node_forge_1.default.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']);
+    });
+}
+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');
+    });
+}
+exports.encryptPrivateKeyWithPassword = encryptPrivateKeyWithPassword;
+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;
+    });
+}
+exports.decryptPrivateKeyWithPassword = decryptPrivateKeyWithPassword;

package/dist/cjs/definitions.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOnRampAssets = exports.getOnRampNetworks = exports.toAssetInfoArray = exports.CURRENT_WALLET_IDS_CHANGE_EVENT = exports.EXTERNAL_WALLET_CHANGE_EVENT = exports.getParaConnectBaseUrl = exports.getParaConnectDomain = exports.getPortalBaseURL = exports.getPortalDomain = exports.WalletSchemeTypeMap = exports.OnRampMethod = exports.EnabledFlow = exports.Environment = exports.is2FAEnabled = exports.OnRampPurchaseStatus = exports.OnRampProvider = exports.OnRampAsset = exports.Network = void 0;
+const buffer_1 = require("buffer");
+if (typeof global !== 'undefined') {
+    global.Buffer = global.Buffer || buffer_1.Buffer;
+}
+else if (typeof window !== 'undefined') {
+    window.Buffer = window.Buffer || buffer_1.Buffer;
+    window.global = window.global || window;
+}
+else {
+    self.Buffer = self.Buffer || buffer_1.Buffer;
+    self.global = self.global || self;
+}
+const user_management_client_1 = require("@getpara/user-management-client");
+Object.defineProperty(exports, "Network", { enumerable: true, get: function () { return user_management_client_1.Network; } });
+Object.defineProperty(exports, "OnRampAsset", { enumerable: true, get: function () { return user_management_client_1.OnRampAsset; } });
+Object.defineProperty(exports, "OnRampProvider", { enumerable: true, get: function () { return user_management_client_1.OnRampProvider; } });
+Object.defineProperty(exports, "OnRampPurchaseStatus", { enumerable: true, get: function () { return user_management_client_1.OnRampPurchaseStatus; } });
+exports.is2FAEnabled = false;
+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 || (exports.Environment = Environment = {}));
+var EnabledFlow;
+(function (EnabledFlow) {
+    EnabledFlow["BUY"] = "BUY";
+    EnabledFlow["RECEIVE"] = "RECEIVE";
+    EnabledFlow["WITHDRAW"] = "WITHDRAW";
+})(EnabledFlow || (exports.EnabledFlow = EnabledFlow = {}));
+var OnRampMethod;
+(function (OnRampMethod) {
+    OnRampMethod["ACH"] = "ACH";
+    OnRampMethod["DEBIT"] = "Debit";
+    OnRampMethod["CREDIT"] = "Credit";
+    OnRampMethod["APPLE_PAY"] = "Apple Pay";
+})(OnRampMethod || (exports.OnRampMethod = OnRampMethod = {}));
+exports.WalletSchemeTypeMap = {
+    [user_management_client_1.WalletScheme.DKLS]: {
+        [user_management_client_1.WalletType.EVM]: true,
+        [user_management_client_1.WalletType.COSMOS]: true,
+    },
+    [user_management_client_1.WalletScheme.CGGMP]: {
+        [user_management_client_1.WalletType.EVM]: true,
+        [user_management_client_1.WalletType.COSMOS]: true,
+    },
+    [user_management_client_1.WalletScheme.ED25519]: {
+        [user_management_client_1.WalletType.SOLANA]: true,
+    },
+};
+function getPortalDomain(env, isE2E) {
+    if (isE2E) {
+        return `localhost`;
+    }
+    switch (env) {
+        case Environment.DEV:
+            return 'localhost';
+        case Environment.SANDBOX:
+            return 'app.sandbox.usecapsule.com';
+        case Environment.BETA:
+            return 'app.beta.usecapsule.com';
+        case Environment.PROD:
+            return 'app.usecapsule.com';
+        default:
+            throw new Error(`env: ${env} not supported`);
+    }
+}
+exports.getPortalDomain = getPortalDomain;
+function getPortalBaseURL({ env, isE2E }, useLocalIp, isForWasm) {
+    if (isE2E) {
+        if (isForWasm) {
+            return `https://app.sandbox.usecapsule.com`;
+        }
+        return `http://localhost:3003`;
+    }
+    const domain = getPortalDomain(env);
+    if (env === Environment.DEV) {
+        if (useLocalIp) {
+            return `http://127.0.0.1:3003`;
+        }
+        return `http://${domain}:3003`;
+    }
+    return `https://${domain}`;
+}
+exports.getPortalBaseURL = getPortalBaseURL;
+function getParaConnectDomain(env) {
+    switch (env) {
+        case Environment.DEV:
+            return 'localhost';
+        case Environment.SANDBOX:
+            return 'connect.sandbox.getpara.com';
+        case Environment.BETA:
+            return 'connect.beta.getpara.com';
+        case Environment.PROD:
+            return 'connect.getpara.com';
+        default:
+            throw new Error(`env: ${env} not supported`);
+    }
+}
+exports.getParaConnectDomain = getParaConnectDomain;
+function getParaConnectBaseUrl({ env }, useLocalIp) {
+    const domain = getParaConnectDomain(env);
+    if (env === Environment.DEV) {
+        if (useLocalIp) {
+            return `http://127.0.0.1:3008`;
+        }
+        return `http://${domain}:3008`;
+    }
+    return `https://${domain}`;
+}
+exports.getParaConnectBaseUrl = getParaConnectBaseUrl;
+exports.EXTERNAL_WALLET_CHANGE_EVENT = 'paraExternalWalletChange';
+exports.CURRENT_WALLET_IDS_CHANGE_EVENT = 'paraCurrentWalletIdsChange';
+function toAssetInfoArray(data) {
+    const result = [];
+    Object.keys(data).forEach(walletType => {
+        const networks = data[walletType];
+        Object.keys(networks).forEach(network => {
+            const assets = networks[network];
+            Object.keys(assets).forEach(asset => {
+                const providerInfo = assets[asset];
+                result.push([walletType, network, asset, providerInfo]);
+            });
+        });
+    });
+    return result;
+}
+exports.toAssetInfoArray = toAssetInfoArray;
+function getOnRampNetworks(data, { walletType, allowed } = {}) {
+    return [
+        ...new Set(toAssetInfoArray(data)
+            .filter(([type, network]) => (!walletType || type === walletType) && (!allowed || allowed.includes(network)))
+            .map(([_, network]) => network)),
+    ];
+}
+exports.getOnRampNetworks = getOnRampNetworks;
+function getOnRampAssets(data, { walletType, network, allowed, } = {}) {
+    return [
+        ...new Set(toAssetInfoArray(data)
+            .filter(([t, n, a]) => (!walletType || t === walletType) &&
+            (!network || n === network) &&
+            (!Array.isArray(allowed) || allowed.includes(a)))
+            .map(([, , asset]) => asset)),
+    ];
+}
+exports.getOnRampAssets = getOnRampAssets;

package/dist/cjs/errors.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionReviewTimeout = exports.TransactionReviewDenied = exports.TransactionReviewError = void 0;
+class TransactionReviewError extends Error {
+    constructor(transactionReviewUrl) {
+        super('transaction review error');
+        this.name = 'TransactionReviewError';
+        this.transactionReviewUrl = transactionReviewUrl;
+    }
+}
+exports.TransactionReviewError = TransactionReviewError;
+class TransactionReviewDenied extends Error {
+    constructor() {
+        super('transaction review has been denied by the user');
+        this.name = 'TransactionReviewDenied';
+    }
+}
+exports.TransactionReviewDenied = TransactionReviewDenied;
+class TransactionReviewTimeout extends Error {
+    constructor(transactionReviewUrl, pendingTransactionId) {
+        super('transaction review has timed out');
+        this.name = 'TransactionReviewTimeout';
+        this.transactionReviewUrl = transactionReviewUrl;
+        this.pendingTransactionId = pendingTransactionId;
+    }
+}
+exports.TransactionReviewTimeout = TransactionReviewTimeout;

package/dist/cjs/external/mpcComputationClient.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+function initClient(baseURL, useAdapter) {
+    const client = axios_1.default.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;
+}
+exports.initClient = initClient;

package/dist/cjs/external/userManagementClient.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initClient = exports.getBaseMPCNetworkUrl = exports.getBaseUrl = void 0;
+const user_management_client_1 = __importDefault(require("@getpara/user-management-client"));
+const definitions_js_1 = require("../definitions.js");
+function getBaseUrl(env) {
+    switch (env) {
+        case definitions_js_1.Environment.DEV:
+            return 'http://localhost:8080/';
+        case definitions_js_1.Environment.SANDBOX:
+            return 'https://api.sandbox.getpara.com/';
+        case definitions_js_1.Environment.BETA:
+            return 'https://api.beta.getpara.com/';
+        case definitions_js_1.Environment.PROD:
+            return 'https://api.getpara.com/';
+        default:
+            throw new Error(`unsupported env: ${env}`);
+    }
+}
+exports.getBaseUrl = getBaseUrl;
+function getBaseMPCNetworkUrl(env, useWebsocket) {
+    const prefix = useWebsocket ? 'ws' : 'http';
+    switch (env) {
+        case definitions_js_1.Environment.DEV:
+            return `${prefix}://localhost:3000`;
+        case definitions_js_1.Environment.SANDBOX:
+            return `${prefix}s://mpc-network.sandbox.getpara.com`;
+        case definitions_js_1.Environment.BETA:
+            return `${prefix}s://mpc-network.beta.getpara.com`;
+        case definitions_js_1.Environment.PROD:
+            return `${prefix}s://mpc-network.prod.getpara.com`;
+        default:
+            throw new Error(`unsupported env: ${env}`);
+    }
+}
+exports.getBaseMPCNetworkUrl = getBaseMPCNetworkUrl;
+function initClient({ env, version, apiKey, partnerId, useFetchAdapter = false, retrieveSessionCookie, persistSessionCookie, }) {
+    return new user_management_client_1.default({
+        userManagementHost: getBaseUrl(env),
+        version: [definitions_js_1.Environment.DEV, definitions_js_1.Environment.SANDBOX].includes(env) ? 'dev' : version,
+        apiKey: apiKey,
+        partnerId,
+        opts: { useFetchAdapter },
+        retrieveSessionCookie,
+        persistSessionCookie,
+    });
+}
+exports.initClient = initClient;

package/dist/cjs/index.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paraVersion = exports.isWalletSupported = exports.PregenIdentifierType = exports.STORAGE_PREFIX = exports.transmissionUtilsRetrieve = exports.publicKeyFromHex = exports.decryptPrivateKeyWithPassword = exports.encryptPrivateKeyWithPassword = exports.hashPasswordWithSalt = exports.decryptPrivateKeyAndDecryptShare = exports.decryptPrivateKey = exports.encryptPrivateKey = exports.getSHA256HashHex = exports.getPublicKeyFromSignature = exports.getDerivedPrivateKeyAndDecrypt = exports.encodePrivateKeyToPemHex = exports.encryptWithDerivedPublicKey = exports.getPublicKeyHex = exports.getAsymmetricKeyPair = exports.decryptWithPrivateKey = exports.decryptWithKeyPair = exports.mpcComputationClient = exports.initClient = exports.getBaseUrl = exports.entityToWallet = exports.stringToPhoneNumber = exports.RecoveryStatus = exports.KeyContainer = exports.distributeNewShare = exports.PREGEN_IDENTIFIER_TYPES = exports.NON_ED25519 = exports.OAuthMethod = exports.OnRampPurchaseType = exports.WalletScheme = exports.WalletType = exports.EmailTheme = exports.AuthMethod = void 0;
+const ParaCore_js_1 = require("./ParaCore.js");
+Object.defineProperty(exports, "STORAGE_PREFIX", { enumerable: true, get: function () { return ParaCore_js_1.PREFIX; } });
+Object.defineProperty(exports, "PregenIdentifierType", { enumerable: true, get: function () { return ParaCore_js_1.PregenIdentifierType; } });
+Object.defineProperty(exports, "isWalletSupported", { enumerable: true, get: function () { return ParaCore_js_1.isWalletSupported; } });
+var user_management_client_1 = require("@getpara/user-management-client");
+Object.defineProperty(exports, "AuthMethod", { enumerable: true, get: function () { return user_management_client_1.AuthMethod; } });
+Object.defineProperty(exports, "EmailTheme", { enumerable: true, get: function () { return user_management_client_1.EmailTheme; } });
+Object.defineProperty(exports, "WalletType", { enumerable: true, get: function () { return user_management_client_1.WalletType; } });
+Object.defineProperty(exports, "WalletScheme", { enumerable: true, get: function () { return user_management_client_1.WalletScheme; } });
+Object.defineProperty(exports, "OnRampPurchaseType", { enumerable: true, get: function () { return user_management_client_1.OnRampPurchaseType; } });
+Object.defineProperty(exports, "OAuthMethod", { enumerable: true, get: function () { return user_management_client_1.OAuthMethod; } });
+Object.defineProperty(exports, "NON_ED25519", { enumerable: true, get: function () { return user_management_client_1.NON_ED25519; } });
+Object.defineProperty(exports, "PREGEN_IDENTIFIER_TYPES", { enumerable: true, get: function () { return user_management_client_1.PREGEN_IDENTIFIER_TYPES; } });
+__exportStar(require("./definitions.js"), exports);
+__exportStar(require("./types/index.js"), exports);
+var shareDistribution_js_1 = require("./shares/shareDistribution.js");
+Object.defineProperty(exports, "distributeNewShare", { enumerable: true, get: function () { return shareDistribution_js_1.distributeNewShare; } });
+var KeyContainer_js_1 = require("./shares/KeyContainer.js");
+Object.defineProperty(exports, "KeyContainer", { enumerable: true, get: function () { return KeyContainer_js_1.KeyContainer; } });
+var ParaCore_js_2 = require("./ParaCore.js");
+Object.defineProperty(exports, "RecoveryStatus", { enumerable: true, get: function () { return ParaCore_js_2.RecoveryStatus; } });
+Object.defineProperty(exports, "stringToPhoneNumber", { enumerable: true, get: function () { return ParaCore_js_2.stringToPhoneNumber; } });
+Object.defineProperty(exports, "entityToWallet", { enumerable: true, get: function () { return ParaCore_js_2.entityToWallet; } });
+var userManagementClient_js_1 = require("./external/userManagementClient.js");
+Object.defineProperty(exports, "getBaseUrl", { enumerable: true, get: function () { return userManagementClient_js_1.getBaseUrl; } });
+Object.defineProperty(exports, "initClient", { enumerable: true, get: function () { return userManagementClient_js_1.initClient; } });
+exports.mpcComputationClient = __importStar(require("./external/mpcComputationClient.js"));
+var utils_js_1 = require("./cryptography/utils.js");
+Object.defineProperty(exports, "decryptWithKeyPair", { enumerable: true, get: function () { return utils_js_1.decryptWithKeyPair; } });
+Object.defineProperty(exports, "decryptWithPrivateKey", { enumerable: true, get: function () { return utils_js_1.decryptWithPrivateKey; } });
+Object.defineProperty(exports, "getAsymmetricKeyPair", { enumerable: true, get: function () { return utils_js_1.getAsymmetricKeyPair; } });
+Object.defineProperty(exports, "getPublicKeyHex", { enumerable: true, get: function () { return utils_js_1.getPublicKeyHex; } });
+Object.defineProperty(exports, "encryptWithDerivedPublicKey", { enumerable: true, get: function () { return utils_js_1.encryptWithDerivedPublicKey; } });
+Object.defineProperty(exports, "encodePrivateKeyToPemHex", { enumerable: true, get: function () { return utils_js_1.encodePrivateKeyToPemHex; } });
+Object.defineProperty(exports, "getDerivedPrivateKeyAndDecrypt", { enumerable: true, get: function () { return utils_js_1.getDerivedPrivateKeyAndDecrypt; } });
+Object.defineProperty(exports, "getPublicKeyFromSignature", { enumerable: true, get: function () { return utils_js_1.getPublicKeyFromSignature; } });
+Object.defineProperty(exports, "getSHA256HashHex", { enumerable: true, get: function () { return utils_js_1.getSHA256HashHex; } });
+Object.defineProperty(exports, "encryptPrivateKey", { enumerable: true, get: function () { return utils_js_1.encryptPrivateKey; } });
+Object.defineProperty(exports, "decryptPrivateKey", { enumerable: true, get: function () { return utils_js_1.decryptPrivateKey; } });
+Object.defineProperty(exports, "decryptPrivateKeyAndDecryptShare", { enumerable: true, get: function () { return utils_js_1.decryptPrivateKeyAndDecryptShare; } });
+Object.defineProperty(exports, "hashPasswordWithSalt", { enumerable: true, get: function () { return utils_js_1.hashPasswordWithSalt; } });
+Object.defineProperty(exports, "encryptPrivateKeyWithPassword", { enumerable: true, get: function () { return utils_js_1.encryptPrivateKeyWithPassword; } });
+Object.defineProperty(exports, "decryptPrivateKeyWithPassword", { enumerable: true, get: function () { return utils_js_1.decryptPrivateKeyWithPassword; } });
+Object.defineProperty(exports, "publicKeyFromHex", { enumerable: true, get: function () { return utils_js_1.publicKeyFromHex; } });
+__exportStar(require("./external/userManagementClient.js"), exports);
+__exportStar(require("./utils/pollingUtils.js"), exports);
+__exportStar(require("./errors.js"), exports);
+__exportStar(require("./utils/formattingUtils.js"), exports);
+var transmissionUtils_js_1 = require("./transmission/transmissionUtils.js");
+Object.defineProperty(exports, "transmissionUtilsRetrieve", { enumerable: true, get: function () { return transmissionUtils_js_1.retrieve; } });
+exports.paraVersion = ParaCore_js_1.ParaCore.version;
+exports.default = ParaCore_js_1.ParaCore;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}