@bitgo-beta/sdk-core 8.2.1-beta.202 → 8.2.1-beta.2021

package/dist/src/bitgo/utils/tss/redpallas/SMC/utils.d.ts

@@ -0,0 +1,29 @@
+import { RedpallasBitgoToOVC1Round1Response, RedpallasBitgoToOVC1Round2Response, RedpallasMPCv2KeyGenRound1Response, RedpallasMPCv2KeyGenRound2Response, RedpallasOVC1ToBitgoRound1Payload, RedpallasOVC2ToBitgoRound2Payload } from '@bitgo/public-types';
+import { IBaseCoin } from '../../../../baseCoin';
+import { BitGoBase } from '../../../../bitgoBase';
+import { Keychain } from '../../../..';
+import { RedpallasMPCv2KeyGenSendFn } from '../redpallasMPCv2KeyGenSender';
+/**
+ * Custodial (SMC/OVC) DKG-only key generation for the Zcash Orchard shielded pool (RedPallas).
+ *
+ * Mirrors for both custodial and SMC wallet
+ * ceremonies driven by external OVC (offline vault console) clients: round1/round2 payloads are
+ * relayed from OVC1/OVC2 to BitGo and back. There is no round3 (no signing) - RedPallas MPS DKG
+ * completes key generation in 2 online rounds, same as EdDSA MPS DKG.
+ */
+export declare class RedpallasMPCv2SMCUtils {
+    private bitgo;
+    private baseCoin;
+    private MPCv2Utils;
+    constructor(bitgo: BitGoBase, baseCoin: IBaseCoin);
+    keyGenRound1(enterprise: string, payload: RedpallasOVC1ToBitgoRound1Payload): Promise<RedpallasBitgoToOVC1Round1Response>;
+    keyGenRound2(enterprise: string, payload: RedpallasOVC2ToBitgoRound2Payload): Promise<RedpallasBitgoToOVC1Round2Response>;
+    keyGenRound1BySender(senderFn: RedpallasMPCv2KeyGenSendFn<RedpallasMPCv2KeyGenRound1Response>, payload: RedpallasOVC1ToBitgoRound1Payload): Promise<RedpallasBitgoToOVC1Round1Response>;
+    keyGenRound2BySender(senderFn: RedpallasMPCv2KeyGenSendFn<RedpallasMPCv2KeyGenRound2Response>, payload: RedpallasOVC2ToBitgoRound2Payload): Promise<RedpallasBitgoToOVC1Round2Response>;
+    uploadClientKeys(bitgoKeyId: string, userCommonKeychain: string, backupCommonKeychain: string): Promise<{
+        userKeychain: Keychain;
+        backupKeychain: Keychain;
+        bitgoKeychain: Keychain;
+    }>;
+}
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/bitgo/utils/tss/redpallas/SMC/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../../src/bitgo/utils/tss/redpallas/SMC/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,kCAAkC,EAClC,kCAAkC,EAElC,kCAAkC,EAClC,kCAAkC,EAClC,iCAAiC,EACjC,iCAAiC,EAClC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAgB,QAAQ,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,EAAE,0BAA0B,EAAsC,MAAM,+BAA+B,CAAC;AAE/G;;;;;;;GAOG;AACH,qBAAa,sBAAsB;IAGrB,OAAO,CAAC,KAAK;IAAa,OAAO,CAAC,QAAQ;IAFtD,OAAO,CAAC,UAAU,CAAsB;gBAEpB,KAAK,EAAE,SAAS,EAAU,QAAQ,EAAE,SAAS;IAIpD,YAAY,CACvB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,kCAAkC,CAAC;IAIjC,YAAY,CACvB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,kCAAkC,CAAC;IAIjC,oBAAoB,CAC/B,QAAQ,EAAE,0BAA0B,CAAC,kCAAkC,CAAC,EACxE,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,kCAAkC,CAAC;IAwCjC,oBAAoB,CAC/B,QAAQ,EAAE,0BAA0B,CAAC,kCAAkC,CAAC,EACxE,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,kCAAkC,CAAC;IAsDjC,gBAAgB,CAC3B,UAAU,EAAE,MAAM,EAClB,kBAAkB,EAAE,MAAM,EAC1B,oBAAoB,EAAE,MAAM,GAC3B,OAAO,CAAC;QAAE,YAAY,EAAE,QAAQ,CAAC;QAAC,cAAc,EAAE,QAAQ,CAAC;QAAC,aAAa,EAAE,QAAQ,CAAA;KAAE,CAAC;CA8B1F"}

package/dist/src/bitgo/utils/tss/redpallas/SMC/utils.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedpallasMPCv2SMCUtils = void 0;
+const assert_1 = __importDefault(require("assert"));
+const public_types_1 = require("@bitgo/public-types");
+const __1 = require("../../../..");
+const redpallasMPCv2_1 = require("../redpallasMPCv2");
+const redpallasMPCv2KeyGenSender_1 = require("../redpallasMPCv2KeyGenSender");
+/**
+ * Custodial (SMC/OVC) DKG-only key generation for the Zcash Orchard shielded pool (RedPallas).
+ *
+ * Mirrors for both custodial and SMC wallet
+ * ceremonies driven by external OVC (offline vault console) clients: round1/round2 payloads are
+ * relayed from OVC1/OVC2 to BitGo and back. There is no round3 (no signing) - RedPallas MPS DKG
+ * completes key generation in 2 online rounds, same as EdDSA MPS DKG.
+ */
+class RedpallasMPCv2SMCUtils {
+    constructor(bitgo, baseCoin) {
+        this.bitgo = bitgo;
+        this.baseCoin = baseCoin;
+        this.MPCv2Utils = new redpallasMPCv2_1.RedpallasMPCv2Utils(bitgo, baseCoin);
+    }
+    async keyGenRound1(enterprise, payload) {
+        return this.keyGenRound1BySender((0, redpallasMPCv2KeyGenSender_1.RedpallasKeyGenSenderForEnterprise)(this.bitgo, enterprise), payload);
+    }
+    async keyGenRound2(enterprise, payload) {
+        return this.keyGenRound2BySender((0, redpallasMPCv2KeyGenSender_1.RedpallasKeyGenSenderForEnterprise)(this.bitgo, enterprise), payload);
+    }
+    async keyGenRound1BySender(senderFn, payload) {
+        (0, assert_1.default)(payload.state === public_types_1.RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data, `Invalid state for round 1, expected: ${public_types_1.RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data}, got: ${payload.state}`);
+        (0, __1.decodeOrElse)(public_types_1.RedpallasOVC1ToBitgoRound1Payload.name, public_types_1.RedpallasOVC1ToBitgoRound1Payload, payload, (errors) => {
+            throw new Error(`error(s) parsing payload: ${errors}`);
+        });
+        const ovc1 = payload.ovc[public_types_1.OVCIndexEnum.ONE];
+        const ovc2 = payload.ovc[public_types_1.OVCIndexEnum.TWO];
+        const result = await this.MPCv2Utils.sendKeyGenerationRound1BySender(senderFn, {
+            userGpgPublicKey: ovc1.gpgPubKey,
+            backupGpgPublicKey: ovc2.gpgPubKey,
+            userMsg1: ovc1.ovcMsg1,
+            backupMsg1: ovc2.ovcMsg1,
+        });
+        const response = {
+            state: public_types_1.RedpallasKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data,
+            tssVersion: payload.tssVersion,
+            walletType: payload.walletType,
+            coin: payload.coin,
+            ovc: payload.ovc,
+            platform: {
+                sessionId: result.sessionId,
+                bitgoMsg1: result.bitgoMsg1,
+            },
+        };
+        return (0, __1.decodeOrElse)(public_types_1.RedpallasBitgoToOVC1Round1Response.name, public_types_1.RedpallasBitgoToOVC1Round1Response, response, (errors) => {
+            throw new Error(`error(s) parsing response: ${errors}`);
+        });
+    }
+    async keyGenRound2BySender(senderFn, payload) {
+        (0, assert_1.default)(payload.state === public_types_1.RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data, `Invalid state for round 2, expected: ${public_types_1.RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data}, got: ${payload.state}`);
+        (0, __1.decodeOrElse)(public_types_1.RedpallasOVC2ToBitgoRound2Payload.name, public_types_1.RedpallasOVC2ToBitgoRound2Payload, payload, (errors) => {
+            throw new Error(`error(s) parsing payload: ${errors}`);
+        });
+        const ovc1 = payload.ovc[public_types_1.OVCIndexEnum.ONE];
+        const ovc2 = payload.ovc[public_types_1.OVCIndexEnum.TWO];
+        const sessionId = payload.platform.sessionId;
+        const result = await this.MPCv2Utils.sendKeyGenerationRound2BySender(senderFn, {
+            sessionId,
+            userMsg2: ovc1.ovcMsg2,
+            backupMsg2: ovc2.ovcMsg2,
+        });
+        assert_1.default.equal(sessionId, result.sessionId, 'Round 1 and round 2 session IDs do not match');
+        const keychains = this.baseCoin.keychains();
+        const bitgoKeychain = await keychains.add({
+            source: 'bitgo',
+            keyType: 'tss',
+            commonKeychain: result.commonPublicKeychain,
+            isMPCv2: true,
+        });
+        const response = {
+            state: public_types_1.RedpallasKeyCreationMPCv2StateEnum.WaitingForOVC1GenerateKey,
+            bitGoKeyId: bitgoKeychain.id,
+            tssVersion: payload.tssVersion,
+            walletType: payload.walletType,
+            coin: payload.coin,
+            ovc: payload.ovc,
+            platform: {
+                // sessionId/bitgoMsg1 carried over from payload.platform; safe because the assert
+                // above guarantees payload.platform.sessionId equals result.sessionId.
+                ...payload.platform,
+                commonPublicKeychain: result.commonPublicKeychain,
+                bitgoMsg2: result.bitgoMsg2,
+            },
+        };
+        return (0, __1.decodeOrElse)(public_types_1.RedpallasBitgoToOVC1Round2Response.name, public_types_1.RedpallasBitgoToOVC1Round2Response, response, (errors) => {
+            throw new Error(`error(s) parsing response: ${errors}`);
+        });
+    }
+    async uploadClientKeys(bitgoKeyId, userCommonKeychain, backupCommonKeychain) {
+        (0, assert_1.default)(userCommonKeychain === backupCommonKeychain, 'Common keychain mismatch between the user and backup keychains');
+        const keychains = this.baseCoin.keychains();
+        const bitgoKeychain = await keychains.get({ id: bitgoKeyId });
+        (0, assert_1.default)(bitgoKeychain, 'Keychain not found');
+        (0, assert_1.default)(bitgoKeychain.source === 'bitgo', 'The keychain is not a BitGo keychain');
+        (0, assert_1.default)(bitgoKeychain.type === 'tss', 'BitGo keychain is not a TSS keychain');
+        (0, assert_1.default)(bitgoKeychain.commonKeychain, 'BitGo keychain does not have a common keychain');
+        (0, assert_1.default)(bitgoKeychain.commonKeychain === userCommonKeychain, 'Common keychain mismatch between the OVCs and BitGo');
+        const userKeychainPromise = keychains.add({
+            source: 'user',
+            keyType: 'tss',
+            commonKeychain: userCommonKeychain,
+            isMPCv2: true,
+        });
+        const backupKeychainPromise = keychains.add({
+            source: 'backup',
+            keyType: 'tss',
+            commonKeychain: backupCommonKeychain,
+            isMPCv2: true,
+        });
+        const [userKeychain, backupKeychain] = await Promise.all([userKeychainPromise, backupKeychainPromise]);
+        return { userKeychain, backupKeychain, bitgoKeychain };
+    }
+}
+exports.RedpallasMPCv2SMCUtils = RedpallasMPCv2SMCUtils;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../src/bitgo/utils/tss/redpallas/SMC/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport {\n  OVCIndexEnum,\n  RedpallasBitgoToOVC1Round1Response,\n  RedpallasBitgoToOVC1Round2Response,\n  RedpallasKeyCreationMPCv2StateEnum,\n  RedpallasMPCv2KeyGenRound1Response,\n  RedpallasMPCv2KeyGenRound2Response,\n  RedpallasOVC1ToBitgoRound1Payload,\n  RedpallasOVC2ToBitgoRound2Payload,\n} from '@bitgo/public-types';\nimport { IBaseCoin } from '../../../../baseCoin';\nimport { BitGoBase } from '../../../../bitgoBase';\nimport { decodeOrElse, Keychain } from '../../../..';\nimport { RedpallasMPCv2Utils } from '../redpallasMPCv2';\nimport { RedpallasMPCv2KeyGenSendFn, RedpallasKeyGenSenderForEnterprise } from '../redpallasMPCv2KeyGenSender';\n\n/**\n * Custodial (SMC/OVC) DKG-only key generation for the Zcash Orchard shielded pool (RedPallas).\n *\n * Mirrors for both custodial and SMC wallet\n * ceremonies driven by external OVC (offline vault console) clients: round1/round2 payloads are\n * relayed from OVC1/OVC2 to BitGo and back. There is no round3 (no signing) - RedPallas MPS DKG\n * completes key generation in 2 online rounds, same as EdDSA MPS DKG.\n */\nexport class RedpallasMPCv2SMCUtils {\n  private MPCv2Utils: RedpallasMPCv2Utils;\n\n  constructor(private bitgo: BitGoBase, private baseCoin: IBaseCoin) {\n    this.MPCv2Utils = new RedpallasMPCv2Utils(bitgo, baseCoin);\n  }\n\n  public async keyGenRound1(\n    enterprise: string,\n    payload: RedpallasOVC1ToBitgoRound1Payload\n  ): Promise<RedpallasBitgoToOVC1Round1Response> {\n    return this.keyGenRound1BySender(RedpallasKeyGenSenderForEnterprise(this.bitgo, enterprise), payload);\n  }\n\n  public async keyGenRound2(\n    enterprise: string,\n    payload: RedpallasOVC2ToBitgoRound2Payload\n  ): Promise<RedpallasBitgoToOVC1Round2Response> {\n    return this.keyGenRound2BySender(RedpallasKeyGenSenderForEnterprise(this.bitgo, enterprise), payload);\n  }\n\n  public async keyGenRound1BySender(\n    senderFn: RedpallasMPCv2KeyGenSendFn<RedpallasMPCv2KeyGenRound1Response>,\n    payload: RedpallasOVC1ToBitgoRound1Payload\n  ): Promise<RedpallasBitgoToOVC1Round1Response> {\n    assert(\n      payload.state === RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data,\n      `Invalid state for round 1, expected: ${RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data}, got: ${payload.state}`\n    );\n    decodeOrElse(RedpallasOVC1ToBitgoRound1Payload.name, RedpallasOVC1ToBitgoRound1Payload, payload, (errors) => {\n      throw new Error(`error(s) parsing payload: ${errors}`);\n    });\n\n    const ovc1 = payload.ovc[OVCIndexEnum.ONE];\n    const ovc2 = payload.ovc[OVCIndexEnum.TWO];\n    const result = await this.MPCv2Utils.sendKeyGenerationRound1BySender(senderFn, {\n      userGpgPublicKey: ovc1.gpgPubKey,\n      backupGpgPublicKey: ovc2.gpgPubKey,\n      userMsg1: ovc1.ovcMsg1,\n      backupMsg1: ovc2.ovcMsg1,\n    });\n\n    const response = {\n      state: RedpallasKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data,\n      tssVersion: payload.tssVersion,\n      walletType: payload.walletType,\n      coin: payload.coin,\n      ovc: payload.ovc,\n      platform: {\n        sessionId: result.sessionId,\n        bitgoMsg1: result.bitgoMsg1,\n      },\n    };\n\n    return decodeOrElse(\n      RedpallasBitgoToOVC1Round1Response.name,\n      RedpallasBitgoToOVC1Round1Response,\n      response,\n      (errors) => {\n        throw new Error(`error(s) parsing response: ${errors}`);\n      }\n    );\n  }\n\n  public async keyGenRound2BySender(\n    senderFn: RedpallasMPCv2KeyGenSendFn<RedpallasMPCv2KeyGenRound2Response>,\n    payload: RedpallasOVC2ToBitgoRound2Payload\n  ): Promise<RedpallasBitgoToOVC1Round2Response> {\n    assert(\n      payload.state === RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data,\n      `Invalid state for round 2, expected: ${RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data}, got: ${payload.state}`\n    );\n    decodeOrElse(RedpallasOVC2ToBitgoRound2Payload.name, RedpallasOVC2ToBitgoRound2Payload, payload, (errors) => {\n      throw new Error(`error(s) parsing payload: ${errors}`);\n    });\n\n    const ovc1 = payload.ovc[OVCIndexEnum.ONE];\n    const ovc2 = payload.ovc[OVCIndexEnum.TWO];\n    const sessionId = payload.platform.sessionId;\n    const result = await this.MPCv2Utils.sendKeyGenerationRound2BySender(senderFn, {\n      sessionId,\n      userMsg2: ovc1.ovcMsg2,\n      backupMsg2: ovc2.ovcMsg2,\n    });\n\n    assert.equal(sessionId, result.sessionId, 'Round 1 and round 2 session IDs do not match');\n\n    const keychains = this.baseCoin.keychains();\n    const bitgoKeychain = await keychains.add({\n      source: 'bitgo',\n      keyType: 'tss',\n      commonKeychain: result.commonPublicKeychain,\n      isMPCv2: true,\n    });\n\n    const response = {\n      state: RedpallasKeyCreationMPCv2StateEnum.WaitingForOVC1GenerateKey,\n      bitGoKeyId: bitgoKeychain.id,\n      tssVersion: payload.tssVersion,\n      walletType: payload.walletType,\n      coin: payload.coin,\n      ovc: payload.ovc,\n      platform: {\n        // sessionId/bitgoMsg1 carried over from payload.platform; safe because the assert\n        // above guarantees payload.platform.sessionId equals result.sessionId.\n        ...payload.platform,\n        commonPublicKeychain: result.commonPublicKeychain,\n        bitgoMsg2: result.bitgoMsg2,\n      },\n    };\n\n    return decodeOrElse(\n      RedpallasBitgoToOVC1Round2Response.name,\n      RedpallasBitgoToOVC1Round2Response,\n      response,\n      (errors) => {\n        throw new Error(`error(s) parsing response: ${errors}`);\n      }\n    );\n  }\n\n  public async uploadClientKeys(\n    bitgoKeyId: string,\n    userCommonKeychain: string,\n    backupCommonKeychain: string\n  ): Promise<{ userKeychain: Keychain; backupKeychain: Keychain; bitgoKeychain: Keychain }> {\n    assert(\n      userCommonKeychain === backupCommonKeychain,\n      'Common keychain mismatch between the user and backup keychains'\n    );\n\n    const keychains = this.baseCoin.keychains();\n    const bitgoKeychain = await keychains.get({ id: bitgoKeyId });\n    assert(bitgoKeychain, 'Keychain not found');\n    assert(bitgoKeychain.source === 'bitgo', 'The keychain is not a BitGo keychain');\n    assert(bitgoKeychain.type === 'tss', 'BitGo keychain is not a TSS keychain');\n    assert(bitgoKeychain.commonKeychain, 'BitGo keychain does not have a common keychain');\n    assert(bitgoKeychain.commonKeychain === userCommonKeychain, 'Common keychain mismatch between the OVCs and BitGo');\n\n    const userKeychainPromise = keychains.add({\n      source: 'user',\n      keyType: 'tss',\n      commonKeychain: userCommonKeychain,\n      isMPCv2: true,\n    });\n    const backupKeychainPromise = keychains.add({\n      source: 'backup',\n      keyType: 'tss',\n      commonKeychain: backupCommonKeychain,\n      isMPCv2: true,\n    });\n\n    const [userKeychain, backupKeychain] = await Promise.all([userKeychainPromise, backupKeychainPromise]);\n    return { userKeychain, backupKeychain, bitgoKeychain };\n  }\n}\n"]}

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

@@ -0,0 +1,4 @@
+export * from './redpallasMPCv2';
+export * from './redpallasMPCv2KeyGenSender';
+export * from './SMC/utils';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/bitgo/utils/tss/redpallas/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,aAAa,CAAC"}

package/dist/src/bitgo/utils/tss/redpallas/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("./redpallasMPCv2"), exports);
+__exportStar(require("./redpallasMPCv2KeyGenSender"), exports);
+__exportStar(require("./SMC/utils"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYml0Z28vdXRpbHMvdHNzL3JlZHBhbGxhcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsbURBQWlDO0FBQ2pDLCtEQUE2QztBQUM3Qyw4Q0FBNEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3JlZHBhbGxhc01QQ3YyJztcbmV4cG9ydCAqIGZyb20gJy4vcmVkcGFsbGFzTVBDdjJLZXlHZW5TZW5kZXInO1xuZXhwb3J0ICogZnJvbSAnLi9TTUMvdXRpbHMnO1xuIl19

package/dist/src/bitgo/utils/tss/redpallas/redpallasMPCv2.d.ts

@@ -0,0 +1,27 @@
+import { RedpallasMPCv2KeyGenRound1Request, RedpallasMPCv2KeyGenRound1Response, RedpallasMPCv2KeyGenRound2Request, RedpallasMPCv2KeyGenRound2Response } from '@bitgo/public-types';
+import { IBaseCoin } from '../../../baseCoin';
+import { BitGoBase } from '../../../bitgoBase';
+import { IWallet } from '../../../wallet';
+import BaseTssUtils from '../baseTSSUtils';
+import { GenerateRedpallasMPCv2KeyRequestResponse, RedpallasMPCv2KeyGenSendFn } from './redpallasMPCv2KeyGenSender';
+/**
+ * DKG-only MPCv2 utils for the Zcash Orchard shielded pool (RedPallas / "Ironwood").
+ *
+ * This currently only exposes the BitGo-platform round1/round2 dispatch used by the custodial
+ * SMC/OVC ceremony (see `RedpallasMPCv2SMCUtils` in `./SMC/utils.ts`) - there is no self-custody
+ * (direct, non-OVC) key-generation entrypoint here, since nothing in this SDK constructs one
+ * today. There is also no signing (DSG) support - transaction signing for Zcash shielded
+ * addresses is out of scope for this SDK.
+ *
+ * RedPallas MPS DKG completes in the same 2-round shape as EdDSA MPS DKG (round0 local, round1 +
+ * round2 online). The resulting `commonPublicKeychain` is the raw 32-byte RedPallas group public
+ * key (64 hex chars) - there is no BIP32-style chain code, unlike EdDSA/ECDSA commonKeychains.
+ */
+export declare class RedpallasMPCv2Utils extends BaseTssUtils<unknown> {
+    constructor(bitgo: BitGoBase, baseCoin: IBaseCoin, wallet?: IWallet);
+    sendKeyGenerationRound1(enterprise: string, payload: RedpallasMPCv2KeyGenRound1Request, safeId?: string): Promise<RedpallasMPCv2KeyGenRound1Response>;
+    sendKeyGenerationRound1BySender(senderFn: RedpallasMPCv2KeyGenSendFn<GenerateRedpallasMPCv2KeyRequestResponse>, payload: RedpallasMPCv2KeyGenRound1Request): Promise<RedpallasMPCv2KeyGenRound1Response>;
+    sendKeyGenerationRound2(enterprise: string, payload: RedpallasMPCv2KeyGenRound2Request): Promise<RedpallasMPCv2KeyGenRound2Response>;
+    sendKeyGenerationRound2BySender(senderFn: RedpallasMPCv2KeyGenSendFn<GenerateRedpallasMPCv2KeyRequestResponse>, payload: RedpallasMPCv2KeyGenRound2Request): Promise<RedpallasMPCv2KeyGenRound2Response>;
+}
+//# sourceMappingURL=redpallasMPCv2.d.ts.map

package/dist/src/bitgo/utils/tss/redpallas/redpallasMPCv2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redpallasMPCv2.d.ts","sourceRoot":"","sources":["../../../../../../src/bitgo/utils/tss/redpallas/redpallasMPCv2.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,iCAAiC,EACjC,kCAAkC,EAClC,iCAAiC,EACjC,kCAAkC,EACnC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAEL,wCAAwC,EAExC,0BAA0B,EAC3B,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;;;;;;GAYG;AACH,qBAAa,mBAAoB,SAAQ,YAAY,CAAC,OAAO,CAAC;gBAChD,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,OAAO;IAO7D,uBAAuB,CAC3B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,iCAAiC,EAC1C,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,kCAAkC,CAAC;IAOxC,+BAA+B,CACnC,QAAQ,EAAE,0BAA0B,CAAC,wCAAwC,CAAC,EAC9E,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,kCAAkC,CAAC;IAOxC,uBAAuB,CAC3B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,kCAAkC,CAAC;IAIxC,+BAA+B,CACnC,QAAQ,EAAE,0BAA0B,CAAC,wCAAwC,CAAC,EAC9E,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,kCAAkC,CAAC;CAQ/C"}

package/dist/src/bitgo/utils/tss/redpallas/redpallasMPCv2.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedpallasMPCv2Utils = void 0;
+const public_types_1 = require("@bitgo/public-types");
+const baseTSSUtils_1 = __importDefault(require("../baseTSSUtils"));
+const redpallasMPCv2KeyGenSender_1 = require("./redpallasMPCv2KeyGenSender");
+/**
+ * DKG-only MPCv2 utils for the Zcash Orchard shielded pool (RedPallas / "Ironwood").
+ *
+ * This currently only exposes the BitGo-platform round1/round2 dispatch used by the custodial
+ * SMC/OVC ceremony (see `RedpallasMPCv2SMCUtils` in `./SMC/utils.ts`) - there is no self-custody
+ * (direct, non-OVC) key-generation entrypoint here, since nothing in this SDK constructs one
+ * today. There is also no signing (DSG) support - transaction signing for Zcash shielded
+ * addresses is out of scope for this SDK.
+ *
+ * RedPallas MPS DKG completes in the same 2-round shape as EdDSA MPS DKG (round0 local, round1 +
+ * round2 online). The resulting `commonPublicKeychain` is the raw 32-byte RedPallas group public
+ * key (64 hex chars) - there is no BIP32-style chain code, unlike EdDSA/ECDSA commonKeychains.
+ */
+class RedpallasMPCv2Utils extends baseTSSUtils_1.default {
+    constructor(bitgo, baseCoin, wallet) {
+        super(bitgo, baseCoin, wallet);
+        this.setBitgoGpgPubKey(bitgo);
+    }
+    // #region platform round1/round2 dispatch
+    async sendKeyGenerationRound1(enterprise, payload, safeId) {
+        return this.sendKeyGenerationRound1BySender((0, redpallasMPCv2KeyGenSender_1.RedpallasKeyGenSenderForEnterprise)(this.bitgo, enterprise, safeId), payload);
+    }
+    async sendKeyGenerationRound1BySender(senderFn, payload) {
+        return senderFn(public_types_1.MPCv2KeyGenStateEnum['MPCv2-R1'], payload);
+    }
+    async sendKeyGenerationRound2(enterprise, payload) {
+        return this.sendKeyGenerationRound2BySender((0, redpallasMPCv2KeyGenSender_1.RedpallasKeyGenSenderForEnterprise)(this.bitgo, enterprise), payload);
+    }
+    async sendKeyGenerationRound2BySender(senderFn, payload) {
+        return senderFn(public_types_1.MPCv2KeyGenStateEnum['MPCv2-R2'], payload);
+    }
+}
+exports.RedpallasMPCv2Utils = RedpallasMPCv2Utils;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/bitgo/utils/tss/redpallas/redpallasMPCv2KeyGenSender.d.ts

@@ -0,0 +1,45 @@
+import * as t from 'io-ts';
+import { MPCv2KeyGenState } from '@bitgo/public-types';
+import { BitGoBase } from '../../../bitgoBase';
+declare const generateRedpallasMPCv2KeyRequestBody: t.UnionC<[t.TypeC<{
+    userGpgPublicKey: import("io-ts-types").NonEmptyStringC;
+    backupGpgPublicKey: import("io-ts-types").NonEmptyStringC;
+    userMsg1: t.TypeC<{
+        message: t.StringC;
+        signature: t.StringC;
+    }>;
+    backupMsg1: t.TypeC<{
+        message: t.StringC;
+        signature: t.StringC;
+    }>;
+}>, t.TypeC<{
+    sessionId: import("io-ts-types").NonEmptyStringC;
+    userMsg2: t.TypeC<{
+        message: t.StringC;
+        signature: t.StringC;
+    }>;
+    backupMsg2: t.TypeC<{
+        message: t.StringC;
+        signature: t.StringC;
+    }>;
+}>]>;
+export type GenerateRedpallasMPCv2KeyRequestBody = t.TypeOf<typeof generateRedpallasMPCv2KeyRequestBody>;
+declare const generateRedpallasMPCv2KeyRequestResponse: t.UnionC<[t.TypeC<{
+    sessionId: import("io-ts-types").NonEmptyStringC;
+    bitgoMsg1: t.TypeC<{
+        message: t.StringC;
+        signature: t.StringC;
+    }>;
+}>, t.TypeC<{
+    sessionId: import("io-ts-types").NonEmptyStringC;
+    commonPublicKeychain: import("io-ts-types").NonEmptyStringC;
+    bitgoMsg2: t.TypeC<{
+        message: t.StringC;
+        signature: t.StringC;
+    }>;
+}>]>;
+export type GenerateRedpallasMPCv2KeyRequestResponse = t.TypeOf<typeof generateRedpallasMPCv2KeyRequestResponse>;
+export type RedpallasMPCv2KeyGenSendFn<T extends GenerateRedpallasMPCv2KeyRequestResponse> = (round: MPCv2KeyGenState, payload: GenerateRedpallasMPCv2KeyRequestBody) => Promise<T>;
+export declare function RedpallasKeyGenSenderForEnterprise<T extends GenerateRedpallasMPCv2KeyRequestResponse>(bitgo: BitGoBase, enterprise: string, safeId?: string): RedpallasMPCv2KeyGenSendFn<T>;
+export {};
+//# sourceMappingURL=redpallasMPCv2KeyGenSender.d.ts.map

package/dist/src/bitgo/utils/tss/redpallas/redpallasMPCv2KeyGenSender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redpallasMPCv2KeyGenSender.d.ts","sourceRoot":"","sources":["../../../../../../src/bitgo/utils/tss/redpallas/redpallasMPCv2KeyGenSender.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAC3B,OAAO,EAGL,gBAAgB,EAKjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C,QAAA,MAAM,oCAAoC;6BA6B6lL,aAAa;+BAAkD,aAAa;cAAgC,EAAG,KAAK;iBAAmB,EAAG,OAAO;mBAAoB,EAAG,OAAO;;gBAAyB,EAAG,KAAK;iBAAmB,EAAG,OAAO;mBAAoB,EAAG,OAAO;;;sBAAwgB,aAAa;cAAgC,EAAG,KAAK;iBAAmB,EAAG,OAAO;mBAAoB,EAAG,OAAO;;gBAAyB,EAAG,KAAK;iBAAmB,EAAG,OAAO;mBAAoB,EAAG,OAAO;;IA1BpmN,CAAC;AACH,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oCAAoC,CAAC,CAAC;AAEzG,QAAA,MAAM,wCAAwC;sBAuB+iM,aAAa;eAAiC,EAAG,KAAK;iBAAmB,EAAG,OAAO;mBAAoB,EAAG,OAAO;;;sBAAmmB,aAAa;iCAAoD,aAAa;eAAiC,EAAG,KAAK;iBAAmB,EAAG,OAAO;mBAAoB,EAAG,OAAO;;IApBj+N,CAAC;AACH,MAAM,MAAM,wCAAwC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wCAAwC,CAAC,CAAC;AAEjH,MAAM,MAAM,0BAA0B,CAAC,CAAC,SAAS,wCAAwC,IAAI,CAC3F,KAAK,EAAE,gBAAgB,EACvB,OAAO,EAAE,oCAAoC,KAC1C,OAAO,CAAC,CAAC,CAAC,CAAC;AAEhB,wBAAgB,kCAAkC,CAAC,CAAC,SAAS,wCAAwC,EACnG,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM,GACd,0BAA0B,CAAC,CAAC,CAAC,CAO/B"}

package/dist/src/bitgo/utils/tss/redpallas/redpallasMPCv2KeyGenSender.js

@@ -0,0 +1,55 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedpallasKeyGenSenderForEnterprise = RedpallasKeyGenSenderForEnterprise;
+const t = __importStar(require("io-ts"));
+const public_types_1 = require("@bitgo/public-types");
+const generateRedpallasMPCv2KeyRequestBody = t.union([
+    public_types_1.RedpallasMPCv2KeyGenRound1Request,
+    public_types_1.RedpallasMPCv2KeyGenRound2Request,
+]);
+const generateRedpallasMPCv2KeyRequestResponse = t.union([
+    public_types_1.RedpallasMPCv2KeyGenRound1Response,
+    public_types_1.RedpallasMPCv2KeyGenRound2Response,
+]);
+function RedpallasKeyGenSenderForEnterprise(bitgo, enterprise, safeId) {
+    return (round, payload) => {
+        return bitgo
+            .post(bitgo.url('/mpc/generatekey', 2))
+            .send({ enterprise, safeId, type: public_types_1.KeyGenTypeEnum.MPCv2, curveType: public_types_1.KeyCurveEnum.RedPallas, round, payload })
+            .result();
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/bitgo/utils/tss/serializedTxHexVerify.d.ts

@@ -0,0 +1,8 @@
+import { IBaseCoin } from '../../baseCoin';
+/**
+ * Returns true when TSS verifyTransaction should decode serializedTxHex instead of
+ * signableHex (e.g. ICP hash digests, or legacy EIP-155 RLP that fails ethereumjs
+ * fromSerializedTx). Controlled via CoinFeature.TSS_VERIFY_USE_SERIALIZED_TX_HEX.
+ */
+export declare function shouldVerifyWithSerializedTxHex(coin: IBaseCoin): boolean;
+//# sourceMappingURL=serializedTxHexVerify.d.ts.map

package/dist/src/bitgo/utils/tss/serializedTxHexVerify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializedTxHexVerify.d.ts","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/serializedTxHexVerify.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAExE"}

package/dist/src/bitgo/utils/tss/serializedTxHexVerify.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldVerifyWithSerializedTxHex = shouldVerifyWithSerializedTxHex;
+const statics_1 = require("@bitgo-beta/statics");
+/**
+ * Returns true when TSS verifyTransaction should decode serializedTxHex instead of
+ * signableHex (e.g. ICP hash digests, or legacy EIP-155 RLP that fails ethereumjs
+ * fromSerializedTx). Controlled via CoinFeature.TSS_VERIFY_USE_SERIALIZED_TX_HEX.
+ */
+function shouldVerifyWithSerializedTxHex(coin) {
+    return coin.getConfig().features?.includes(statics_1.CoinFeature.TSS_VERIFY_USE_SERIALIZED_TX_HEX) ?? false;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VyaWFsaXplZFR4SGV4VmVyaWZ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2JpdGdvL3V0aWxzL3Rzcy9zZXJpYWxpemVkVHhIZXhWZXJpZnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFTQSwwRUFFQztBQVhELGlEQUFrRDtBQUlsRDs7OztHQUlHO0FBQ0gsU0FBZ0IsK0JBQStCLENBQUMsSUFBZTtJQUM3RCxPQUFPLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQyxRQUFRLEVBQUUsUUFBUSxDQUFDLHFCQUFXLENBQUMsZ0NBQWdDLENBQUMsSUFBSSxLQUFLLENBQUM7QUFDcEcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvaW5GZWF0dXJlIH0gZnJvbSAnQGJpdGdvLWJldGEvc3RhdGljcyc7XG5cbmltcG9ydCB7IElCYXNlQ29pbiB9IGZyb20gJy4uLy4uL2Jhc2VDb2luJztcblxuLyoqXG4gKiBSZXR1cm5zIHRydWUgd2hlbiBUU1MgdmVyaWZ5VHJhbnNhY3Rpb24gc2hvdWxkIGRlY29kZSBzZXJpYWxpemVkVHhIZXggaW5zdGVhZCBvZlxuICogc2lnbmFibGVIZXggKGUuZy4gSUNQIGhhc2ggZGlnZXN0cywgb3IgbGVnYWN5IEVJUC0xNTUgUkxQIHRoYXQgZmFpbHMgZXRoZXJldW1qc1xuICogZnJvbVNlcmlhbGl6ZWRUeCkuIENvbnRyb2xsZWQgdmlhIENvaW5GZWF0dXJlLlRTU19WRVJJRllfVVNFX1NFUklBTElaRURfVFhfSEVYLlxuICovXG5leHBvcnQgZnVuY3Rpb24gc2hvdWxkVmVyaWZ5V2l0aFNlcmlhbGl6ZWRUeEhleChjb2luOiBJQmFzZUNvaW4pOiBib29sZWFuIHtcbiAgcmV0dXJuIGNvaW4uZ2V0Q29uZmlnKCkuZmVhdHVyZXM/LmluY2x1ZGVzKENvaW5GZWF0dXJlLlRTU19WRVJJRllfVVNFX1NFUklBTElaRURfVFhfSEVYKSA/PyBmYWxzZTtcbn1cbiJdfQ==

package/dist/src/bitgo/utils/tss/signableConsistency.d.ts

@@ -0,0 +1,12 @@
+export interface CoinWithSignableConsistency {
+    /**
+     * Verify that the server-supplied signableHex is consistent with serializedTxHex.
+     * For TSS_VERIFY_USE_SERIALIZED_TX_HEX coins (BSC, XDC), the MPC signing flow
+     * verifies serializedTxHex but signs signableHex — both are server-supplied
+     * independently.  This method derives the expected signableHex from the
+     * serializedTxHex locally and throws InvalidTransactionError if they diverge.
+     */
+    assertSignableConsistency(serializedTxHex: string, signableHex: string): void;
+}
+export declare function isCoinWithSignableConsistency(coin: unknown): coin is CoinWithSignableConsistency;
+//# sourceMappingURL=signableConsistency.d.ts.map

package/dist/src/bitgo/utils/tss/signableConsistency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signableConsistency.d.ts","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/signableConsistency.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,2BAA2B;IAC1C;;;;;;OAMG;IACH,yBAAyB,CAAC,eAAe,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/E;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,2BAA2B,CAMhG"}

package/dist/src/bitgo/utils/tss/signableConsistency.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCoinWithSignableConsistency = isCoinWithSignableConsistency;
+function isCoinWithSignableConsistency(coin) {
+    return (coin !== null &&
+        typeof coin === 'object' &&
+        typeof coin.assertSignableConsistency === 'function');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbmFibGVDb25zaXN0ZW5jeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9iaXRnby91dGlscy90c3Mvc2lnbmFibGVDb25zaXN0ZW5jeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQVdBLHNFQU1DO0FBTkQsU0FBZ0IsNkJBQTZCLENBQUMsSUFBYTtJQUN6RCxPQUFPLENBQ0wsSUFBSSxLQUFLLElBQUk7UUFDYixPQUFPLElBQUksS0FBSyxRQUFRO1FBQ3hCLE9BQVEsSUFBb0MsQ0FBQyx5QkFBeUIsS0FBSyxVQUFVLENBQ3RGLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBDb2luV2l0aFNpZ25hYmxlQ29uc2lzdGVuY3kge1xuICAvKipcbiAgICogVmVyaWZ5IHRoYXQgdGhlIHNlcnZlci1zdXBwbGllZCBzaWduYWJsZUhleCBpcyBjb25zaXN0ZW50IHdpdGggc2VyaWFsaXplZFR4SGV4LlxuICAgKiBGb3IgVFNTX1ZFUklGWV9VU0VfU0VSSUFMSVpFRF9UWF9IRVggY29pbnMgKEJTQywgWERDKSwgdGhlIE1QQyBzaWduaW5nIGZsb3dcbiAgICogdmVyaWZpZXMgc2VyaWFsaXplZFR4SGV4IGJ1dCBzaWducyBzaWduYWJsZUhleCDigJQgYm90aCBhcmUgc2VydmVyLXN1cHBsaWVkXG4gICAqIGluZGVwZW5kZW50bHkuICBUaGlzIG1ldGhvZCBkZXJpdmVzIHRoZSBleHBlY3RlZCBzaWduYWJsZUhleCBmcm9tIHRoZVxuICAgKiBzZXJpYWxpemVkVHhIZXggbG9jYWxseSBhbmQgdGhyb3dzIEludmFsaWRUcmFuc2FjdGlvbkVycm9yIGlmIHRoZXkgZGl2ZXJnZS5cbiAgICovXG4gIGFzc2VydFNpZ25hYmxlQ29uc2lzdGVuY3koc2VyaWFsaXplZFR4SGV4OiBzdHJpbmcsIHNpZ25hYmxlSGV4OiBzdHJpbmcpOiB2b2lkO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gaXNDb2luV2l0aFNpZ25hYmxlQ29uc2lzdGVuY3koY29pbjogdW5rbm93bik6IGNvaW4gaXMgQ29pbldpdGhTaWduYWJsZUNvbnNpc3RlbmN5IHtcbiAgcmV0dXJuIChcbiAgICBjb2luICE9PSBudWxsICYmXG4gICAgdHlwZW9mIGNvaW4gPT09ICdvYmplY3QnICYmXG4gICAgdHlwZW9mIChjb2luIGFzIENvaW5XaXRoU2lnbmFibGVDb25zaXN0ZW5jeSkuYXNzZXJ0U2lnbmFibGVDb25zaXN0ZW5jeSA9PT0gJ2Z1bmN0aW9uJ1xuICApO1xufVxuIl19

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

@@ -0,0 +1,10 @@
+import { ApiVersion, IWallet } from '../wallet';
+export declare function validateTxRequestApiVersion(wallet: IWallet, requestedApiVersion: ApiVersion): void;
+/**
+ * Get the api version for the provided wallet.
+ * If the user requested api version is invalid, this will throw an error.
+ * @param wallet
+ * @param requestedApiVersion
+ */
+export declare function getTxRequestApiVersion(wallet: IWallet, requestedApiVersion?: ApiVersion): ApiVersion;
+//# sourceMappingURL=txRequest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"txRequest.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/utils/txRequest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGhD,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,OAAO,EAAE,mBAAmB,EAAE,UAAU,GAAG,IAAI,CAiBlG;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,EAAE,mBAAmB,CAAC,EAAE,UAAU,GAAG,UAAU,CAcpG"}

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

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTxRequestApiVersion = validateTxRequestApiVersion;
+exports.getTxRequestApiVersion = getTxRequestApiVersion;
+const assert_1 = __importDefault(require("assert"));
+function validateTxRequestApiVersion(wallet, requestedApiVersion) {
+    if (wallet.multisigType() !== 'tss') {
+        // only tss wallets have api version requirements
+        return;
+    }
+    if (wallet.baseCoin.getMPCAlgorithm() === 'ecdsa') {
+        (0, assert_1.default)(requestedApiVersion === 'full', 'For ECDSA tss wallets, parameter `apiVersion` must be `full`.');
+    }
+    else if (wallet.multisigTypeVersion() === 'MPCv2') {
+        (0, assert_1.default)(requestedApiVersion === 'full', 'For EdDSA MPCv2 tss wallets, parameter `apiVersion` must be `full`.');
+    }
+    else if (wallet.type() !== 'hot') {
+        // all other cases should use full!
+        (0, assert_1.default)(requestedApiVersion === 'full', 'For non self-custodial (hot) tss wallets, parameter `apiVersion` must be `full`.');
+    }
+    return;
+}
+/**
+ * Get the api version for the provided wallet.
+ * If the user requested api version is invalid, this will throw an error.
+ * @param wallet
+ * @param requestedApiVersion
+ */
+function getTxRequestApiVersion(wallet, requestedApiVersion) {
+    if (requestedApiVersion) {
+        validateTxRequestApiVersion(wallet, requestedApiVersion);
+        return requestedApiVersion;
+    }
+    if (wallet.baseCoin.getMPCAlgorithm() === 'ecdsa' || wallet.multisigTypeVersion() === 'MPCv2') {
+        return 'full';
+    }
+    else if (wallet.type() === 'hot') {
+        // default to lite for hot eddsa tss wallets (v1 only)
+        return 'lite';
+    }
+    else {
+        // default to full for all other wallet types
+        return 'full';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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