@bitgo/sdk-core 1.0.1-rc.0 → 1.1.0-dev.0

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

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlsUtils = void 0;
+/**
+ * @prettier
+ */
+const crypto_1 = require("crypto");
+const openpgp_1 = require("openpgp");
+const baseCoin_1 = require("../../account-lib/baseCoin");
+const mpcUtils_1 = require("./mpcUtils");
+/**
+ * Utility functions for BLS-DKG work flows.
+ */
+class BlsUtils extends mpcUtils_1.MpcUtils {
+    constructor(bitgo, baseCoin) {
+        super(bitgo, baseCoin);
+    }
+    /**
+     * Creates a Keychain containing the User's BLS-DKG signing materials.
+     *
+     * @param userGpgKey - ephemeral GPG key to encrypt / decrypt sensitve data exchanged between user and server
+     * @param userKeyShare - user's BLS-DKG key share
+     * @param backupKeyShare - backup's BLS-DKG 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
+     */
+    async createUserKeychain(userGpgKey, userKeyShare, backupKeyShare, bitgoKeychain, passphrase, originalPasscodeEncryptionCode) {
+        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');
+        }
+        if (!userKeyShare.secretShares || !userKeyShare.pub) {
+            throw new Error('Invalid user key shares');
+        }
+        if (!backupKeyShare.secretShares || !backupKeyShare.pub) {
+            throw new Error('Invalid backup key shares');
+        }
+        const bitGoToUserPrivateShare = await this.decryptPrivateShare(bitGoToUserShare.privateShare, userGpgKey);
+        const userPrivateKey = baseCoin_1.BlsKeyPair.aggregatePrvkeys([
+            userKeyShare.secretShares[0],
+            backupKeyShare.secretShares[0],
+            bitGoToUserPrivateShare,
+        ]);
+        const commonPub = baseCoin_1.BlsKeyPair.aggregatePubkeys([
+            userKeyShare.pub,
+            backupKeyShare.pub,
+            bitGoToUserShare.publicShare,
+        ]);
+        if (commonPub !== bitgoKeychain.commonPub) {
+            throw new Error('Failed to create user keychain - commonPubs do not match.');
+        }
+        const userKeychainParams = {
+            source: 'user',
+            keyType: 'blsdkg',
+            commonPub: commonPub,
+            encryptedPrv: this.bitgo.encrypt({ input: userPrivateKey, password: passphrase }),
+            originalPasscodeEncryptionCode: originalPasscodeEncryptionCode,
+        };
+        return await this.baseCoin.keychains().add(userKeychainParams);
+    }
+    /**
+     * Creates a Keychain containing the Backup party's BLS-DKG signing materials.
+     *
+     * @param userGpgKey - ephemeral GPG key to encrypt / decrypt sensitve data exchanged between user and server
+     * @param userKeyShare - User's BLS-DKG Keyshare
+     * @param backupKeyShare - Backup's BLS-DKG 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 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');
+        }
+        if (!userKeyShare.secretShares || !userKeyShare.pub) {
+            throw new Error('Invalid user key shares');
+        }
+        if (!backupKeyShare.secretShares || !backupKeyShare.pub) {
+            throw new Error('Invalid backup key shares');
+        }
+        const bitGoToBackupPrivateShare = await this.decryptPrivateShare(bitGoToBackupShare.privateShare, userGpgKey);
+        const backupPrivateKey = baseCoin_1.BlsKeyPair.aggregatePrvkeys([
+            userKeyShare.secretShares[1],
+            backupKeyShare.secretShares[1],
+            bitGoToBackupPrivateShare,
+        ]);
+        const commonPub = baseCoin_1.BlsKeyPair.aggregatePubkeys([
+            userKeyShare.pub,
+            backupKeyShare.pub,
+            bitGoToBackupShare.publicShare,
+        ]);
+        if (commonPub !== bitgoKeychain.commonPub) {
+            throw new Error('Failed to create backup keychain - commonPubs do not match.');
+        }
+        return await this.baseCoin.keychains().createBackup({
+            source: 'backup',
+            keyType: 'blsdkg',
+            commonPub: commonPub,
+            prv: backupPrivateKey,
+            encryptedPrv: this.bitgo.encrypt({ input: backupPrivateKey, password: passphrase }),
+        });
+    }
+    /**
+     * Creates a Keychain containing BitGo's BLS-DKG signing materials.
+     *
+     * @param userGpgKey - ephemeral GPG key to encrypt / decrypt sensitve data exchanged between user and server
+     * @param userKeyShare - user's BLS-DKG key share
+     * @param backupKeyShare - backup's BLS-DKG key share
+     */
+    async createBitgoKeychain(userGpgKey, userKeyShare, backupKeyShare, enterprise) {
+        if (!userKeyShare.secretShares || !userKeyShare.pub) {
+            throw new Error('Invalid user key shares');
+        }
+        if (!backupKeyShare.secretShares || !backupKeyShare.pub) {
+            throw new Error('Invalid backup key shares');
+        }
+        const userToBitgoKeyShare = {
+            publicShare: userKeyShare.pub,
+            privateShare: userKeyShare.secretShares[2],
+        };
+        const backupToBitgoKeyShare = {
+            publicShare: backupKeyShare.pub,
+            privateShare: backupKeyShare.secretShares[2],
+        };
+        return await this.createBitgoKeychainInWP(userGpgKey, userToBitgoKeyShare, backupToBitgoKeyShare, 'blsdkg', enterprise);
+    }
+    /**
+     * Creates User, Backup, and BitGo BLS-DKG Keychains.
+     *
+     * @param params.passphrase - passphrase used to encrypt signing materials created for User and Backup
+     */
+    async createKeychains(params) {
+        const userKeyShare = this.baseCoin.generateKeyPair();
+        const backupKeyShare = this.baseCoin.generateKeyPair();
+        const randomHexString = crypto_1.randomBytes(12).toString('hex');
+        const userGpgKey = await openpgp_1.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;
+    }
+}
+exports.BlsUtils = BlsUtils;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blsUtils.js","sourceRoot":"","sources":["../../../../src/bitgo/utils/blsUtils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport { randomBytes } from 'crypto';\nimport { generateKey, SerializedKeyPair } from 'openpgp';\nimport { BlsKeyPair as BlsKeyPairClass } from '../../account-lib/baseCoin';\nimport { IBaseCoin, IBlsKeyPair, KeychainsTriplet } from '../baseCoin';\nimport { BitGoBase } from '../bitgoBase';\nimport { Keychain } from '../keychain';\nimport { IBlsUtils } from './iBlsUtils';\nimport { MpcUtils } from './mpcUtils';\n\n/**\n * Utility functions for BLS-DKG work flows.\n */\nexport class BlsUtils extends MpcUtils implements IBlsUtils {\n  constructor(bitgo: BitGoBase, baseCoin: IBaseCoin) {\n    super(bitgo, baseCoin);\n  }\n\n  /**\n   * Creates a Keychain containing the User's BLS-DKG signing materials.\n   *\n   * @param userGpgKey - ephemeral GPG key to encrypt / decrypt sensitve data exchanged between user and server\n   * @param userKeyShare - user's BLS-DKG key share\n   * @param backupKeyShare - backup's BLS-DKG 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   */\n  async createUserKeychain(\n    userGpgKey: SerializedKeyPair<string>,\n    userKeyShare: IBlsKeyPair,\n    backupKeyShare: IBlsKeyPair,\n    bitgoKeychain: Keychain,\n    passphrase: string,\n    originalPasscodeEncryptionCode?: string\n  ): Promise<Keychain> {\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    if (!userKeyShare.secretShares || !userKeyShare.pub) {\n      throw new Error('Invalid user key shares');\n    }\n    if (!backupKeyShare.secretShares || !backupKeyShare.pub) {\n      throw new Error('Invalid backup key shares');\n    }\n\n    const bitGoToUserPrivateShare = await this.decryptPrivateShare(bitGoToUserShare.privateShare, userGpgKey);\n\n    const userPrivateKey = BlsKeyPairClass.aggregatePrvkeys([\n      userKeyShare.secretShares[0],\n      backupKeyShare.secretShares[0],\n      bitGoToUserPrivateShare,\n    ]);\n    const commonPub = BlsKeyPairClass.aggregatePubkeys([\n      userKeyShare.pub,\n      backupKeyShare.pub,\n      bitGoToUserShare.publicShare,\n    ]);\n    if (commonPub !== bitgoKeychain.commonPub) {\n      throw new Error('Failed to create user keychain - commonPubs do not match.');\n    }\n\n    const userKeychainParams: any = {\n      source: 'user',\n      keyType: 'blsdkg',\n      commonPub: commonPub,\n      encryptedPrv: this.bitgo.encrypt({ input: userPrivateKey, password: passphrase }),\n      originalPasscodeEncryptionCode: originalPasscodeEncryptionCode,\n    };\n\n    return await this.baseCoin.keychains().add(userKeychainParams);\n  }\n\n  /**\n   * Creates a Keychain containing the Backup party's BLS-DKG signing materials.\n   *\n   * @param userGpgKey - ephemeral GPG key to encrypt / decrypt sensitve data exchanged between user and server\n   * @param userKeyShare - User's BLS-DKG Keyshare\n   * @param backupKeyShare - Backup's BLS-DKG 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: SerializedKeyPair<string>,\n    userKeyShare: IBlsKeyPair,\n    backupKeyShare: IBlsKeyPair,\n    bitgoKeychain: Keychain,\n    passphrase: string\n  ): Promise<Keychain> {\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    if (!userKeyShare.secretShares || !userKeyShare.pub) {\n      throw new Error('Invalid user key shares');\n    }\n    if (!backupKeyShare.secretShares || !backupKeyShare.pub) {\n      throw new Error('Invalid backup key shares');\n    }\n\n    const bitGoToBackupPrivateShare = await this.decryptPrivateShare(bitGoToBackupShare.privateShare, userGpgKey);\n\n    const backupPrivateKey = BlsKeyPairClass.aggregatePrvkeys([\n      userKeyShare.secretShares[1],\n      backupKeyShare.secretShares[1],\n      bitGoToBackupPrivateShare,\n    ]);\n    const commonPub = BlsKeyPairClass.aggregatePubkeys([\n      userKeyShare.pub,\n      backupKeyShare.pub,\n      bitGoToBackupShare.publicShare,\n    ]);\n    if (commonPub !== bitgoKeychain.commonPub) {\n      throw new Error('Failed to create backup keychain - commonPubs do not match.');\n    }\n\n    return await this.baseCoin.keychains().createBackup({\n      source: 'backup',\n      keyType: 'blsdkg',\n      commonPub: commonPub,\n      prv: backupPrivateKey,\n      encryptedPrv: this.bitgo.encrypt({ input: backupPrivateKey, password: passphrase }),\n    });\n  }\n\n  /**\n   * Creates a Keychain containing BitGo's BLS-DKG signing materials.\n   *\n   * @param userGpgKey - ephemeral GPG key to encrypt / decrypt sensitve data exchanged between user and server\n   * @param userKeyShare - user's BLS-DKG key share\n   * @param backupKeyShare - backup's BLS-DKG key share\n   */\n  async createBitgoKeychain(\n    userGpgKey: SerializedKeyPair<string>,\n    userKeyShare: IBlsKeyPair,\n    backupKeyShare: IBlsKeyPair,\n    enterprise?: string\n  ): Promise<Keychain> {\n    if (!userKeyShare.secretShares || !userKeyShare.pub) {\n      throw new Error('Invalid user key shares');\n    }\n    if (!backupKeyShare.secretShares || !backupKeyShare.pub) {\n      throw new Error('Invalid backup key shares');\n    }\n\n    const userToBitgoKeyShare = {\n      publicShare: userKeyShare.pub,\n      privateShare: userKeyShare.secretShares[2],\n    };\n\n    const backupToBitgoKeyShare = {\n      publicShare: backupKeyShare.pub,\n      privateShare: backupKeyShare.secretShares[2],\n    };\n\n    return await this.createBitgoKeychainInWP(\n      userGpgKey,\n      userToBitgoKeyShare,\n      backupToBitgoKeyShare,\n      'blsdkg',\n      enterprise\n    );\n  }\n\n  /**\n   * Creates User, Backup, and BitGo BLS-DKG 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 userKeyShare = this.baseCoin.generateKeyPair();\n    const backupKeyShare = this.baseCoin.generateKeyPair();\n\n    const randomHexString = randomBytes(12).toString('hex');\n\n    const userGpgKey = await 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"]}

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

@@ -0,0 +1,14 @@
+import { SerializedKeyPair } from 'openpgp';
+import { IBlsKeyPair, KeychainsTriplet } from '../baseCoin';
+import { Keychain } from '../keychain';
+export interface IBlsUtils {
+    createUserKeychain(userGpgKey: SerializedKeyPair<string>, userKeyShare: IBlsKeyPair, backupKeyShare: IBlsKeyPair, bitgoKeychain: Keychain, passphrase: string, originalPasscodeEncryptionCode: string): Promise<Keychain>;
+    createBackupKeychain(userGpgKey: SerializedKeyPair<string>, userKeyShare: IBlsKeyPair, backupKeyShare: IBlsKeyPair, bitgoKeychain: Keychain, passphrase: string): Promise<Keychain>;
+    createBitgoKeychain(userGpgKey: SerializedKeyPair<string>, userKeyShare: IBlsKeyPair, backupKeyShare: IBlsKeyPair, enterprise: string): Promise<Keychain>;
+    createKeychains(params: {
+        passphrase: string;
+        enterprise?: string;
+        originalPasscodeEncryptionCode?: string;
+    }): Promise<KeychainsTriplet>;
+}
+//# sourceMappingURL=iBlsUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"iBlsUtils.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/utils/iBlsUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,MAAM,WAAW,SAAS;IACxB,kBAAkB,CAChB,UAAU,EAAE,iBAAiB,CAAC,MAAM,CAAC,EACrC,YAAY,EAAE,WAAW,EACzB,cAAc,EAAE,WAAW,EAC3B,aAAa,EAAE,QAAQ,EACvB,UAAU,EAAE,MAAM,EAClB,8BAA8B,EAAE,MAAM,GACrC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACrB,oBAAoB,CAClB,UAAU,EAAE,iBAAiB,CAAC,MAAM,CAAC,EACrC,YAAY,EAAE,WAAW,EACzB,cAAc,EAAE,WAAW,EAC3B,aAAa,EAAE,QAAQ,EACvB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,QAAQ,CAAC,CAAC;IACrB,mBAAmB,CACjB,UAAU,EAAE,iBAAiB,CAAC,MAAM,CAAC,EACrC,YAAY,EAAE,WAAW,EACzB,cAAc,EAAE,WAAW,EAC3B,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,QAAQ,CAAC,CAAC;IACrB,eAAe,CAAC,MAAM,EAAE;QACtB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,8BAA8B,CAAC,EAAE,MAAM,CAAC;KACzC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC/B"}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaUJsc1V0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2JpdGdvL3V0aWxzL2lCbHNVdGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2VyaWFsaXplZEtleVBhaXIgfSBmcm9tICdvcGVucGdwJztcbmltcG9ydCB7IElCbHNLZXlQYWlyLCBLZXljaGFpbnNUcmlwbGV0IH0gZnJvbSAnLi4vYmFzZUNvaW4nO1xuaW1wb3J0IHsgS2V5Y2hhaW4gfSBmcm9tICcuLi9rZXljaGFpbic7XG5cbmV4cG9ydCBpbnRlcmZhY2UgSUJsc1V0aWxzIHtcbiAgY3JlYXRlVXNlcktleWNoYWluKFxuICAgIHVzZXJHcGdLZXk6IFNlcmlhbGl6ZWRLZXlQYWlyPHN0cmluZz4sXG4gICAgdXNlcktleVNoYXJlOiBJQmxzS2V5UGFpcixcbiAgICBiYWNrdXBLZXlTaGFyZTogSUJsc0tleVBhaXIsXG4gICAgYml0Z29LZXljaGFpbjogS2V5Y2hhaW4sXG4gICAgcGFzc3BocmFzZTogc3RyaW5nLFxuICAgIG9yaWdpbmFsUGFzc2NvZGVFbmNyeXB0aW9uQ29kZTogc3RyaW5nXG4gICk6IFByb21pc2U8S2V5Y2hhaW4+O1xuICBjcmVhdGVCYWNrdXBLZXljaGFpbihcbiAgICB1c2VyR3BnS2V5OiBTZXJpYWxpemVkS2V5UGFpcjxzdHJpbmc+LFxuICAgIHVzZXJLZXlTaGFyZTogSUJsc0tleVBhaXIsXG4gICAgYmFja3VwS2V5U2hhcmU6IElCbHNLZXlQYWlyLFxuICAgIGJpdGdvS2V5Y2hhaW46IEtleWNoYWluLFxuICAgIHBhc3NwaHJhc2U6IHN0cmluZ1xuICApOiBQcm9taXNlPEtleWNoYWluPjtcbiAgY3JlYXRlQml0Z29LZXljaGFpbihcbiAgICB1c2VyR3BnS2V5OiBTZXJpYWxpemVkS2V5UGFpcjxzdHJpbmc+LFxuICAgIHVzZXJLZXlTaGFyZTogSUJsc0tleVBhaXIsXG4gICAgYmFja3VwS2V5U2hhcmU6IElCbHNLZXlQYWlyLFxuICAgIGVudGVycHJpc2U6IHN0cmluZ1xuICApOiBQcm9taXNlPEtleWNoYWluPjtcbiAgY3JlYXRlS2V5Y2hhaW5zKHBhcmFtczoge1xuICAgIHBhc3NwaHJhc2U6IHN0cmluZztcbiAgICBlbnRlcnByaXNlPzogc3RyaW5nO1xuICAgIG9yaWdpbmFsUGFzc2NvZGVFbmNyeXB0aW9uQ29kZT86IHN0cmluZztcbiAgfSk6IFByb21pc2U8S2V5Y2hhaW5zVHJpcGxldD47XG59XG4iXX0=

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

@@ -0,0 +1,12 @@
+import * as openpgpUtils from './opengpgUtils';
+export * from './abstractUtxoCoinUtil';
+export * from './blsUtils';
+export * from './iBlsUtils';
+export * from './mpcUtils';
+export * from './opengpgUtils';
+export * from './promise-utils';
+export * from './triple';
+export * from './tss';
+export * from './util';
+export { openpgpUtils };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAE/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC;AAEvB,OAAO,EAAE,YAAY,EAAE,CAAC"}

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

@@ -0,0 +1,37 @@
+"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 __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 });
+exports.openpgpUtils = void 0;
+const openpgpUtils = __importStar(require("./opengpgUtils"));
+exports.openpgpUtils = openpgpUtils;
+__exportStar(require("./abstractUtxoCoinUtil"), exports);
+__exportStar(require("./blsUtils"), exports);
+__exportStar(require("./iBlsUtils"), exports);
+__exportStar(require("./mpcUtils"), exports);
+__exportStar(require("./opengpgUtils"), exports);
+__exportStar(require("./promise-utils"), exports);
+__exportStar(require("./triple"), exports);
+__exportStar(require("./tss"), exports);
+__exportStar(require("./util"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYml0Z28vdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDZEQUErQztBQVl0QyxvQ0FBWTtBQVZyQix5REFBdUM7QUFDdkMsNkNBQTJCO0FBQzNCLDhDQUE0QjtBQUM1Qiw2Q0FBMkI7QUFDM0IsaURBQStCO0FBQy9CLGtEQUFnQztBQUNoQywyQ0FBeUI7QUFDekIsd0NBQXNCO0FBQ3RCLHlDQUF1QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIG9wZW5wZ3BVdGlscyBmcm9tICcuL29wZW5ncGdVdGlscyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vYWJzdHJhY3RVdHhvQ29pblV0aWwnO1xuZXhwb3J0ICogZnJvbSAnLi9ibHNVdGlscyc7XG5leHBvcnQgKiBmcm9tICcuL2lCbHNVdGlscyc7XG5leHBvcnQgKiBmcm9tICcuL21wY1V0aWxzJztcbmV4cG9ydCAqIGZyb20gJy4vb3BlbmdwZ1V0aWxzJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvbWlzZS11dGlscyc7XG5leHBvcnQgKiBmcm9tICcuL3RyaXBsZSc7XG5leHBvcnQgKiBmcm9tICcuL3Rzcyc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWwnO1xuXG5leHBvcnQgeyBvcGVucGdwVXRpbHMgfTtcbiJdfQ==

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

@@ -0,0 +1,31 @@
+/**
+ * @prettier
+ */
+import { SerializedKeyPair } from 'openpgp';
+import { IBaseCoin, KeychainsTriplet } from '../baseCoin';
+import { BitGoBase } from '../bitgoBase';
+import { Keychain, KeyType } from '../keychain';
+export interface MpcKeyShare {
+    publicShare: string;
+    privateShare: string;
+}
+export declare abstract class MpcUtils {
+    protected bitgo: BitGoBase;
+    protected baseCoin: IBaseCoin;
+    constructor(bitgo: BitGoBase, baseCoin: IBaseCoin);
+    protected decryptPrivateShare(privateShare: string, userGpgKey: SerializedKeyPair<string>): Promise<string>;
+    protected createBitgoKeychainInWP(userGpgKey: SerializedKeyPair<string>, userKeyShare: MpcKeyShare, backupKeyShare: MpcKeyShare, keyType: KeyType, enterprise?: string): Promise<Keychain>;
+    /**
+     * Creates User, Backup, and BitGo MPC Keychains.
+     *
+     * @param params.passphrase - passphrase used to encrypt signing materials created for User and Backup
+     * @param params.enterprise - optional enterprise id that will be attached to the BitGo Keychain
+     * @param params.originalPasscodeEncryptionCode - optional encryption code used to reset the user's password, if absent, password recovery will not work
+     */
+    abstract createKeychains(params: {
+        passphrase: string;
+        enterprise?: string;
+        originalPasscodeEncryptionCode?: string;
+    }): Promise<KeychainsTriplet>;
+}
+//# sourceMappingURL=mpcUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mpcUtils.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/utils/mpcUtils.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAwC,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAClF,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAGhD,MAAM,WAAW,WAAW;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,8BAAsB,QAAQ;IAC5B,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC;IAC3B,SAAS,CAAC,QAAQ,EAAE,SAAS,CAAC;gBAElB,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS;cAKjC,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,iBAAiB,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;cAiBjG,uBAAuB,CACrC,UAAU,EAAE,iBAAiB,CAAC,MAAM,CAAC,EACrC,YAAY,EAAE,WAAW,EACzB,cAAc,EAAE,WAAW,EAC3B,OAAO,EAAE,OAAO,EAChB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,QAAQ,CAAC;IA8BpB;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,MAAM,EAAE;QAC/B,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,8BAA8B,CAAC,EAAE,MAAM,CAAC;KACzC,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAC9B"}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MpcUtils = void 0;
+/**
+ * @prettier
+ */
+const openpgp_1 = require("openpgp");
+const opengpgUtils_1 = require("./opengpgUtils");
+class MpcUtils {
+    constructor(bitgo, baseCoin) {
+        this.bitgo = bitgo;
+        this.baseCoin = baseCoin;
+    }
+    async decryptPrivateShare(privateShare, userGpgKey) {
+        const privateShareMessage = await openpgp_1.readMessage({
+            armoredMessage: privateShare,
+        });
+        const userGpgPrivateKey = await openpgp_1.readPrivateKey({ armoredKey: userGpgKey.privateKey });
+        const decryptedPrivateShare = (await openpgp_1.decrypt({
+            message: privateShareMessage,
+            decryptionKeys: [userGpgPrivateKey],
+            format: 'utf8',
+        })).data;
+        return decryptedPrivateShare;
+    }
+    async createBitgoKeychainInWP(userGpgKey, userKeyShare, backupKeyShare, keyType, enterprise) {
+        const bitgoKey = await opengpgUtils_1.getBitgoGpgPubKey(this.bitgo);
+        const encUserToBitGoMessage = await opengpgUtils_1.encryptText(userKeyShare.privateShare, bitgoKey);
+        const encBackupToBitGoMessage = await opengpgUtils_1.encryptText(backupKeyShare.privateShare, bitgoKey);
+        const createBitGoMPCParams = {
+            keyType,
+            source: 'bitgo',
+            keyShares: [
+                {
+                    from: 'user',
+                    to: 'bitgo',
+                    publicShare: userKeyShare.publicShare,
+                    privateShare: encUserToBitGoMessage,
+                },
+                {
+                    from: 'backup',
+                    to: 'bitgo',
+                    publicShare: backupKeyShare.publicShare,
+                    privateShare: encBackupToBitGoMessage,
+                },
+            ],
+            userGPGPublicKey: userGpgKey.publicKey,
+            backupGPGPublicKey: userGpgKey.publicKey,
+            enterprise: enterprise,
+        };
+        return await this.baseCoin.keychains().add(createBitGoMPCParams);
+    }
+}
+exports.MpcUtils = MpcUtils;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXBjVXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYml0Z28vdXRpbHMvbXBjVXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7O0dBRUc7QUFDSCxxQ0FBa0Y7QUFJbEYsaURBQWdFO0FBT2hFLE1BQXNCLFFBQVE7SUFJNUIsWUFBWSxLQUFnQixFQUFFLFFBQW1CO1FBQy9DLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ25CLElBQUksQ0FBQyxRQUFRLEdBQUcsUUFBUSxDQUFDO0lBQzNCLENBQUM7SUFFUyxLQUFLLENBQUMsbUJBQW1CLENBQUMsWUFBb0IsRUFBRSxVQUFxQztRQUM3RixNQUFNLG1CQUFtQixHQUFHLE1BQU0scUJBQVcsQ0FBQztZQUM1QyxjQUFjLEVBQUUsWUFBWTtTQUM3QixDQUFDLENBQUM7UUFDSCxNQUFNLGlCQUFpQixHQUFHLE1BQU0sd0JBQWMsQ0FBQyxFQUFFLFVBQVUsRUFBRSxVQUFVLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FBQztRQUV0RixNQUFNLHFCQUFxQixHQUFHLENBQzVCLE1BQU0saUJBQU8sQ0FBQztZQUNaLE9BQU8sRUFBRSxtQkFBbUI7WUFDNUIsY0FBYyxFQUFFLENBQUMsaUJBQWlCLENBQUM7WUFDbkMsTUFBTSxFQUFFLE1BQU07U0FDZixDQUFDLENBQ0gsQ0FBQyxJQUFJLENBQUM7UUFFUCxPQUFPLHFCQUFxQixDQUFDO0lBQy9CLENBQUM7SUFFUyxLQUFLLENBQUMsdUJBQXVCLENBQ3JDLFVBQXFDLEVBQ3JDLFlBQXlCLEVBQ3pCLGNBQTJCLEVBQzNCLE9BQWdCLEVBQ2hCLFVBQW1CO1FBRW5CLE1BQU0sUUFBUSxHQUFHLE1BQU0sZ0NBQWlCLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3JELE1BQU0scUJBQXFCLEdBQUcsTUFBTSwwQkFBVyxDQUFDLFlBQVksQ0FBQyxZQUFZLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDckYsTUFBTSx1QkFBdUIsR0FBRyxNQUFNLDBCQUFXLENBQUMsY0FBYyxDQUFDLFlBQVksRUFBRSxRQUFRLENBQUMsQ0FBQztRQUV6RixNQUFNLG9CQUFvQixHQUFHO1lBQzNCLE9BQU87WUFDUCxNQUFNLEVBQUUsT0FBTztZQUNmLFNBQVMsRUFBRTtnQkFDVDtvQkFDRSxJQUFJLEVBQUUsTUFBTTtvQkFDWixFQUFFLEVBQUUsT0FBTztvQkFDWCxXQUFXLEVBQUUsWUFBWSxDQUFDLFdBQVc7b0JBQ3JDLFlBQVksRUFBRSxxQkFBcUI7aUJBQ3BDO2dCQUNEO29CQUNFLElBQUksRUFBRSxRQUFRO29CQUNkLEVBQUUsRUFBRSxPQUFPO29CQUNYLFdBQVcsRUFBRSxjQUFjLENBQUMsV0FBVztvQkFDdkMsWUFBWSxFQUFFLHVCQUF1QjtpQkFDdEM7YUFDRjtZQUNELGdCQUFnQixFQUFFLFVBQVUsQ0FBQyxTQUFTO1lBQ3RDLGtCQUFrQixFQUFFLFVBQVUsQ0FBQyxTQUFTO1lBQ3hDLFVBQVUsRUFBRSxVQUFVO1NBQ3ZCLENBQUM7UUFFRixPQUFPLE1BQU0sSUFBSSxDQUFDLFFBQVEsQ0FBQyxTQUFTLEVBQUUsQ0FBQyxHQUFHLENBQUMsb0JBQW9CLENBQUMsQ0FBQztJQUNuRSxDQUFDO0NBY0Y7QUExRUQsNEJBMEVDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAcHJldHRpZXJcbiAqL1xuaW1wb3J0IHsgZGVjcnlwdCwgcmVhZE1lc3NhZ2UsIHJlYWRQcml2YXRlS2V5LCBTZXJpYWxpemVkS2V5UGFpciB9IGZyb20gJ29wZW5wZ3AnO1xuaW1wb3J0IHsgSUJhc2VDb2luLCBLZXljaGFpbnNUcmlwbGV0IH0gZnJvbSAnLi4vYmFzZUNvaW4nO1xuaW1wb3J0IHsgQml0R29CYXNlIH0gZnJvbSAnLi4vYml0Z29CYXNlJztcbmltcG9ydCB7IEtleWNoYWluLCBLZXlUeXBlIH0gZnJvbSAnLi4va2V5Y2hhaW4nO1xuaW1wb3J0IHsgZW5jcnlwdFRleHQsIGdldEJpdGdvR3BnUHViS2V5IH0gZnJvbSAnLi9vcGVuZ3BnVXRpbHMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIE1wY0tleVNoYXJlIHtcbiAgcHVibGljU2hhcmU6IHN0cmluZztcbiAgcHJpdmF0ZVNoYXJlOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBNcGNVdGlscyB7XG4gIHByb3RlY3RlZCBiaXRnbzogQml0R29CYXNlO1xuICBwcm90ZWN0ZWQgYmFzZUNvaW46IElCYXNlQ29pbjtcblxuICBjb25zdHJ1Y3RvcihiaXRnbzogQml0R29CYXNlLCBiYXNlQ29pbjogSUJhc2VDb2luKSB7XG4gICAgdGhpcy5iaXRnbyA9IGJpdGdvO1xuICAgIHRoaXMuYmFzZUNvaW4gPSBiYXNlQ29pbjtcbiAgfVxuXG4gIHByb3RlY3RlZCBhc3luYyBkZWNyeXB0UHJpdmF0ZVNoYXJlKHByaXZhdGVTaGFyZTogc3RyaW5nLCB1c2VyR3BnS2V5OiBTZXJpYWxpemVkS2V5UGFpcjxzdHJpbmc+KTogUHJvbWlzZTxzdHJpbmc+IHtcbiAgICBjb25zdCBwcml2YXRlU2hhcmVNZXNzYWdlID0gYXdhaXQgcmVhZE1lc3NhZ2Uoe1xuICAgICAgYXJtb3JlZE1lc3NhZ2U6IHByaXZhdGVTaGFyZSxcbiAgICB9KTtcbiAgICBjb25zdCB1c2VyR3BnUHJpdmF0ZUtleSA9IGF3YWl0IHJlYWRQcml2YXRlS2V5KHsgYXJtb3JlZEtleTogdXNlckdwZ0tleS5wcml2YXRlS2V5IH0pO1xuXG4gICAgY29uc3QgZGVjcnlwdGVkUHJpdmF0ZVNoYXJlID0gKFxuICAgICAgYXdhaXQgZGVjcnlwdCh7XG4gICAgICAgIG1lc3NhZ2U6IHByaXZhdGVTaGFyZU1lc3NhZ2UsXG4gICAgICAgIGRlY3J5cHRpb25LZXlzOiBbdXNlckdwZ1ByaXZhdGVLZXldLFxuICAgICAgICBmb3JtYXQ6ICd1dGY4JyxcbiAgICAgIH0pXG4gICAgKS5kYXRhO1xuXG4gICAgcmV0dXJuIGRlY3J5cHRlZFByaXZhdGVTaGFyZTtcbiAgfVxuXG4gIHByb3RlY3RlZCBhc3luYyBjcmVhdGVCaXRnb0tleWNoYWluSW5XUChcbiAgICB1c2VyR3BnS2V5OiBTZXJpYWxpemVkS2V5UGFpcjxzdHJpbmc+LFxuICAgIHVzZXJLZXlTaGFyZTogTXBjS2V5U2hhcmUsXG4gICAgYmFja3VwS2V5U2hhcmU6IE1wY0tleVNoYXJlLFxuICAgIGtleVR5cGU6IEtleVR5cGUsXG4gICAgZW50ZXJwcmlzZT86IHN0cmluZ1xuICApOiBQcm9taXNlPEtleWNoYWluPiB7XG4gICAgY29uc3QgYml0Z29LZXkgPSBhd2FpdCBnZXRCaXRnb0dwZ1B1YktleSh0aGlzLmJpdGdvKTtcbiAgICBjb25zdCBlbmNVc2VyVG9CaXRHb01lc3NhZ2UgPSBhd2FpdCBlbmNyeXB0VGV4dCh1c2VyS2V5U2hhcmUucHJpdmF0ZVNoYXJlLCBiaXRnb0tleSk7XG4gICAgY29uc3QgZW5jQmFja3VwVG9CaXRHb01lc3NhZ2UgPSBhd2FpdCBlbmNyeXB0VGV4dChiYWNrdXBLZXlTaGFyZS5wcml2YXRlU2hhcmUsIGJpdGdvS2V5KTtcblxuICAgIGNvbnN0IGNyZWF0ZUJpdEdvTVBDUGFyYW1zID0ge1xuICAgICAga2V5VHlwZSxcbiAgICAgIHNvdXJjZTogJ2JpdGdvJyxcbiAgICAgIGtleVNoYXJlczogW1xuICAgICAgICB7XG4gICAgICAgICAgZnJvbTogJ3VzZXInLFxuICAgICAgICAgIHRvOiAnYml0Z28nLFxuICAgICAgICAgIHB1YmxpY1NoYXJlOiB1c2VyS2V5U2hhcmUucHVibGljU2hhcmUsXG4gICAgICAgICAgcHJpdmF0ZVNoYXJlOiBlbmNVc2VyVG9CaXRHb01lc3NhZ2UsXG4gICAgICAgIH0sXG4gICAgICAgIHtcbiAgICAgICAgICBmcm9tOiAnYmFja3VwJyxcbiAgICAgICAgICB0bzogJ2JpdGdvJyxcbiAgICAgICAgICBwdWJsaWNTaGFyZTogYmFja3VwS2V5U2hhcmUucHVibGljU2hhcmUsXG4gICAgICAgICAgcHJpdmF0ZVNoYXJlOiBlbmNCYWNrdXBUb0JpdEdvTWVzc2FnZSxcbiAgICAgICAgfSxcbiAgICAgIF0sXG4gICAgICB1c2VyR1BHUHVibGljS2V5OiB1c2VyR3BnS2V5LnB1YmxpY0tleSxcbiAgICAgIGJhY2t1cEdQR1B1YmxpY0tleTogdXNlckdwZ0tleS5wdWJsaWNLZXksXG4gICAgICBlbnRlcnByaXNlOiBlbnRlcnByaXNlLFxuICAgIH07XG5cbiAgICByZXR1cm4gYXdhaXQgdGhpcy5iYXNlQ29pbi5rZXljaGFpbnMoKS5hZGQoY3JlYXRlQml0R29NUENQYXJhbXMpO1xuICB9XG5cbiAgLyoqXG4gICAqIENyZWF0ZXMgVXNlciwgQmFja3VwLCBhbmQgQml0R28gTVBDIEtleWNoYWlucy5cbiAgICpcbiAgICogQHBhcmFtIHBhcmFtcy5wYXNzcGhyYXNlIC0gcGFzc3BocmFzZSB1c2VkIHRvIGVuY3J5cHQgc2lnbmluZyBtYXRlcmlhbHMgY3JlYXRlZCBmb3IgVXNlciBhbmQgQmFja3VwXG4gICAqIEBwYXJhbSBwYXJhbXMuZW50ZXJwcmlzZSAtIG9wdGlvbmFsIGVudGVycHJpc2UgaWQgdGhhdCB3aWxsIGJlIGF0dGFjaGVkIHRvIHRoZSBCaXRHbyBLZXljaGFpblxuICAgKiBAcGFyYW0gcGFyYW1zLm9yaWdpbmFsUGFzc2NvZGVFbmNyeXB0aW9uQ29kZSAtIG9wdGlvbmFsIGVuY3J5cHRpb24gY29kZSB1c2VkIHRvIHJlc2V0IHRoZSB1c2VyJ3MgcGFzc3dvcmQsIGlmIGFic2VudCwgcGFzc3dvcmQgcmVjb3Zlcnkgd2lsbCBub3Qgd29ya1xuICAgKi9cbiAgYWJzdHJhY3QgY3JlYXRlS2V5Y2hhaW5zKHBhcmFtczoge1xuICAgIHBhc3NwaHJhc2U6IHN0cmluZztcbiAgICBlbnRlcnByaXNlPzogc3RyaW5nO1xuICAgIG9yaWdpbmFsUGFzc2NvZGVFbmNyeXB0aW9uQ29kZT86IHN0cmluZztcbiAgfSk6IFByb21pc2U8S2V5Y2hhaW5zVHJpcGxldD47XG59XG4iXX0=

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

@@ -0,0 +1,51 @@
+import { Key } from 'openpgp';
+import { BitGoBase } from '../bitgoBase';
+/**
+ * Fetches BitGo's pubic gpg key used in MPC flows
+ * @param {BitGo} bitgo BitGo object
+ * @return {Key} public gpg key
+ */
+export declare function getBitgoGpgPubKey(bitgo: BitGoBase): Promise<Key>;
+/**
+ * Encrypts string using gpg key
+ * @DEPRECATED - should use encryptAndSignText instead for added security
+ *
+ * @param text string to encrypt
+ * @param key encryption key
+ * @return {string} encrypted string
+ *
+ * TODO(BG-47170): Delete once gpg signatures are fully supported
+ */
+export declare function encryptText(text: string, key: Key): Promise<string>;
+/**
+ * Encrypts and signs a string
+ * @param text string to encrypt and sign
+ * @param publicArmor public key to encrypt with
+ * @param privateArmor private key to sign with
+ */
+export declare function encryptAndSignText(text: string, publicArmor: string, privateArmor: string): Promise<string>;
+/**
+ * Reads a signed and encrypted message
+ *
+ * @param signed signed and encrypted message
+ * @param publicArmor public key to verify signature
+ * @param privateArmor private key to decrypt message
+ */
+export declare function readSignedMessage(signed: string, publicArmor: string, privateArmor: string): Promise<string>;
+/**
+ * Generates a signature
+ *
+ * @param text string to generate a signature for
+ * @param privateArmor private key as armored string
+ * @return {string} armored signature string
+ */
+export declare function signText(text: string, privateArmor: string): Promise<string>;
+/**
+ * Verifies signature was generated by the public key and matches the expected text
+ *
+ * @param text text that the signature was for
+ * @param armoredSignature signed message as an armored string
+ * @param publicArmor public key that generated the signature
+ */
+export declare function verifySignature(text: string, armoredSignature: string, publicArmor: string): Promise<boolean>;
+//# sourceMappingURL=opengpgUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"opengpgUtils.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/utils/opengpgUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,GAAG,EAOJ,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,CAQtE;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAczE;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAmBjH;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAalH;AAED;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAWlF;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAoBnH"}

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

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySignature = exports.signText = exports.readSignedMessage = exports.encryptAndSignText = exports.encryptText = exports.getBitgoGpgPubKey = void 0;
+const openpgp_1 = require("openpgp");
+/**
+ * Fetches BitGo's pubic gpg key used in MPC flows
+ * @param {BitGo} bitgo BitGo object
+ * @return {Key} public gpg key
+ */
+async function getBitgoGpgPubKey(bitgo) {
+    const constants = await bitgo.fetchConstants();
+    if (!constants.mpc || !constants.mpc.bitgoPublicKey) {
+        throw new Error('Unable to create MPC keys - bitgoPublicKey is missing from constants');
+    }
+    const bitgoPublicKeyStr = constants.mpc.bitgoPublicKey;
+    return await openpgp_1.readKey({ armoredKey: bitgoPublicKeyStr });
+}
+exports.getBitgoGpgPubKey = getBitgoGpgPubKey;
+/**
+ * Encrypts string using gpg key
+ * @DEPRECATED - should use encryptAndSignText instead for added security
+ *
+ * @param text string to encrypt
+ * @param key encryption key
+ * @return {string} encrypted string
+ *
+ * TODO(BG-47170): Delete once gpg signatures are fully supported
+ */
+async function encryptText(text, key) {
+    const messageToEncrypt = await openpgp_1.createMessage({
+        text,
+    });
+    return await openpgp_1.encrypt({
+        message: messageToEncrypt,
+        encryptionKeys: [key],
+        format: 'armored',
+        config: {
+            rejectCurves: new Set(),
+            showVersion: false,
+            showComment: false,
+        },
+    });
+}
+exports.encryptText = encryptText;
+/**
+ * Encrypts and signs a string
+ * @param text string to encrypt and sign
+ * @param publicArmor public key to encrypt with
+ * @param privateArmor private key to sign with
+ */
+async function encryptAndSignText(text, publicArmor, privateArmor) {
+    const publicKey = await openpgp_1.readKey({ armoredKey: publicArmor });
+    const privateKey = await openpgp_1.readPrivateKey({ armoredKey: privateArmor });
+    const message = await openpgp_1.createMessage({ text });
+    const signedMessage = await openpgp_1.encrypt({
+        message,
+        encryptionKeys: publicKey,
+        signingKeys: privateKey,
+        format: 'armored',
+        config: {
+            rejectCurves: new Set(),
+            showVersion: false,
+            showComment: false,
+        },
+    });
+    return signedMessage;
+}
+exports.encryptAndSignText = encryptAndSignText;
+/**
+ * Reads a signed and encrypted message
+ *
+ * @param signed signed and encrypted message
+ * @param publicArmor public key to verify signature
+ * @param privateArmor private key to decrypt message
+ */
+async function readSignedMessage(signed, publicArmor, privateArmor) {
+    const publicKey = await openpgp_1.readKey({ armoredKey: publicArmor });
+    const privateKey = await openpgp_1.readPrivateKey({ armoredKey: privateArmor });
+    const message = await openpgp_1.readMessage({ armoredMessage: signed });
+    const decrypted = await openpgp_1.decrypt({
+        message,
+        verificationKeys: publicKey,
+        decryptionKeys: privateKey,
+        expectSigned: true,
+    });
+    return decrypted.data;
+}
+exports.readSignedMessage = readSignedMessage;
+/**
+ * Generates a signature
+ *
+ * @param text string to generate a signature for
+ * @param privateArmor private key as armored string
+ * @return {string} armored signature string
+ */
+async function signText(text, privateArmor) {
+    const privateKey = await openpgp_1.readPrivateKey({ armoredKey: privateArmor });
+    const message = await openpgp_1.createMessage({ text });
+    const signature = await openpgp_1.sign({
+        message,
+        signingKeys: privateKey,
+        format: 'armored',
+        detached: true,
+    });
+    return signature;
+}
+exports.signText = signText;
+/**
+ * Verifies signature was generated by the public key and matches the expected text
+ *
+ * @param text text that the signature was for
+ * @param armoredSignature signed message as an armored string
+ * @param publicArmor public key that generated the signature
+ */
+async function verifySignature(text, armoredSignature, publicArmor) {
+    const publicKey = await openpgp_1.readKey({ armoredKey: publicArmor });
+    const signature = await openpgp_1.readSignature({ armoredSignature });
+    const message = await openpgp_1.createMessage({ text });
+    const verificationResult = await openpgp_1.verify({
+        message,
+        signature,
+        verificationKeys: publicKey,
+    });
+    if (verificationResult.signatures.length !== 1) {
+        throw new Error('Invalid number of signatures');
+    }
+    try {
+        await verificationResult.signatures[0].verified;
+        return text === verificationResult.data;
+    }
+    catch {
+        return false;
+    }
+}
+exports.verifySignature = verifySignature;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"opengpgUtils.js","sourceRoot":"","sources":["../../../../src/bitgo/utils/opengpgUtils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  createMessage,\n  decrypt,\n  encrypt,\n  Key,\n  readKey,\n  readMessage,\n  readPrivateKey,\n  readSignature,\n  sign,\n  verify,\n} from 'openpgp';\nimport { BitGoBase } from '../bitgoBase';\n\n/**\n * Fetches BitGo's pubic gpg key used in MPC flows\n * @param {BitGo} bitgo BitGo object\n * @return {Key} public gpg key\n */\nexport async function getBitgoGpgPubKey(bitgo: BitGoBase): Promise<Key> {\n  const constants = await bitgo.fetchConstants();\n  if (!constants.mpc || !constants.mpc.bitgoPublicKey) {\n    throw new Error('Unable to create MPC keys - bitgoPublicKey is missing from constants');\n  }\n\n  const bitgoPublicKeyStr = constants.mpc.bitgoPublicKey as string;\n  return await readKey({ armoredKey: bitgoPublicKeyStr });\n}\n\n/**\n * Encrypts string using gpg key\n * @DEPRECATED - should use encryptAndSignText instead for added security\n *\n * @param text string to encrypt\n * @param key encryption key\n * @return {string} encrypted string\n *\n * TODO(BG-47170): Delete once gpg signatures are fully supported\n */\nexport async function encryptText(text: string, key: Key): Promise<string> {\n  const messageToEncrypt = await createMessage({\n    text,\n  });\n  return await encrypt({\n    message: messageToEncrypt,\n    encryptionKeys: [key],\n    format: 'armored',\n    config: {\n      rejectCurves: new Set(),\n      showVersion: false,\n      showComment: false,\n    },\n  });\n}\n\n/**\n * Encrypts and signs a string\n * @param text string to encrypt and sign\n * @param publicArmor public key to encrypt with\n * @param privateArmor private key to sign with\n */\nexport async function encryptAndSignText(text: string, publicArmor: string, privateArmor: string): Promise<string> {\n  const publicKey = await readKey({ armoredKey: publicArmor });\n  const privateKey = await readPrivateKey({ armoredKey: privateArmor });\n\n  const message = await createMessage({ text });\n\n  const signedMessage = await encrypt({\n    message,\n    encryptionKeys: publicKey,\n    signingKeys: privateKey,\n    format: 'armored',\n    config: {\n      rejectCurves: new Set(),\n      showVersion: false,\n      showComment: false,\n    },\n  });\n\n  return signedMessage;\n}\n\n/**\n * Reads a signed and encrypted message\n *\n * @param signed signed and encrypted message\n * @param publicArmor public key to verify signature\n * @param privateArmor private key to decrypt message\n */\nexport async function readSignedMessage(signed: string, publicArmor: string, privateArmor: string): Promise<string> {\n  const publicKey = await readKey({ armoredKey: publicArmor });\n  const privateKey = await readPrivateKey({ armoredKey: privateArmor });\n\n  const message = await readMessage({ armoredMessage: signed });\n  const decrypted = await decrypt({\n    message,\n    verificationKeys: publicKey,\n    decryptionKeys: privateKey,\n    expectSigned: true,\n  });\n\n  return decrypted.data;\n}\n\n/**\n * Generates a signature\n *\n * @param text string to generate a signature for\n * @param privateArmor private key as armored string\n * @return {string} armored signature string\n */\nexport async function signText(text: string, privateArmor: string): Promise<string> {\n  const privateKey = await readPrivateKey({ armoredKey: privateArmor });\n  const message = await createMessage({ text });\n  const signature = await sign({\n    message,\n    signingKeys: privateKey,\n    format: 'armored',\n    detached: true,\n  });\n\n  return signature;\n}\n\n/**\n * Verifies signature was generated by the public key and matches the expected text\n *\n * @param text text that the signature was for\n * @param armoredSignature signed message as an armored string\n * @param publicArmor public key that generated the signature\n */\nexport async function verifySignature(text: string, armoredSignature: string, publicArmor: string): Promise<boolean> {\n  const publicKey = await readKey({ armoredKey: publicArmor });\n  const signature = await readSignature({ armoredSignature });\n  const message = await createMessage({ text });\n  const verificationResult = await verify({\n    message,\n    signature,\n    verificationKeys: publicKey,\n  });\n\n  if (verificationResult.signatures.length !== 1) {\n    throw new Error('Invalid number of signatures');\n  }\n\n  try {\n    await verificationResult.signatures[0].verified;\n    return text === verificationResult.data;\n  } catch {\n    return false;\n  }\n}\n"]}

package/dist/src/bitgo/utils/promise-utils.d.ts

@@ -0,0 +1,5 @@
+export declare type PromiseProps<T> = {
+    [K in keyof T]?: Promise<T[K] | undefined>;
+};
+export declare function promiseProps<T extends Record<string, unknown>>(obj: PromiseProps<T>): Promise<T>;
+//# sourceMappingURL=promise-utils.d.ts.map

package/dist/src/bitgo/utils/promise-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-utils.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/utils/promise-utils.ts"],"names":[],"mappings":"AAAA,oBAAY,YAAY,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;CAAE,CAAC;AAC7E,wBAAsB,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAMtG"}

package/dist/src/bitgo/utils/promise-utils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseProps = void 0;
+async function promiseProps(obj) {
+    const promKeys = Object.keys(obj);
+    return (await Promise.all(Object.values(obj))).reduce((acc, cur, idx) => {
+        acc[promKeys[idx]] = cur;
+        return acc;
+    }, {});
+}
+exports.promiseProps = promiseProps;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvbWlzZS11dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iaXRnby91dGlscy9wcm9taXNlLXV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNPLEtBQUssVUFBVSxZQUFZLENBQW9DLEdBQW9CO0lBQ3hGLE1BQU0sUUFBUSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFnQixDQUFDO0lBQ2pELE9BQU8sQ0FBQyxNQUFNLE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsR0FBTSxFQUFFLEdBQUcsRUFBRSxHQUFHLEVBQUUsRUFBRTtRQUN6RSxHQUFHLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsR0FBRyxDQUFDO1FBQ3pCLE9BQU8sR0FBRyxDQUFDO0lBQ2IsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO0FBQ1QsQ0FBQztBQU5ELG9DQU1DIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgUHJvbWlzZVByb3BzPFQ+ID0geyBbSyBpbiBrZXlvZiBUXT86IFByb21pc2U8VFtLXSB8IHVuZGVmaW5lZD4gfTtcbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBwcm9taXNlUHJvcHM8VCBleHRlbmRzIFJlY29yZDxzdHJpbmcsIHVua25vd24+PihvYmo6IFByb21pc2VQcm9wczxUPik6IFByb21pc2U8VD4ge1xuICBjb25zdCBwcm9tS2V5cyA9IE9iamVjdC5rZXlzKG9iaikgYXMgKGtleW9mIFQpW107XG4gIHJldHVybiAoYXdhaXQgUHJvbWlzZS5hbGwoT2JqZWN0LnZhbHVlcyhvYmopKSkucmVkdWNlKChhY2M6IFQsIGN1ciwgaWR4KSA9PiB7XG4gICAgYWNjW3Byb21LZXlzW2lkeF1dID0gY3VyO1xuICAgIHJldHVybiBhY2M7XG4gIH0sIHt9KTtcbn1cbiJdfQ==

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

@@ -0,0 +1,3 @@
+export declare type Triple<T> = [T, T, T];
+export declare function isTriple<T>(arr: T[]): arr is Triple<T>;
+//# sourceMappingURL=triple.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"triple.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/utils/triple.ts"],"names":[],"mappings":"AAAA,oBAAY,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAElC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,IAAI,MAAM,CAAC,CAAC,CAAC,CAEtD"}