@bitgo/sdk-core 1.1.0-rc.2 → 1.1.0-rc.3

package/dist/src/bitgo/utils/tssUtils.js

@@ -0,0 +1,348 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TssUtils = void 0;
+/**
+ * @prettier
+ */
+const bs58 = __importStar(require("bs58"));
+const crypto = __importStar(require("crypto"));
+const _ = __importStar(require("lodash"));
+const openpgp = __importStar(require("openpgp"));
+const hdTree_1 = require("../../account-lib/mpc/hdTree");
+const tss_1 = __importDefault(require("../../account-lib/mpc/tss"));
+const mpcUtils_1 = require("./mpcUtils");
+const opengpgUtils_1 = require("./opengpgUtils");
+const tss_2 = require("../tss");
+/**
+ * Utility functions for TSS work flows.
+ */
+class TssUtils extends mpcUtils_1.MpcUtils {
+    constructor(bitgo, baseCoin, wallet) {
+        super(bitgo, baseCoin);
+        this._wallet = wallet;
+    }
+    get wallet() {
+        if (_.isNil(this._wallet)) {
+            throw new Error('Wallet not defined');
+        }
+        return this._wallet;
+    }
+    /**
+     * Creates a Keychain containing the User's TSS signing materials.
+     *
+     * @param userGpgKey - ephemeral GPG key to encrypt / decrypt sensitve data exchanged between user and server
+     * @param userKeyShare - user's TSS key share
+     * @param backupKeyShare - backup's TSS key share
+     * @param bitgoKeychain - previously created BitGo keychain; must be compatible with user and backup key shares
+     * @param passphrase - wallet passphrase used to encrypt user's signing materials
+     * @param [originalPasscodeEncryptionCode] - optional encryption code needed for wallet password reset for hot wallets
+     */
+    async createUserKeychain(userGpgKey, userKeyShare, backupKeyShare, bitgoKeychain, passphrase, originalPasscodeEncryptionCode) {
+        const MPC = await tss_1.default.initialize();
+        const bitgoKeyShares = bitgoKeychain.keyShares;
+        if (!bitgoKeyShares) {
+            throw new Error('Missing BitGo key shares');
+        }
+        const bitGoToUserShare = bitgoKeyShares.find((keyShare) => keyShare.from === 'bitgo' && keyShare.to === 'user');
+        if (!bitGoToUserShare) {
+            throw new Error('Missing BitGo to User key share');
+        }
+        const bitGoToUserPrivateShare = await this.decryptPrivateShare(bitGoToUserShare.privateShare, userGpgKey);
+        const bitgoToUser = {
+            i: 1,
+            j: 3,
+            y: bitGoToUserShare.publicShare.slice(0, 64),
+            u: bitGoToUserPrivateShare.slice(0, 64),
+            chaincode: bitGoToUserPrivateShare.slice(64),
+        };
+        // TODO(BG-47170): use tss.createCombinedKey helper when signatures are supported
+        const userCombined = MPC.keyCombine(userKeyShare.uShare, [backupKeyShare.yShares[1], bitgoToUser]);
+        const commonKeychain = userCombined.pShare.y + userCombined.pShare.chaincode;
+        if (commonKeychain !== bitgoKeychain.commonKeychain) {
+            throw new Error('Failed to create user keychain - commonKeychains do not match.');
+        }
+        const userSigningMaterial = {
+            uShare: userKeyShare.uShare,
+            bitgoYShare: bitgoToUser,
+            backupYShare: backupKeyShare.yShares[1],
+        };
+        const userKeychainParams = {
+            source: 'user',
+            keyType: 'tss',
+            commonKeychain: bitgoKeychain.commonKeychain,
+            encryptedPrv: this.bitgo.encrypt({ input: JSON.stringify(userSigningMaterial), password: passphrase }),
+            originalPasscodeEncryptionCode,
+        };
+        return await this.baseCoin.keychains().add(userKeychainParams);
+    }
+    /**
+     * Creates a Keychain containing the Backup party's TSS signing materials.
+     *
+     * @param userGpgKey - ephemeral GPG key to encrypt / decrypt sensitve data exchanged between user and server
+     * @param userKeyShare - User's TSS Keyshare
+     * @param backupKeyShare - Backup's TSS Keyshare
+     * @param bitgoKeychain - previously created BitGo keychain; must be compatible with user and backup key shares
+     * @param passphrase - wallet passphrase used to encrypt user's signing materials
+     */
+    async createBackupKeychain(userGpgKey, userKeyShare, backupKeyShare, bitgoKeychain, passphrase) {
+        const MPC = await tss_1.default.initialize();
+        const bitgoKeyShares = bitgoKeychain.keyShares;
+        if (!bitgoKeyShares) {
+            throw new Error('Invalid bitgo keyshares');
+        }
+        const bitGoToBackupShare = bitgoKeyShares.find((keyShare) => keyShare.from === 'bitgo' && keyShare.to === 'backup');
+        if (!bitGoToBackupShare) {
+            throw new Error('Missing BitGo to User key share');
+        }
+        const bitGoToBackupPrivateShare = await this.decryptPrivateShare(bitGoToBackupShare.privateShare, userGpgKey);
+        const bitgoToBackup = {
+            i: 2,
+            j: 3,
+            y: bitGoToBackupShare.publicShare.slice(0, 64),
+            u: bitGoToBackupPrivateShare.slice(0, 64),
+            chaincode: bitGoToBackupPrivateShare.slice(64),
+        };
+        // TODO(BG-47170): use tss.createCombinedKey helper when signatures are supported
+        const backupCombined = MPC.keyCombine(backupKeyShare.uShare, [userKeyShare.yShares[2], bitgoToBackup]);
+        const commonKeychain = backupCombined.pShare.y + backupCombined.pShare.chaincode;
+        if (commonKeychain !== bitgoKeychain.commonKeychain) {
+            throw new Error('Failed to create backup keychain - commonKeychains do not match.');
+        }
+        const backupSigningMaterial = {
+            uShare: backupKeyShare.uShare,
+            bitgoYShare: bitgoToBackup,
+            userYShare: userKeyShare.yShares[2],
+        };
+        const prv = JSON.stringify(backupSigningMaterial);
+        return await this.baseCoin.keychains().createBackup({
+            source: 'backup',
+            keyType: 'tss',
+            commonKeychain: bitgoKeychain.commonKeychain,
+            prv: prv,
+            encryptedPrv: this.bitgo.encrypt({ input: prv, password: passphrase }),
+        });
+    }
+    /**
+     * Creates a Keychain containing BitGo's TSS signing materials.
+     *
+     * @param userGpgKey - ephemeral GPG key to encrypt / decrypt sensitve data exchanged between user and server
+     * @param userKeyShare - user's TSS key share
+     * @param backupKeyShare - backup's TSS key share
+     */
+    async createBitgoKeychain(userGpgKey, userKeyShare, backupKeyShare, enterprise) {
+        // TODO(BG-47170): use tss.encryptYShare helper when signatures are supported
+        const userToBitgoPublicShare = Buffer.concat([
+            Buffer.from(userKeyShare.uShare.y, 'hex'),
+            Buffer.from(userKeyShare.uShare.chaincode, 'hex'),
+        ]).toString('hex');
+        const userToBitgoPrivateShare = Buffer.concat([
+            Buffer.from(userKeyShare.yShares[3].u, 'hex'),
+            Buffer.from(userKeyShare.yShares[3].chaincode, 'hex'),
+        ]).toString('hex');
+        const userToBitgoKeyShare = {
+            publicShare: userToBitgoPublicShare,
+            privateShare: userToBitgoPrivateShare,
+        };
+        const backupToBitgoPublicShare = Buffer.concat([
+            Buffer.from(backupKeyShare.uShare.y, 'hex'),
+            Buffer.from(backupKeyShare.uShare.chaincode, 'hex'),
+        ]).toString('hex');
+        const backupToBitgoPrivateShare = Buffer.concat([
+            Buffer.from(backupKeyShare.yShares[3].u, 'hex'),
+            Buffer.from(backupKeyShare.yShares[3].chaincode, 'hex'),
+        ]).toString('hex');
+        const backupToBitgoKeyShare = {
+            publicShare: backupToBitgoPublicShare,
+            privateShare: backupToBitgoPrivateShare,
+        };
+        return await this.createBitgoKeychainInWP(userGpgKey, userToBitgoKeyShare, backupToBitgoKeyShare, 'tss', enterprise);
+    }
+    /**
+     * Creates User, Backup, and BitGo TSS Keychains.
+     *
+     * @param params.passphrase - passphrase used to encrypt signing materials created for User and Backup
+     */
+    async createKeychains(params) {
+        const MPC = await tss_1.default.initialize();
+        const m = 2;
+        const n = 3;
+        const userKeyShare = MPC.keyShare(1, m, n);
+        const backupKeyShare = MPC.keyShare(2, m, n);
+        const randomHexString = crypto.randomBytes(12).toString('hex');
+        const userGpgKey = await openpgp.generateKey({
+            userIDs: [
+                {
+                    name: randomHexString,
+                    email: `${randomHexString}@${randomHexString}.com`,
+                },
+            ],
+        });
+        const bitgoKeychain = await this.createBitgoKeychain(userGpgKey, userKeyShare, backupKeyShare, params.enterprise);
+        const userKeychainPromise = this.createUserKeychain(userGpgKey, userKeyShare, backupKeyShare, bitgoKeychain, params.passphrase, params.originalPasscodeEncryptionCode);
+        const backupKeychainPromise = this.createBackupKeychain(userGpgKey, userKeyShare, backupKeyShare, bitgoKeychain, params.passphrase);
+        const [userKeychain, backupKeychain] = await Promise.all([userKeychainPromise, backupKeychainPromise]);
+        // create wallet
+        const keychains = {
+            userKeychain,
+            backupKeychain,
+            bitgoKeychain,
+        };
+        return keychains;
+    }
+    /**
+     * Signs the transaction associated to the transaction request.
+     *
+     * @param txRequest - transaction request object or id
+     * @param prv - decrypted private key
+     * @param reqId - request id
+     * @returns {Promise<TxRequest>} fully signed TxRequest object
+     */
+    async signTxRequest(params) {
+        let txRequestResolved;
+        let txRequestId;
+        const { txRequest, prv } = params;
+        if (typeof txRequest === 'string') {
+            txRequestResolved = await tss_2.getTxRequest(this.bitgo, this.wallet.id(), txRequest);
+            txRequestId = txRequestResolved.txRequestId;
+        }
+        else {
+            txRequestResolved = txRequest;
+            txRequestId = txRequest.txRequestId;
+        }
+        const hdTree = await hdTree_1.Ed25519BIP32.initialize();
+        const MPC = await tss_1.default.initialize(hdTree);
+        const userSigningMaterial = JSON.parse(prv);
+        if (!userSigningMaterial.backupYShare) {
+            throw new Error('Invalid user key - missing backupYShare');
+        }
+        const signingKey = MPC.keyDerive(userSigningMaterial.uShare, [userSigningMaterial.bitgoYShare, userSigningMaterial.backupYShare], txRequestResolved.unsignedTxs[0].derivationPath);
+        const signablePayload = Buffer.from(txRequestResolved.unsignedTxs[0].signableHex, 'hex');
+        const userSignShare = await tss_2.createUserSignShare(signablePayload, signingKey.pShare);
+        const signerShare = signingKey.yShares[3].u + signingKey.yShares[3].chaincode;
+        const bitgoGpgKey = await opengpgUtils_1.getBitgoGpgPubKey(this.bitgo);
+        const encryptedSignerShare = await opengpgUtils_1.encryptText(signerShare, bitgoGpgKey);
+        await tss_2.offerUserToBitgoRShare(this.bitgo, this.wallet.id(), txRequestId, userSignShare, encryptedSignerShare);
+        const bitgoToUserRShare = await tss_2.getBitgoToUserRShare(this.bitgo, this.wallet.id(), txRequestId);
+        const userToBitGoGShare = await tss_2.createUserToBitGoGShare(userSignShare, bitgoToUserRShare, userSigningMaterial.backupYShare, userSigningMaterial.bitgoYShare, signablePayload);
+        await tss_2.sendUserToBitgoGShare(this.bitgo, this.wallet.id(), txRequestId, userToBitGoGShare);
+        return await tss_2.getTxRequest(this.bitgo, this.wallet.id(), txRequestId);
+    }
+    /**
+     * Builds a tx request from params and verify it
+     *
+     * @param {PrebuildTransactionWithIntentOptions} params - parameters to build the tx
+     * @param apiVersion
+     * @returns {Promise<TxRequest>} - a built tx request
+     */
+    async prebuildTxWithIntent(params, apiVersion = 'lite') {
+        var _a;
+        const chain = this.baseCoin.getChain();
+        const intentRecipients = params.recipients.map((recipient) => ({
+            address: { address: recipient.address },
+            amount: { value: `${recipient.amount}`, symbol: chain },
+        }));
+        const whitelistedParams = {
+            intent: {
+                intentType: params.intentType,
+                sequenceId: params.sequenceId,
+                comment: params.comment,
+                recipients: intentRecipients,
+                memo: (_a = params.memo) === null || _a === void 0 ? void 0 : _a.value,
+                token: params.tokenName,
+                nonce: params.nonce,
+            },
+            apiVersion: apiVersion,
+        };
+        const unsignedTx = (await this.bitgo
+            .post(this.bitgo.url('/wallet/' + this.wallet.id() + '/txrequests', 2))
+            .send(whitelistedParams)
+            .result());
+        return unsignedTx;
+    }
+    /**
+     * Call delete signature shares for a txRequest, the endpoint delete the signatures and return them
+     *
+     * @param {string} txRequestId tx id reference to delete signature shares
+     * @returns {SignatureShareRecord[]}
+     */
+    async deleteSignatureShares(txRequestId) {
+        return this.bitgo
+            .del(this.bitgo.url(`/wallet/${this.wallet.id()}/txrequests/${txRequestId}/signatureshares`, 2))
+            .send()
+            .result();
+    }
+    /**
+     * Initialize the send procedure once Bitgo has the User To Bitgo GShare
+     *
+     * @param {String} txRequestId - the txRequest Id
+     * @returns {Promise<any>}
+     */
+    async sendTxRequest(txRequestId) {
+        return this.bitgo
+            .post(this.baseCoin.url('/wallet/' + this.wallet.id() + '/tx/send'))
+            .send({ txRequestId })
+            .result();
+    }
+    /**
+     * Delete signature shares, get the tx request without them from the db and sign it to finally send it.
+     *
+     * Note : This can be performed in order to reach latest network conditions required on pending approval flow.
+     *
+     * @param {String} txRequestId - the txRequest Id to make the requests.
+     * @param {String} decryptedPrv - decrypted prv to sign the tx request.
+     * @param {RequestTracer} reqId id tracer.
+     * @returns {Promise<any>}
+     */
+    async recreateTxRequest(txRequestId, decryptedPrv, reqId) {
+        await this.deleteSignatureShares(txRequestId);
+        // after delete signatures shares get the tx without them
+        const txRequest = await tss_2.getTxRequest(this.bitgo, this.wallet.id(), txRequestId);
+        return await this.signTxRequest({ txRequest, prv: decryptedPrv, reqId });
+    }
+    /**
+     * Gets the latest Tx Request by id
+     *
+     * @param {String} txRequestId - the txRequest Id
+     * @returns {Promise<TxRequest>}
+     */
+    async getTxRequest(txRequestId) {
+        return tss_2.getTxRequest(this.bitgo, this.wallet.id(), txRequestId);
+    }
+    /**
+     * Get the commonPub portion of the commonKeychain.
+     *
+     * @param {String} commonKeychain
+     * @returns {string}
+     */
+    static getPublicKeyFromCommonKeychain(commonKeychain) {
+        if (commonKeychain.length !== 128) {
+            throw new Error(`Invalid commonKeychain length, expected 128, got ${commonKeychain.length}`);
+        }
+        const commonPubHexStr = commonKeychain.slice(0, 64);
+        return bs58.encode(Buffer.from(commonPubHexStr, 'hex'));
+    }
+}
+exports.TssUtils = TssUtils;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tssUtils.js","sourceRoot":"","sources":["../../../../src/bitgo/utils/tssUtils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport * as bs58 from 'bs58';\nimport * as crypto from 'crypto';\nimport * as _ from 'lodash';\nimport * as openpgp from 'openpgp';\nimport { Ed25519BIP32 } from '../../account-lib/mpc/hdTree';\nimport Eddsa, { KeyShare, YShare } from '../../account-lib/mpc/tss';\nimport { IRequestTracer } from '../../api';\nimport { IBaseCoin, KeychainsTriplet } from '../baseCoin';\nimport { BitGoBase } from '../bitgoBase';\nimport { AddKeychainOptions, Keychain, KeyType } from '../keychain';\nimport { IWallet } from '../wallet';\nimport { ITssUtils, PrebuildTransactionWithIntentOptions, SignatureShareRecord, TxRequest } from './iTssUtils';\nimport { MpcUtils } from './mpcUtils';\nimport { encryptText, getBitgoGpgPubKey } from './opengpgUtils';\nimport {\n  createUserSignShare,\n  createUserToBitGoGShare,\n  getBitgoToUserRShare,\n  getTxRequest,\n  offerUserToBitgoRShare,\n  sendUserToBitgoGShare,\n  SigningMaterial,\n} from '../tss';\n\n/**\n * Utility functions for TSS work flows.\n */\n\nexport class TssUtils extends MpcUtils implements ITssUtils {\n  private _wallet?: IWallet;\n\n  constructor(bitgo: BitGoBase, baseCoin: IBaseCoin, wallet?: IWallet) {\n    super(bitgo, baseCoin);\n    this._wallet = wallet;\n  }\n\n  private get wallet(): IWallet {\n    if (_.isNil(this._wallet)) {\n      throw new Error('Wallet not defined');\n    }\n    return this._wallet;\n  }\n\n  /**\n   * Creates a Keychain containing the User's TSS signing materials.\n   *\n   * @param userGpgKey - ephemeral GPG key to encrypt / decrypt sensitve data exchanged between user and server\n   * @param userKeyShare - user's TSS key share\n   * @param backupKeyShare - backup's TSS key share\n   * @param bitgoKeychain - previously created BitGo keychain; must be compatible with user and backup key shares\n   * @param passphrase - wallet passphrase used to encrypt user's signing materials\n   * @param [originalPasscodeEncryptionCode] - optional encryption code needed for wallet password reset for hot wallets\n   */\n  async createUserKeychain(\n    userGpgKey: openpgp.SerializedKeyPair<string>,\n    userKeyShare: KeyShare,\n    backupKeyShare: KeyShare,\n    bitgoKeychain: Keychain,\n    passphrase: string,\n    originalPasscodeEncryptionCode?: string\n  ): Promise<Keychain> {\n    const MPC = await Eddsa.initialize();\n    const bitgoKeyShares = bitgoKeychain.keyShares;\n    if (!bitgoKeyShares) {\n      throw new Error('Missing BitGo key shares');\n    }\n\n    const bitGoToUserShare = bitgoKeyShares.find((keyShare) => keyShare.from === 'bitgo' && keyShare.to === 'user');\n    if (!bitGoToUserShare) {\n      throw new Error('Missing BitGo to User key share');\n    }\n\n    const bitGoToUserPrivateShare = await this.decryptPrivateShare(bitGoToUserShare.privateShare, userGpgKey);\n\n    const bitgoToUser: YShare = {\n      i: 1,\n      j: 3,\n      y: bitGoToUserShare.publicShare.slice(0, 64),\n      u: bitGoToUserPrivateShare.slice(0, 64),\n      chaincode: bitGoToUserPrivateShare.slice(64),\n    };\n\n    // TODO(BG-47170): use tss.createCombinedKey helper when signatures are supported\n    const userCombined = MPC.keyCombine(userKeyShare.uShare, [backupKeyShare.yShares[1], bitgoToUser]);\n    const commonKeychain = userCombined.pShare.y + userCombined.pShare.chaincode;\n    if (commonKeychain !== bitgoKeychain.commonKeychain) {\n      throw new Error('Failed to create user keychain - commonKeychains do not match.');\n    }\n\n    const userSigningMaterial: SigningMaterial = {\n      uShare: userKeyShare.uShare,\n      bitgoYShare: bitgoToUser,\n      backupYShare: backupKeyShare.yShares[1],\n    };\n\n    const userKeychainParams: AddKeychainOptions = {\n      source: 'user',\n      keyType: 'tss' as KeyType,\n      commonKeychain: bitgoKeychain.commonKeychain,\n      encryptedPrv: this.bitgo.encrypt({ input: JSON.stringify(userSigningMaterial), password: passphrase }),\n      originalPasscodeEncryptionCode,\n    };\n\n    return await this.baseCoin.keychains().add(userKeychainParams);\n  }\n\n  /**\n   * Creates a Keychain containing the Backup party's TSS signing materials.\n   *\n   * @param userGpgKey - ephemeral GPG key to encrypt / decrypt sensitve data exchanged between user and server\n   * @param userKeyShare - User's TSS Keyshare\n   * @param backupKeyShare - Backup's TSS Keyshare\n   * @param bitgoKeychain - previously created BitGo keychain; must be compatible with user and backup key shares\n   * @param passphrase - wallet passphrase used to encrypt user's signing materials\n   */\n  async createBackupKeychain(\n    userGpgKey: openpgp.SerializedKeyPair<string>,\n    userKeyShare: KeyShare,\n    backupKeyShare: KeyShare,\n    bitgoKeychain: Keychain,\n    passphrase: string\n  ): Promise<Keychain> {\n    const MPC = await Eddsa.initialize();\n    const bitgoKeyShares = bitgoKeychain.keyShares;\n    if (!bitgoKeyShares) {\n      throw new Error('Invalid bitgo keyshares');\n    }\n\n    const bitGoToBackupShare = bitgoKeyShares.find((keyShare) => keyShare.from === 'bitgo' && keyShare.to === 'backup');\n    if (!bitGoToBackupShare) {\n      throw new Error('Missing BitGo to User key share');\n    }\n\n    const bitGoToBackupPrivateShare = await this.decryptPrivateShare(bitGoToBackupShare.privateShare, userGpgKey);\n\n    const bitgoToBackup: YShare = {\n      i: 2,\n      j: 3,\n      y: bitGoToBackupShare.publicShare.slice(0, 64),\n      u: bitGoToBackupPrivateShare.slice(0, 64),\n      chaincode: bitGoToBackupPrivateShare.slice(64),\n    };\n\n    // TODO(BG-47170): use tss.createCombinedKey helper when signatures are supported\n    const backupCombined = MPC.keyCombine(backupKeyShare.uShare, [userKeyShare.yShares[2], bitgoToBackup]);\n    const commonKeychain = backupCombined.pShare.y + backupCombined.pShare.chaincode;\n    if (commonKeychain !== bitgoKeychain.commonKeychain) {\n      throw new Error('Failed to create backup keychain - commonKeychains do not match.');\n    }\n\n    const backupSigningMaterial: SigningMaterial = {\n      uShare: backupKeyShare.uShare,\n      bitgoYShare: bitgoToBackup,\n      userYShare: userKeyShare.yShares[2],\n    };\n    const prv = JSON.stringify(backupSigningMaterial);\n\n    return await this.baseCoin.keychains().createBackup({\n      source: 'backup',\n      keyType: 'tss',\n      commonKeychain: bitgoKeychain.commonKeychain,\n      prv: prv,\n      encryptedPrv: this.bitgo.encrypt({ input: prv, password: passphrase }),\n    });\n  }\n\n  /**\n   * Creates a Keychain containing BitGo's TSS signing materials.\n   *\n   * @param userGpgKey - ephemeral GPG key to encrypt / decrypt sensitve data exchanged between user and server\n   * @param userKeyShare - user's TSS key share\n   * @param backupKeyShare - backup's TSS key share\n   */\n  async createBitgoKeychain(\n    userGpgKey: openpgp.SerializedKeyPair<string>,\n    userKeyShare: KeyShare,\n    backupKeyShare: KeyShare,\n    enterprise?: string\n  ): Promise<Keychain> {\n    // TODO(BG-47170): use tss.encryptYShare helper when signatures are supported\n    const userToBitgoPublicShare = Buffer.concat([\n      Buffer.from(userKeyShare.uShare.y, 'hex'),\n      Buffer.from(userKeyShare.uShare.chaincode, 'hex'),\n    ]).toString('hex');\n    const userToBitgoPrivateShare = Buffer.concat([\n      Buffer.from(userKeyShare.yShares[3].u, 'hex'),\n      Buffer.from(userKeyShare.yShares[3].chaincode, 'hex'),\n    ]).toString('hex');\n    const userToBitgoKeyShare = {\n      publicShare: userToBitgoPublicShare,\n      privateShare: userToBitgoPrivateShare,\n    };\n\n    const backupToBitgoPublicShare = Buffer.concat([\n      Buffer.from(backupKeyShare.uShare.y, 'hex'),\n      Buffer.from(backupKeyShare.uShare.chaincode, 'hex'),\n    ]).toString('hex');\n    const backupToBitgoPrivateShare = Buffer.concat([\n      Buffer.from(backupKeyShare.yShares[3].u, 'hex'),\n      Buffer.from(backupKeyShare.yShares[3].chaincode, 'hex'),\n    ]).toString('hex');\n    const backupToBitgoKeyShare = {\n      publicShare: backupToBitgoPublicShare,\n      privateShare: backupToBitgoPrivateShare,\n    };\n\n    return await this.createBitgoKeychainInWP(\n      userGpgKey,\n      userToBitgoKeyShare,\n      backupToBitgoKeyShare,\n      'tss',\n      enterprise\n    );\n  }\n\n  /**\n   * Creates User, Backup, and BitGo TSS Keychains.\n   *\n   * @param params.passphrase - passphrase used to encrypt signing materials created for User and Backup\n   */\n  async createKeychains(params: {\n    passphrase: string;\n    enterprise?: string;\n    originalPasscodeEncryptionCode?: string;\n  }): Promise<KeychainsTriplet> {\n    const MPC = await Eddsa.initialize();\n    const m = 2;\n    const n = 3;\n\n    const userKeyShare = MPC.keyShare(1, m, n);\n    const backupKeyShare = MPC.keyShare(2, m, n);\n\n    const randomHexString = crypto.randomBytes(12).toString('hex');\n\n    const userGpgKey = await openpgp.generateKey({\n      userIDs: [\n        {\n          name: randomHexString,\n          email: `${randomHexString}@${randomHexString}.com`,\n        },\n      ],\n    });\n\n    const bitgoKeychain = await this.createBitgoKeychain(userGpgKey, userKeyShare, backupKeyShare, params.enterprise);\n    const userKeychainPromise = this.createUserKeychain(\n      userGpgKey,\n      userKeyShare,\n      backupKeyShare,\n      bitgoKeychain,\n      params.passphrase,\n      params.originalPasscodeEncryptionCode\n    );\n    const backupKeychainPromise = this.createBackupKeychain(\n      userGpgKey,\n      userKeyShare,\n      backupKeyShare,\n      bitgoKeychain,\n      params.passphrase\n    );\n    const [userKeychain, backupKeychain] = await Promise.all([userKeychainPromise, backupKeychainPromise]);\n\n    // create wallet\n    const keychains = {\n      userKeychain,\n      backupKeychain,\n      bitgoKeychain,\n    };\n\n    return keychains;\n  }\n\n  /**\n   * Signs the transaction associated to the transaction request.\n   *\n   * @param txRequest - transaction request object or id\n   * @param prv - decrypted private key\n   * @param reqId - request id\n   * @returns {Promise<TxRequest>} fully signed TxRequest object\n   */\n  async signTxRequest(params: {\n    txRequest: string | TxRequest;\n    prv: string;\n    reqId: IRequestTracer;\n  }): Promise<TxRequest> {\n    let txRequestResolved: TxRequest;\n    let txRequestId: string;\n\n    const { txRequest, prv } = params;\n\n    if (typeof txRequest === 'string') {\n      txRequestResolved = await getTxRequest(this.bitgo, this.wallet.id(), txRequest);\n      txRequestId = txRequestResolved.txRequestId;\n    } else {\n      txRequestResolved = txRequest;\n      txRequestId = txRequest.txRequestId;\n    }\n\n    const hdTree = await Ed25519BIP32.initialize();\n    const MPC = await Eddsa.initialize(hdTree);\n\n    const userSigningMaterial: SigningMaterial = JSON.parse(prv);\n    if (!userSigningMaterial.backupYShare) {\n      throw new Error('Invalid user key - missing backupYShare');\n    }\n\n    const signingKey = MPC.keyDerive(\n      userSigningMaterial.uShare,\n      [userSigningMaterial.bitgoYShare, userSigningMaterial.backupYShare],\n      txRequestResolved.unsignedTxs[0].derivationPath\n    );\n\n    const signablePayload = Buffer.from(txRequestResolved.unsignedTxs[0].signableHex, 'hex');\n\n    const userSignShare = await createUserSignShare(signablePayload, signingKey.pShare);\n\n    const signerShare = signingKey.yShares[3].u + signingKey.yShares[3].chaincode;\n    const bitgoGpgKey = await getBitgoGpgPubKey(this.bitgo);\n    const encryptedSignerShare = await encryptText(signerShare, bitgoGpgKey);\n\n    await offerUserToBitgoRShare(this.bitgo, this.wallet.id(), txRequestId, userSignShare, encryptedSignerShare);\n\n    const bitgoToUserRShare = await getBitgoToUserRShare(this.bitgo, this.wallet.id(), txRequestId);\n\n    const userToBitGoGShare = await createUserToBitGoGShare(\n      userSignShare,\n      bitgoToUserRShare,\n      userSigningMaterial.backupYShare,\n      userSigningMaterial.bitgoYShare,\n      signablePayload\n    );\n\n    await sendUserToBitgoGShare(this.bitgo, this.wallet.id(), txRequestId, userToBitGoGShare);\n\n    return await getTxRequest(this.bitgo, this.wallet.id(), txRequestId);\n  }\n\n  /**\n   * Builds a tx request from params and verify it\n   *\n   * @param {PrebuildTransactionWithIntentOptions} params - parameters to build the tx\n   * @param apiVersion\n   * @returns {Promise<TxRequest>} - a built tx request\n   */\n  async prebuildTxWithIntent(params: PrebuildTransactionWithIntentOptions, apiVersion = 'lite'): Promise<TxRequest> {\n    const chain = this.baseCoin.getChain();\n    const intentRecipients = params.recipients.map((recipient) => ({\n      address: { address: recipient.address },\n      amount: { value: `${recipient.amount}`, symbol: chain },\n    }));\n\n    const whitelistedParams = {\n      intent: {\n        intentType: params.intentType,\n        sequenceId: params.sequenceId,\n        comment: params.comment,\n        recipients: intentRecipients,\n        memo: params.memo?.value,\n        token: params.tokenName,\n        nonce: params.nonce,\n      },\n      apiVersion: apiVersion,\n    };\n\n    const unsignedTx = (await this.bitgo\n      .post(this.bitgo.url('/wallet/' + this.wallet.id() + '/txrequests', 2))\n      .send(whitelistedParams)\n      .result()) as TxRequest;\n\n    return unsignedTx;\n  }\n\n  /**\n   * Call delete signature shares for a txRequest, the endpoint delete the signatures and return them\n   *\n   * @param {string} txRequestId tx id reference to delete signature shares\n   * @returns {SignatureShareRecord[]}\n   */\n  async deleteSignatureShares(txRequestId: string): Promise<SignatureShareRecord[]> {\n    return this.bitgo\n      .del(this.bitgo.url(`/wallet/${this.wallet.id()}/txrequests/${txRequestId}/signatureshares`, 2))\n      .send()\n      .result();\n  }\n\n  /**\n   * Initialize the send procedure once Bitgo has the User To Bitgo GShare\n   *\n   * @param {String} txRequestId - the txRequest Id\n   * @returns {Promise<any>}\n   */\n  async sendTxRequest(txRequestId: string): Promise<any> {\n    return this.bitgo\n      .post(this.baseCoin.url('/wallet/' + this.wallet.id() + '/tx/send'))\n      .send({ txRequestId })\n      .result();\n  }\n\n  /**\n   * Delete signature shares, get the tx request without them from the db and sign it to finally send it.\n   *\n   * Note : This can be performed in order to reach latest network conditions required on pending approval flow.\n   *\n   * @param {String} txRequestId - the txRequest Id to make the requests.\n   * @param {String} decryptedPrv - decrypted prv to sign the tx request.\n   * @param {RequestTracer} reqId id tracer.\n   * @returns {Promise<any>}\n   */\n  async recreateTxRequest(txRequestId: string, decryptedPrv: string, reqId: IRequestTracer): Promise<TxRequest> {\n    await this.deleteSignatureShares(txRequestId);\n    // after delete signatures shares get the tx without them\n    const txRequest = await getTxRequest(this.bitgo, this.wallet.id(), txRequestId);\n    return await this.signTxRequest({ txRequest, prv: decryptedPrv, reqId });\n  }\n\n  /**\n   * Gets the latest Tx Request by id\n   *\n   * @param {String} txRequestId - the txRequest Id\n   * @returns {Promise<TxRequest>}\n   */\n  async getTxRequest(txRequestId: string): Promise<TxRequest> {\n    return getTxRequest(this.bitgo, this.wallet.id(), txRequestId);\n  }\n\n  /**\n   * Get the commonPub portion of the commonKeychain.\n   *\n   * @param {String} commonKeychain\n   * @returns {string}\n   */\n  static getPublicKeyFromCommonKeychain(commonKeychain: string): string {\n    if (commonKeychain.length !== 128) {\n      throw new Error(`Invalid commonKeychain length, expected 128, got ${commonKeychain.length}`);\n    }\n    const commonPubHexStr = commonKeychain.slice(0, 64);\n    return bs58.encode(Buffer.from(commonPubHexStr, 'hex'));\n  }\n}\n"]}

package/dist/src/bitgo/utils/util.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @prettier
+ * @hidden
+ */
+import { IRequestTracer } from '../../api';
+/**
+ * Create a request tracer for tracing workflows which involve multiple round trips to the server
+ */
+export declare class RequestTracer implements IRequestTracer {
+    private _seq;
+    private readonly _seed;
+    constructor();
+    inc(): void;
+    toString(): string;
+}
+export declare class Util {
+    private constructor();
+    /**
+     * @deprecated
+     */
+    static isEthAvailable(): boolean;
+    /**
+     * Convert a big.js big number to an array of unsigned bytes
+     * @param bn
+     * @deprecated
+     */
+    static bnToByteArrayUnsigned(bn: any): any;
+    /**
+     * Utility method for handling arguments of pageable queries
+     * @param params
+     * @deprecated
+     */
+    static preparePageableQuery(params?: {
+        limit?: number;
+        skip?: number;
+    }): {
+        limit?: number;
+        skip?: number;
+    };
+    /**
+     * Create a request identifier for tracing multi-request workflows
+     */
+    static createRequestId(): RequestTracer;
+    /**
+     * Convert a BTC xpub to an Ethereum address (with 0x prefix)
+     * @param xpub
+     * @deprecated
+     */
+    static xpubToEthAddress(xpub: string): string;
+    /**
+     * Convert a BTC xpriv to an Ethereum private key (without 0x prefix)
+     * @param xprv
+     * @deprecated
+     */
+    static xprvToEthPrivateKey(xprv: string): string;
+    /**
+     * Sign a message using Ethereum's ECsign method and return the signature string
+     * @param msgHash
+     * @param privKey
+     * @deprecated
+     */
+    static ethSignMsgHash(msgHash: string, privKey: string): string;
+    /**
+     * Convert from wei string (or BN) to Ether (multiply by 1e18)
+     * @param wei
+     * @deprecated
+     */
+    static weiToEtherString(wei: any): string;
+    /**
+     * Recover an ethereum address from a signature and message hash
+     * @param msgHash
+     * @param signature
+     * @deprecated
+     */
+    static ecRecoverEthAddress(msgHash: string, signature: string): string;
+}
+//# sourceMappingURL=util.d.ts.map

package/dist/src/bitgo/utils/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/utils/util.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAoB3C;;GAEG;AACH,qBAAa,aAAc,YAAW,cAAc;IAClD,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;;IAK/B,GAAG;IAIH,QAAQ;CAGT;AAED,qBAAa,IAAI;IAEf,OAAO;IAEP;;OAEG;IACH,MAAM,CAAC,cAAc;IAIrB;;;;OAIG;IACH,MAAM,CAAC,qBAAqB,CAAC,EAAE,EAAE,GAAG,GAAG,GAAG;IAe1C;;;;OAIG;IACH,MAAM,CAAC,oBAAoB,CAAC,MAAM,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE;IAiB9G;;OAEG;IACH,MAAM,CAAC,eAAe,IAAI,aAAa;IAIvC;;;;OAIG;IACH,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAO7C;;;;OAIG;IACH,MAAM,CAAC,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAQhD;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IAkB/D;;;;OAIG;IACH,MAAM,CAAC,gBAAgB,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM;IAiBzC;;;;;OAKG;IACH,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM;CAWvE"}