@getpara/core-sdk 0.1.0

package/dist/cjs/shares/KeyContainer.js

@@ -0,0 +1,84 @@
+"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 __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.KeyContainer = void 0;
+const ecies_js_1 = require("@celo/utils/lib/ecies.js");
+const eutil = __importStar(require("ethereumjs-util"));
+const forge = __importStar(require("node-forge"));
+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 = (0, ecies_js_1.Encrypt)(pubkey, Buffer.from(backup, 'ucs2')).toString('base64');
+            return data;
+        }
+        catch (error) {
+            throw Error('Error encrypting backup');
+        }
+    }
+    static encryptWithPublicKey(publicKey, backup) {
+        try {
+            const data = (0, ecies_js_1.Encrypt)(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 = (0, ecies_js_1.Decrypt)(Buffer.from(this.backupDecryptionKey, 'hex'), buf);
+            return Buffer.from(data.buffer).toString('ucs2');
+        }
+        catch (error) {
+            throw Error('Error decrypting backup');
+        }
+    }
+}
+exports.KeyContainer = KeyContainer;

package/dist/cjs/shares/recovery.js

@@ -0,0 +1,62 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendRecoveryForShare = void 0;
+const user_management_client_1 = require("@getpara/user-management-client");
+const KeyContainer_js_1 = require("./KeyContainer.js");
+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_js_1.KeyContainer(walletId, '', '');
+            const { recoveryPublicKeys } = yield ctx.client.persistRecoveryPublicKeys(userId, [
+                recoveryPrivateKeyContainer.getPublicEncryptionKeyHex(),
+            ]);
+            const encryptedUserBackup = recoveryPrivateKeyContainer.encryptForSelf(userSigner);
+            userBackupKeyShareOptsArr = [
+                {
+                    walletId,
+                    encryptedShare: encryptedUserBackup,
+                    type: user_management_client_1.KeyShareType.USER,
+                    encryptor: user_management_client_1.EncryptorType.RECOVERY,
+                    recoveryPublicKeyId: recoveryPublicKeys[0].id,
+                },
+            ];
+        }
+        else {
+            userBackupKeyShareOptsArr = recoveryPublicKeys.map(recoveryPublicKey => {
+                const { id: recoveryPublicKeyId, publicKey } = recoveryPublicKey;
+                const encryptedUserBackup = KeyContainer_js_1.KeyContainer.encryptWithPublicKey(Buffer.from(publicKey, 'hex'), userSigner);
+                return {
+                    walletId,
+                    encryptedShare: encryptedUserBackup,
+                    type: user_management_client_1.KeyShareType.USER,
+                    encryptor: user_management_client_1.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) : '';
+    });
+}
+exports.sendRecoveryForShare = sendRecoveryForShare;

package/dist/cjs/shares/shareDistribution.js

@@ -0,0 +1,67 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distributeNewShare = void 0;
+const user_management_client_1 = require("@getpara/user-management-client");
+const utils_js_1 = require("../cryptography/utils.js");
+const recovery_js_1 = require("./recovery.js");
+// function to call on new user share to perform all necessary distribution
+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 } = (0, utils_js_1.encryptWithDerivedPublicKey)(key.sigDerivedPublicKey, userShare);
+            return {
+                encryptedShare: encryptedMessageHex,
+                encryptedKey: encryptedKeyHex,
+                type: user_management_client_1.KeyShareType.USER,
+                encryptor: user_management_client_1.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 } = (0, utils_js_1.encryptWithDerivedPublicKey)(password.sigDerivedPublicKey, userShare);
+            return {
+                encryptedShare: encryptedMessageHex,
+                encryptedKey: encryptedKeyHex,
+                type: user_management_client_1.KeyShareType.USER,
+                encryptor: user_management_client_1.EncryptorType.PASSWORD,
+                passwordId: password.id,
+                partnerId,
+                protocolId,
+            };
+        })
+            .filter(Boolean);
+        const allEncryptedShares = [...biometricEncryptedShares, ...passwordEncryptedShares];
+        return yield (0, recovery_js_1.sendRecoveryForShare)({
+            ctx,
+            userId,
+            walletId,
+            otherEncryptedShares: allEncryptedShares,
+            userSigner: userShare,
+            ignoreRedistributingBackupEncryptedShare,
+            emailProps,
+        });
+    });
+}
+exports.distributeNewShare = distributeNewShare;

package/dist/cjs/transmission/transmissionUtils.js

@@ -0,0 +1,73 @@
+"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 __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;
+};
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieve = exports.upload = void 0;
+const crypto_1 = require("crypto");
+const ecies_js_1 = require("@celo/utils/lib/ecies.js");
+const buffer_1 = require("buffer");
+const eutil = __importStar(require("ethereumjs-util"));
+function upload(message, userManagementClient) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let secret;
+        let publicKeyUint8Array;
+        while (true) {
+            try {
+                secret = (0, crypto_1.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_1.Buffer.from(secret, 'hex'));
+                break;
+            }
+            catch (e) {
+                continue;
+            }
+        }
+        const pubkey = buffer_1.Buffer.from(publicKeyUint8Array);
+        const data = (0, ecies_js_1.Encrypt)(pubkey, buffer_1.Buffer.from(message, 'ucs2')).toString('base64');
+        const { data: { id }, } = yield userManagementClient.tempTrasmissionInit(data);
+        return encodeURIComponent(id + '|' + secret);
+    });
+}
+exports.upload = upload;
+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_1.Buffer.from(data, 'base64');
+        const res = buffer_1.Buffer.from((0, ecies_js_1.Decrypt)(buffer_1.Buffer.from(secret, 'hex'), buf).buffer).toString('ucs2');
+        return res;
+    });
+}
+exports.retrieve = retrieve;

package/dist/cjs/types/index.js

@@ -0,0 +1,20 @@
+"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 __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./walletTypes.js"), exports);
+__exportStar(require("./params.js"), exports);
+__exportStar(require("./theme.js"), exports);
+__exportStar(require("./popupTypes.js"), exports);

package/dist/cjs/types/params.js

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

package/dist/cjs/types/popupTypes.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PopupType = void 0;
+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 || (exports.PopupType = PopupType = {}));

package/dist/cjs/types/theme.js

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

package/dist/cjs/types/walletTypes.js

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

package/dist/cjs/utils/formattingUtils.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateAddress = exports.getCosmosAddress = exports.decimalToHex = exports.hexToDecimal = exports.hexToUint8Array = exports.hexToSignature = exports.hexStringToBase64 = void 0;
+const encoding_1 = require("@cosmjs/encoding");
+const sha256_1 = require("@noble/hashes/sha256");
+const ripemd160_1 = require("@noble/hashes/ripemd160");
+const elliptic_1 = __importDefault(require("elliptic"));
+const secp256k1 = new elliptic_1.default.ec('secp256k1');
+function hexStringToBase64(hexString) {
+    if (hexString.substring(0, 2) === '0x') {
+        hexString = hexString.substring(2);
+    }
+    return Buffer.from(hexString, 'hex').toString('base64');
+}
+exports.hexStringToBase64 = hexStringToBase64;
+function hexToSignature(hexSig) {
+    return {
+        r: `0x${hexSig.slice(2, 66)}`,
+        s: `0x${hexSig.slice(66, 130)}`,
+        v: BigInt(hexSig.slice(130, 132)),
+    };
+}
+exports.hexToSignature = hexToSignature;
+function hexToUint8Array(hex) {
+    if (hex.startsWith('0x')) {
+        hex = hex.slice(2);
+    }
+    return new Uint8Array(Buffer.from(hex, 'hex'));
+}
+exports.hexToUint8Array = hexToUint8Array;
+function hexToDecimal(hex) {
+    if (hex.startsWith('0x')) {
+        hex = hex.slice(2);
+    }
+    return `${parseInt(hex, 16)}`;
+}
+exports.hexToDecimal = hexToDecimal;
+function decimalToHex(decimal) {
+    return `0x${parseInt(decimal).toString(16)}`;
+}
+exports.decimalToHex = decimalToHex;
+function compressPubkey(pubkey) {
+    switch (pubkey.length) {
+        case 33:
+            return pubkey;
+        case 65:
+            return Uint8Array.from(secp256k1.keyFromPublic(pubkey).getPublic(true, 'array'));
+        default:
+            throw new Error('Invalid pubkey length');
+    }
+}
+function rawSecp256k1PubkeyToRawAddress(pubkeyData) {
+    if (pubkeyData.length !== 33) {
+        throw new Error(`Invalid Secp256k1 pubkey length (compressed): ${pubkeyData.length}`);
+    }
+    return (0, ripemd160_1.ripemd160)((0, sha256_1.sha256)(pubkeyData));
+}
+function getCosmosAddress(publicKey, prefix) {
+    const uncompressedPublicKey = new Uint8Array(Buffer.from(publicKey.startsWith('0x') ? publicKey.slice(2) : publicKey, 'hex'));
+    const compressedPublicKey = compressPubkey(uncompressedPublicKey);
+    return (0, encoding_1.toBech32)(prefix, rawSecp256k1PubkeyToRawAddress(compressedPublicKey));
+}
+exports.getCosmosAddress = getCosmosAddress;
+function truncateAddress(str, addressType, { prefix = addressType === 'COSMOS' ? 'cosmos' : undefined } = {}) {
+    const headLength = (addressType === 'COSMOS' ? prefix.length : addressType === 'SOLANA' ? 0 : 2) + 4;
+    return `${str.slice(0, headLength)}...${str.slice(-4)}`;
+}
+exports.truncateAddress = truncateAddress;

package/dist/cjs/utils/pollingUtils.js

@@ -0,0 +1,25 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilTrue = void 0;
+function waitUntilTrue(condition, timeoutMs, intervalMs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const start = Date.now();
+        while (Date.now() - start < timeoutMs) {
+            if (yield condition()) {
+                return true;
+            }
+            yield new Promise(resolve => setTimeout(resolve, intervalMs));
+        }
+        return false;
+    });
+}
+exports.waitUntilTrue = waitUntilTrue;