@bitgo-beta/sdk-core 8.2.1-beta.197 → 8.2.1-beta.1971

package/dist/src/bitgo/utils/tss/ecdsa/ecdsaMPCv2.js

@@ -0,0 +1,1049 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcdsaMPCv2Utils = void 0;
+exports.isGG18SigningMaterial = isGG18SigningMaterial;
+exports.getMpcV2RecoveryKeyShares = getMpcV2RecoveryKeyShares;
+exports.signRecoveryMpcV2 = signRecoveryMpcV2;
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const assert_1 = __importDefault(require("assert"));
+const buffer_1 = require("buffer");
+const io_ts_types_1 = require("io-ts-types");
+const keccak_1 = __importDefault(require("keccak"));
+const public_types_1 = require("@bitgo/public-types");
+const account_lib_1 = require("../../../../account-lib");
+const tss_1 = require("../../../tss");
+const common_1 = require("../../../tss/common");
+const typesMPCv2_1 = require("./typesMPCv2");
+const ecdsaMPCv2_1 = require("../../../tss/ecdsa/ecdsaMPCv2");
+const opengpgUtils_1 = require("../../opengpgUtils");
+const baseTypes_1 = require("../baseTypes");
+const preHashedSignable_1 = require("../preHashedSignable");
+const serializedTxHexVerify_1 = require("../serializedTxHexVerify");
+const base_1 = require("./base");
+const ecdsaMPCv2KeyGenSender_1 = require("./ecdsaMPCv2KeyGenSender");
+const bitgoPubKeys_1 = require("../../../tss/bitgoPubKeys");
+const errors_1 = require("../../../errors");
+const recipientUtils_1 = require("../recipientUtils");
+class EcdsaMPCv2Utils extends base_1.BaseEcdsaUtils {
+    /** @inheritdoc */
+    async createKeychains(params) {
+        const { userSession, backupSession } = this.getUserAndBackupSession(2, 3, params.retrofit);
+        const userGpgKey = await (0, opengpgUtils_1.generateGPGKeyPair)('secp256k1');
+        const backupGpgKey = await (0, opengpgUtils_1.generateGPGKeyPair)('secp256k1');
+        // Get the BitGo public key based on user/enterprise feature flags
+        // If it doesn't work, use the default public key from the constants
+        const { mpcv2PublicKey } = await this.getBitgoGpgPubkeyBasedOnFeatureFlags(params.enterprise, true);
+        const mpcv2Key = mpcv2PublicKey ?? this.bitgoMPCv2PublicGpgKey;
+        (0, assert_1.default)(mpcv2Key, 'Failed to get BitGo MPCv2 GPG public key');
+        const bitgoPublicGpgKey = mpcv2Key.armor();
+        if ((0, bitgoPubKeys_1.envRequiresBitgoPubGpgKeyConfig)(this.bitgo.getEnv())) {
+            // Ensure the public key is one of the expected BitGo public keys when in test or prod.
+            (0, assert_1.default)((0, bitgoPubKeys_1.isBitgoMpcPubKey)(bitgoPublicGpgKey, 'mpcv2'), 'Invalid BitGo GPG public key');
+        }
+        const userGpgPrvKey = {
+            partyId: typesMPCv2_1.MPCv2PartiesEnum.USER,
+            gpgKey: userGpgKey.privateKey,
+        };
+        const backupGpgPrvKey = {
+            partyId: typesMPCv2_1.MPCv2PartiesEnum.BACKUP,
+            gpgKey: backupGpgKey.privateKey,
+        };
+        const bitgoGpgPubKey = {
+            partyId: typesMPCv2_1.MPCv2PartiesEnum.BITGO,
+            gpgKey: bitgoPublicGpgKey,
+        };
+        // #region round 1
+        const userRound1BroadcastMsg = await userSession.initDkg();
+        const backupRound1BroadcastMsg = await backupSession.initDkg();
+        const round1SerializedMessages = sdk_lib_mpc_1.DklsTypes.serializeMessages({
+            broadcastMessages: [userRound1BroadcastMsg, backupRound1BroadcastMsg],
+            p2pMessages: [],
+        });
+        const round1Messages = await sdk_lib_mpc_1.DklsComms.encryptAndAuthOutgoingMessages(round1SerializedMessages, [bitgoGpgPubKey], [userGpgPrvKey, backupGpgPrvKey]);
+        const { sessionId, bitgoMsg1, bitgoToBackupMsg2, bitgoToUserMsg2 } = await this.sendKeyGenerationRound1(params.enterprise, userGpgKey.publicKey, backupGpgKey.publicKey, params.retrofit?.walletId
+            ? {
+                ...round1Messages,
+                walletId: params.retrofit.walletId,
+            }
+            : round1Messages, params.safeId);
+        // #endregion
+        // #region round 2
+        const bitgoRound1BroadcastMessages = await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({ p2pMessages: [], broadcastMessages: [this.formatBitgoBroadcastMessage(bitgoMsg1)] }, [bitgoGpgPubKey], [userGpgPrvKey, backupGpgPrvKey]);
+        const bitgoRound1BroadcastMsg = bitgoRound1BroadcastMessages.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(bitgoRound1BroadcastMsg, 'BitGo message 1 not found in broadcast messages');
+        const userRound2P2PMessages = userSession.handleIncomingMessages({
+            p2pMessages: [],
+            broadcastMessages: [sdk_lib_mpc_1.DklsTypes.deserializeBroadcastMessage(bitgoRound1BroadcastMsg), backupRound1BroadcastMsg],
+        });
+        const userToBitgoMsg2 = userRound2P2PMessages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(userToBitgoMsg2, 'User message 2 not found in P2P messages');
+        const serializedUserToBitgoMsg2 = sdk_lib_mpc_1.DklsTypes.serializeP2PMessage(userToBitgoMsg2);
+        const backupRound2P2PMessages = backupSession.handleIncomingMessages({
+            p2pMessages: [],
+            broadcastMessages: [userRound1BroadcastMsg, sdk_lib_mpc_1.DklsTypes.deserializeBroadcastMessage(bitgoRound1BroadcastMsg)],
+        });
+        const serializedBackupToBitgoMsg2 = sdk_lib_mpc_1.DklsTypes.serializeMessages(backupRound2P2PMessages).p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(serializedBackupToBitgoMsg2, 'Backup message 2 not found in P2P messages');
+        const round2Messages = await sdk_lib_mpc_1.DklsComms.encryptAndAuthOutgoingMessages({ p2pMessages: [serializedUserToBitgoMsg2, serializedBackupToBitgoMsg2], broadcastMessages: [] }, [bitgoGpgPubKey], [userGpgPrvKey, backupGpgPrvKey]);
+        const { sessionId: sessionIdRound2, bitgoCommitment2, bitgoToUserMsg3, bitgoToBackupMsg3, } = await this.sendKeyGenerationRound2(params.enterprise, sessionId, round2Messages);
+        // #endregion
+        // #region round 3
+        assert_1.default.equal(sessionId, sessionIdRound2, 'Round 1 and 2 Session IDs do not match');
+        const decryptedBitgoToUserRound2Msgs = await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({ p2pMessages: [this.formatP2PMessage(bitgoToUserMsg2)], broadcastMessages: [] }, [bitgoGpgPubKey], [userGpgPrvKey]);
+        const serializedBitgoToUserRound2Msg = decryptedBitgoToUserRound2Msgs.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BITGO && m.to === typesMPCv2_1.MPCv2PartiesEnum.USER);
+        (0, assert_1.default)(serializedBitgoToUserRound2Msg, 'BitGo to User message 2 not found in P2P messages');
+        const bitgoToUserRound2Msg = sdk_lib_mpc_1.DklsTypes.deserializeP2PMessage(serializedBitgoToUserRound2Msg);
+        const decryptedBitgoToBackupRound2Msg = await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({ p2pMessages: [this.formatP2PMessage(bitgoToBackupMsg2)], broadcastMessages: [] }, [bitgoGpgPubKey], [backupGpgPrvKey]);
+        const serializedBitgoToBackupRound2Msg = decryptedBitgoToBackupRound2Msg.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BITGO && m.to === typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        (0, assert_1.default)(serializedBitgoToBackupRound2Msg, 'BitGo to Backup message 2 not found in P2P messages');
+        const bitgoToBackupRound2Msg = sdk_lib_mpc_1.DklsTypes.deserializeP2PMessage(serializedBitgoToBackupRound2Msg);
+        const userToBackupMsg2 = userRound2P2PMessages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER && m.to === typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        (0, assert_1.default)(userToBackupMsg2, 'User to Backup message 2 not found in P2P messages');
+        const backupToUserMsg2 = backupRound2P2PMessages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP && m.to === typesMPCv2_1.MPCv2PartiesEnum.USER);
+        (0, assert_1.default)(backupToUserMsg2, 'Backup to User message 2 not found in P2P messages');
+        const userRound3Messages = userSession.handleIncomingMessages({
+            broadcastMessages: [],
+            p2pMessages: [bitgoToUserRound2Msg, backupToUserMsg2],
+        });
+        const userToBackupMsg3 = userRound3Messages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER && m.to === typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        (0, assert_1.default)(userToBackupMsg3, 'User to Backup message 3 not found in P2P messages');
+        const userToBitgoMsg3 = userRound3Messages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(userToBitgoMsg3, 'User to Bitgo message 3 not found in P2P messages');
+        const serializedUserToBitgoMsg3 = sdk_lib_mpc_1.DklsTypes.serializeP2PMessage(userToBitgoMsg3);
+        const backupRound3Messages = backupSession.handleIncomingMessages({
+            broadcastMessages: [],
+            p2pMessages: [bitgoToBackupRound2Msg, userToBackupMsg2],
+        });
+        const backupToUserMsg3 = backupRound3Messages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP && m.to === typesMPCv2_1.MPCv2PartiesEnum.USER);
+        (0, assert_1.default)(backupToUserMsg3, 'Backup to User message 3 not found in P2P messages');
+        const backupToBitgoMsg3 = backupRound3Messages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(backupToBitgoMsg3, 'Backup to Bitgo message 3 not found in P2P messages');
+        const serializedBackupToBitgoMsg3 = sdk_lib_mpc_1.DklsTypes.serializeP2PMessage(backupToBitgoMsg3);
+        const decryptedBitgoToUserRound3Messages = await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({ broadcastMessages: [], p2pMessages: [this.formatP2PMessage(bitgoToUserMsg3, bitgoCommitment2)] }, [bitgoGpgPubKey], [userGpgPrvKey]);
+        const serializedBitgoToUserRound3Msg = decryptedBitgoToUserRound3Messages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BITGO && m.to === typesMPCv2_1.MPCv2PartiesEnum.USER);
+        (0, assert_1.default)(serializedBitgoToUserRound3Msg, 'BitGo to User message 3 not found in P2P messages');
+        const bitgoToUserRound3Msg = sdk_lib_mpc_1.DklsTypes.deserializeP2PMessage(serializedBitgoToUserRound3Msg);
+        const decryptedBitgoToBackupRound3Messages = await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({ broadcastMessages: [], p2pMessages: [this.formatP2PMessage(bitgoToBackupMsg3, bitgoCommitment2)] }, [bitgoGpgPubKey], [backupGpgPrvKey]);
+        const serializedBitgoToBackupRound3Msg = decryptedBitgoToBackupRound3Messages.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BITGO && m.to === typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        (0, assert_1.default)(serializedBitgoToBackupRound3Msg, 'BitGo to Backup message 3 not found in P2P messages');
+        const bitgoToBackupRound3Msg = sdk_lib_mpc_1.DklsTypes.deserializeP2PMessage(serializedBitgoToBackupRound3Msg);
+        const userRound4Messages = userSession.handleIncomingMessages({
+            p2pMessages: [backupToUserMsg3, bitgoToUserRound3Msg],
+            broadcastMessages: [],
+        });
+        const userRound4BroadcastMsg = userRound4Messages.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER);
+        (0, assert_1.default)(userRound4BroadcastMsg, 'User message 4 not found in broadcast messages');
+        const serializedUserRound4BroadcastMsg = sdk_lib_mpc_1.DklsTypes.serializeBroadcastMessage(userRound4BroadcastMsg);
+        const backupRound4Messages = backupSession.handleIncomingMessages({
+            p2pMessages: [userToBackupMsg3, bitgoToBackupRound3Msg],
+            broadcastMessages: [],
+        });
+        const backupRound4BroadcastMsg = backupRound4Messages.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        (0, assert_1.default)(backupRound4BroadcastMsg, 'Backup message 4 not found in broadcast messages');
+        const serializedBackupRound4BroadcastMsg = sdk_lib_mpc_1.DklsTypes.serializeBroadcastMessage(backupRound4BroadcastMsg);
+        const round3Messages = await sdk_lib_mpc_1.DklsComms.encryptAndAuthOutgoingMessages({
+            p2pMessages: [serializedUserToBitgoMsg3, serializedBackupToBitgoMsg3],
+            broadcastMessages: [serializedUserRound4BroadcastMsg, serializedBackupRound4BroadcastMsg],
+        }, [bitgoGpgPubKey], [userGpgPrvKey, backupGpgPrvKey]);
+        const { sessionId: sessionIdRound3, bitgoMsg4, commonKeychain: bitgoCommonKeychain, } = await this.sendKeyGenerationRound3(params.enterprise, sessionId, round3Messages);
+        // #endregion
+        // #region keychain creation
+        assert_1.default.equal(sessionId, sessionIdRound3, 'Round 1 and 3 Session IDs do not match');
+        const bitgoRound4BroadcastMessages = sdk_lib_mpc_1.DklsTypes.deserializeMessages(await sdk_lib_mpc_1.DklsComms.decryptAndVerifyIncomingMessages({ p2pMessages: [], broadcastMessages: [this.formatBitgoBroadcastMessage(bitgoMsg4)] }, [bitgoGpgPubKey], [])).broadcastMessages;
+        const bitgoRound4BroadcastMsg = bitgoRound4BroadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(bitgoRound4BroadcastMsg, 'BitGo message 4 not found in broadcast messages');
+        userSession.handleIncomingMessages({
+            p2pMessages: [],
+            broadcastMessages: [bitgoRound4BroadcastMsg, backupRound4BroadcastMsg],
+        });
+        backupSession.handleIncomingMessages({
+            p2pMessages: [],
+            broadcastMessages: [bitgoRound4BroadcastMsg, userRound4BroadcastMsg],
+        });
+        const userPrivateMaterial = userSession.getKeyShare();
+        const backupPrivateMaterial = backupSession.getKeyShare();
+        const userReducedPrivateMaterial = userSession.getReducedKeyShare();
+        const backupReducedPrivateMaterial = backupSession.getReducedKeyShare();
+        const userCommonKeychain = sdk_lib_mpc_1.DklsTypes.getCommonKeychain(userPrivateMaterial);
+        const backupCommonKeychain = sdk_lib_mpc_1.DklsTypes.getCommonKeychain(backupPrivateMaterial);
+        assert_1.default.equal(bitgoCommonKeychain, userCommonKeychain, 'User and Bitgo Common keychains do not match');
+        assert_1.default.equal(bitgoCommonKeychain, backupCommonKeychain, 'Backup and Bitgo Common keychains do not match');
+        const encryptionSession = params.encryptionVersion === 2 ? await this.bitgo.createEncryptionSession(params.passphrase) : undefined;
+        try {
+            const userKeychainPromise = this.addUserKeychain(bitgoCommonKeychain, userPrivateMaterial, userReducedPrivateMaterial, params.passphrase, params.originalPasscodeEncryptionCode, params.webauthnInfo, encryptionSession, params.encryptionVersion, params.enterprise, params.safeId);
+            const backupKeychainPromise = this.addBackupKeychain(bitgoCommonKeychain, backupPrivateMaterial, backupReducedPrivateMaterial, params.passphrase, params.originalPasscodeEncryptionCode, encryptionSession, params.encryptionVersion, params.safeId);
+            const bitgoKeychainPromise = this.addBitgoKeychain(bitgoCommonKeychain, params.safeId);
+            const [userKeychain, backupKeychain, bitgoKeychain] = await Promise.all([
+                userKeychainPromise,
+                backupKeychainPromise,
+                bitgoKeychainPromise,
+            ]);
+            // #endregion
+            return {
+                userKeychain,
+                backupKeychain,
+                bitgoKeychain,
+            };
+        }
+        finally {
+            encryptionSession?.destroy();
+        }
+    }
+    // #region keychain utils
+    async createParticipantKeychain(participantIndex, commonKeychain, privateMaterial, reducedPrivateMaterial, passphrase, originalPasscodeEncryptionCode, webauthnInfo, encryptionSession, encryptionVersion, enterprise, safeId) {
+        let source;
+        let encryptedPrv = undefined;
+        let reducedEncryptedPrv = undefined;
+        let privateMaterialBase64 = undefined;
+        switch (participantIndex) {
+            case typesMPCv2_1.MPCv2PartiesEnum.USER:
+            case typesMPCv2_1.MPCv2PartiesEnum.BACKUP:
+                source = participantIndex === typesMPCv2_1.MPCv2PartiesEnum.USER ? 'user' : 'backup';
+                (0, assert_1.default)(privateMaterial, `Private material is required for ${source} keychain`);
+                (0, assert_1.default)(reducedPrivateMaterial, `Reduced private material is required for ${source} keychain`);
+                (0, assert_1.default)(passphrase, `Passphrase is required for ${source} keychain`);
+                privateMaterialBase64 = privateMaterial.toString('base64');
+                if (encryptionSession) {
+                    encryptedPrv = await encryptionSession.encrypt(privateMaterialBase64);
+                    reducedEncryptedPrv = await encryptionSession.encrypt(btoa(String.fromCharCode.apply(null, Array.from(new Uint8Array(reducedPrivateMaterial)))));
+                }
+                else {
+                    encryptedPrv = await this.bitgo.encrypt({
+                        input: privateMaterialBase64,
+                        password: passphrase,
+                        encryptionVersion,
+                    });
+                    // Encrypts the CBOR-encoded ReducedKeyShare (which contains the party's private
+                    // scalar s_i) with the wallet passphrase. The result is stored as reducedEncryptedPrv
+                    // on the key card QR code and represents a second copy of private key material
+                    // beyond the server-stored encryptedPrv.
+                    reducedEncryptedPrv = await this.bitgo.encrypt({
+                        // Buffer.toString('base64') can not be used here as it does not work on the browser.
+                        // The browser deals with a Buffer as Uint8Array, therefore in the browser .toString('base64') just creates a comma seperated string of the array values.
+                        input: btoa(String.fromCharCode.apply(null, Array.from(new Uint8Array(reducedPrivateMaterial)))),
+                        password: passphrase,
+                        encryptionVersion,
+                    });
+                }
+                break;
+            case typesMPCv2_1.MPCv2PartiesEnum.BITGO:
+                source = 'bitgo';
+                break;
+            default:
+                throw new Error('Invalid participant index');
+        }
+        const recipientKeychainParams = {
+            source,
+            keyType: 'tss',
+            commonKeychain,
+            encryptedPrv,
+            originalPasscodeEncryptionCode,
+            isMPCv2: true,
+            safeId,
+        };
+        if (webauthnInfo && participantIndex === typesMPCv2_1.MPCv2PartiesEnum.USER && privateMaterialBase64) {
+            // Send the passkey as `webauthnInfo`; the deprecated `webauthnDevices` array is ignored by POST /key.
+            (0, assert_1.default)(enterprise, 'enterprise is required to attach a webauthn device to the user keychain');
+            recipientKeychainParams.webauthnInfo = {
+                otpDeviceId: webauthnInfo.otpDeviceId,
+                prfSalt: webauthnInfo.prfSalt,
+                encryptedPrv: await this.bitgo.encrypt({
+                    input: privateMaterialBase64,
+                    password: webauthnInfo.passphrase,
+                    encryptionVersion,
+                }),
+                enterpriseId: enterprise,
+            };
+        }
+        const keychains = this.baseCoin.keychains();
+        return { ...(await keychains.add(recipientKeychainParams)), reducedEncryptedPrv: reducedEncryptedPrv };
+    }
+    /**
+     * Converts a User or Backup MPCv1 SigningMaterial to RetrofitData needed by MPCv2 DKG.
+     *
+     * @param decryptedKeyshare - MPCv1 decrypted signing material for user or backup as a json.stringify string and bitgo's Big Si.
+     * @param partyId - The party ID of the MPCv1 keyshare.
+     * @returns The retrofit data needed to start an MPCv2 DKG session.
+     * @deprecated
+     */
+    static getKeyDataForRetrofit(decryptedKeyshare, partyId) {
+        const mpc = new account_lib_1.Ecdsa();
+        const xiList = [
+            Array.from((0, sdk_lib_mpc_1.bigIntToBufferBE)(BigInt(1), 32)),
+            Array.from((0, sdk_lib_mpc_1.bigIntToBufferBE)(BigInt(2), 32)),
+            Array.from((0, sdk_lib_mpc_1.bigIntToBufferBE)(BigInt(3), 32)),
+        ];
+        return EcdsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key({
+            mpcv1PartyKeyShare: decryptedKeyshare,
+            mpcv1PartyIndex: partyId === typesMPCv2_1.MPCv2PartiesEnum.USER ? 1 : 2,
+            xiList,
+            mpc,
+        });
+    }
+    /**
+     * Converts user and backup MPCv1 SigningMaterial to RetrofitData needed by MPCv2 DKG.
+     *
+     * @param {Object} params - MPCv1 decrypted signing material for user and backup as a json.stringify string and bitgo's Big Si.
+     * @returns {{ mpcv2UserKeyShare: DklsTypes.RetrofitData; mpcv2BakcupKeyShare: DklsTypes.RetrofitData }} - the retrofit data needed to start an MPCv2 DKG session.
+     */
+    getMpcV2RetrofitDataFromMpcV1Keys(params) {
+        const mpc = new account_lib_1.Ecdsa();
+        const xiList = [
+            Array.from((0, sdk_lib_mpc_1.bigIntToBufferBE)(BigInt(1), 32)),
+            Array.from((0, sdk_lib_mpc_1.bigIntToBufferBE)(BigInt(2), 32)),
+            Array.from((0, sdk_lib_mpc_1.bigIntToBufferBE)(BigInt(3), 32)),
+        ];
+        return {
+            mpcv2UserKeyShare: EcdsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key({
+                mpcv1PartyKeyShare: params.mpcv1UserKeyShare,
+                mpcv1PartyIndex: 1,
+                xiList,
+                mpc,
+            }),
+            mpcv2BackupKeyShare: EcdsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key({
+                mpcv1PartyKeyShare: params.mpcv1BackupKeyShare,
+                mpcv1PartyIndex: 2,
+                xiList,
+                mpc,
+            }),
+        };
+    }
+    /**
+     * Get retrofit data from MPCv1 key share.
+     * @param mpcv1PartyKeyShare
+     * @param mpcv1PartyIndex
+     * @param xiList
+     * @param mpc
+     * @deprecated
+     */
+    static getMpcV2RetrofitDataFromMpcV1Key({ mpcv1PartyKeyShare, mpcv1PartyIndex, xiList, mpc, }) {
+        const signingMaterial = JSON.parse(mpcv1PartyKeyShare);
+        let keyCombined = undefined;
+        switch (mpcv1PartyIndex) {
+            case 1:
+                (0, assert_1.default)(signingMaterial.backupNShare, 'User MPCv1 key material should have backup NShare.');
+                (0, assert_1.default)(signingMaterial.bitgoNShare, 'BitGo MPCv1 key material should have user NShare.');
+                keyCombined = mpc.keyCombine(signingMaterial.pShare, [
+                    signingMaterial.backupNShare,
+                    signingMaterial.bitgoNShare,
+                ]);
+                break;
+            case 2:
+                (0, assert_1.default)(signingMaterial.userNShare, 'User MPCv1 key material should have backup NShare.');
+                (0, assert_1.default)(signingMaterial.bitgoNShare, 'BitGo MPCv1 key material should have user NShare.');
+                keyCombined = mpc.keyCombine(signingMaterial.pShare, [signingMaterial.userNShare, signingMaterial.bitgoNShare]);
+                break;
+            case 3:
+                (0, assert_1.default)(signingMaterial.userNShare, 'User MPCv1 key material should have backup NShare.');
+                (0, assert_1.default)(signingMaterial.backupNShare, 'Backup MPCv1 key material should have user NShare.');
+                keyCombined = mpc.keyCombine(signingMaterial.pShare, [
+                    signingMaterial.userNShare,
+                    signingMaterial.backupNShare,
+                ]);
+                break;
+            default:
+                throw new Error('Invalid participant index');
+        }
+        return {
+            xShare: keyCombined.xShare,
+            xiList: xiList,
+        };
+    }
+    async addUserKeychain(commonKeychain, privateMaterial, reducedPrivateMaterial, passphrase, originalPasscodeEncryptionCode, webauthnInfo, encryptionSession, encryptionVersion, enterprise, safeId) {
+        return this.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.USER, commonKeychain, privateMaterial, reducedPrivateMaterial, passphrase, originalPasscodeEncryptionCode, webauthnInfo, encryptionSession, encryptionVersion, enterprise, safeId);
+    }
+    async addBackupKeychain(commonKeychain, privateMaterial, reducedPrivateMaterial, passphrase, originalPasscodeEncryptionCode, encryptionSession, encryptionVersion, safeId) {
+        return this.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.BACKUP, commonKeychain, privateMaterial, reducedPrivateMaterial, passphrase, originalPasscodeEncryptionCode, undefined, encryptionSession, encryptionVersion, undefined, safeId);
+    }
+    getUserAndBackupSession(m, n, retrofit) {
+        if (retrofit) {
+            const retrofitData = this.getMpcV2RetrofitDataFromMpcV1Keys({
+                mpcv1UserKeyShare: retrofit.decryptedUserKey,
+                mpcv1BackupKeyShare: retrofit.decryptedBackupKey,
+            });
+            const userSession = new sdk_lib_mpc_1.DklsDkg.Dkg(n, m, typesMPCv2_1.MPCv2PartiesEnum.USER, undefined, retrofitData.mpcv2UserKeyShare);
+            const backupSession = new sdk_lib_mpc_1.DklsDkg.Dkg(n, m, typesMPCv2_1.MPCv2PartiesEnum.BACKUP, undefined, retrofitData.mpcv2BackupKeyShare);
+            return { userSession, backupSession };
+        }
+        const userSession = new sdk_lib_mpc_1.DklsDkg.Dkg(n, m, typesMPCv2_1.MPCv2PartiesEnum.USER);
+        const backupSession = new sdk_lib_mpc_1.DklsDkg.Dkg(n, m, typesMPCv2_1.MPCv2PartiesEnum.BACKUP);
+        return { userSession, backupSession };
+    }
+    async addBitgoKeychain(commonKeychain, safeId) {
+        return this.createParticipantKeychain(typesMPCv2_1.MPCv2PartiesEnum.BITGO, commonKeychain, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, safeId);
+    }
+    // #endregion
+    /**
+     * Creates ECDSA MPCv2 keychains using external signer callbacks instead of a passphrase.
+     * The external signer holds all private key material; the SDK only coordinates the DKG protocol.
+     */
+    async createKeychainsWithExternalSigner(params) {
+        const { enterprise, callbacks } = params;
+        const { mpcv2PublicKey } = await this.getBitgoGpgPubkeyBasedOnFeatureFlags(enterprise, true);
+        const mpcv2Key = mpcv2PublicKey ?? this.bitgoMPCv2PublicGpgKey;
+        (0, assert_1.default)(mpcv2Key, 'Failed to get BitGo MPCv2 GPG public key');
+        const bitgoPublicGpgKey = mpcv2Key.armor();
+        if ((0, bitgoPubKeys_1.envRequiresBitgoPubGpgKeyConfig)(this.bitgo.getEnv())) {
+            (0, assert_1.default)((0, bitgoPubKeys_1.isBitgoMpcPubKey)(bitgoPublicGpgKey, 'mpcv2'), 'Invalid BitGo GPG public key');
+        }
+        // Round 1: external signer generates GPG keys and initial DKG messages
+        const { userGpgPublicKey, backupGpgPublicKey, round1Messages, userState, backupState } = await callbacks.initializeCallback({
+            enterprise,
+            bitgoPublicGpgKey,
+        });
+        const { sessionId, bitgoMsg1, bitgoToUserMsg2, bitgoToBackupMsg2 } = await this.sendKeyGenerationRound1(enterprise, userGpgPublicKey, backupGpgPublicKey, round1Messages);
+        // Round 2: external signer processes BitGo's round 1 response
+        const { round2Messages, userState: userStateAfter2, backupState: backupStateAfter2, } = await callbacks.round2Callback({
+            sessionId,
+            bitgoMsg1,
+            bitgoToUserMsg2,
+            bitgoToBackupMsg2,
+            userState,
+            backupState,
+        });
+        const round2Response = await this.sendKeyGenerationRound2(enterprise, sessionId, round2Messages);
+        assert_1.default.strictEqual(round2Response.sessionId, sessionId, 'Session ID mismatch after round 2');
+        // Round 3: external signer processes BitGo's round 2 response
+        const { round3Messages, userState: userStateAfter3, backupState: backupStateAfter3, } = await callbacks.round3Callback({
+            sessionId,
+            bitgoCommitment2: round2Response.bitgoCommitment2,
+            bitgoToUserMsg3: round2Response.bitgoToUserMsg3,
+            bitgoToBackupMsg3: round2Response.bitgoToBackupMsg3,
+            userState: userStateAfter2,
+            backupState: backupStateAfter2,
+        });
+        const round3Response = await this.sendKeyGenerationRound3(enterprise, sessionId, round3Messages);
+        assert_1.default.strictEqual(round3Response.sessionId, sessionId, 'Session ID mismatch after round 3');
+        // Finalize: external signer verifies BitGo's final message against the derived common keychain
+        const { commonKeychain } = await callbacks.finalizeCallback({
+            sessionId,
+            bitgoMsg4: round3Response.bitgoMsg4,
+            bitgoCommonKeychain: round3Response.commonKeychain,
+            userState: userStateAfter3,
+            backupState: backupStateAfter3,
+        });
+        assert_1.default.strictEqual(commonKeychain, round3Response.commonKeychain, 'Common keychains do not match');
+        const keychains = this.baseCoin.keychains();
+        const [userKeychain, backupKeychain, bitgoKeychain] = await Promise.all([
+            keychains.add({ source: 'user', keyType: 'tss', commonKeychain, isMPCv2: true }),
+            keychains.add({ source: 'backup', keyType: 'tss', commonKeychain, isMPCv2: true }),
+            this.addBitgoKeychain(commonKeychain),
+        ]);
+        return { userKeychain, backupKeychain, bitgoKeychain };
+    }
+    async sendKeyGenerationRound1(enterprise, userGpgPublicKey, backupGpgPublicKey, payload, safeId) {
+        return this.sendKeyGenerationRound1BySender((0, ecdsaMPCv2KeyGenSender_1.KeyGenSenderForEnterprise)(this.bitgo, enterprise, safeId), userGpgPublicKey, backupGpgPublicKey, payload);
+    }
+    async sendKeyGenerationRound2(enterprise, sessionId, payload) {
+        return this.sendKeyGenerationRound2BySender((0, ecdsaMPCv2KeyGenSender_1.KeyGenSenderForEnterprise)(this.bitgo, enterprise), sessionId, payload);
+    }
+    async sendKeyGenerationRound3(enterprise, sessionId, payload) {
+        return this.sendKeyGenerationRound3BySender((0, ecdsaMPCv2KeyGenSender_1.KeyGenSenderForEnterprise)(this.bitgo, enterprise), sessionId, payload);
+    }
+    async sendKeyGenerationRound1BySender(senderFn, userGpgPublicKey, backupGpgPublicKey, payload) {
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(userGpgPublicKey), 'User GPG public key is required');
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(backupGpgPublicKey), 'Backup GPG public key is required');
+        const userMsg1 = payload.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER)?.payload;
+        (0, assert_1.default)(userMsg1, 'User message 1 not found in broadcast messages');
+        const backupMsg1 = payload.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP)?.payload;
+        (0, assert_1.default)(backupMsg1, 'Backup message 1 not found in broadcast messages');
+        return senderFn(public_types_1.MPCv2KeyGenStateEnum['MPCv2-R1'], {
+            userGpgPublicKey,
+            backupGpgPublicKey,
+            userMsg1: { from: 0, ...userMsg1 },
+            backupMsg1: { from: 1, ...backupMsg1 },
+            walletId: payload.walletId,
+        });
+    }
+    async sendKeyGenerationRound2BySender(senderFn, sessionId, payload) {
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(sessionId), 'Session ID is required');
+        const userMsg2 = payload.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(userMsg2, 'User to Bitgo message 2 not found in P2P messages');
+        (0, assert_1.default)(userMsg2.commitment, 'User to Bitgo commitment not found in P2P messages');
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(userMsg2.commitment), 'User to Bitgo commitment is required');
+        const backupMsg2 = payload.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO);
+        (0, assert_1.default)(backupMsg2, 'Backup to Bitgo message 2 not found in P2P messages');
+        (0, assert_1.default)(backupMsg2.commitment, 'Backup to Bitgo commitment not found in P2P messages');
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(backupMsg2.commitment), 'Backup to Bitgo commitment is required');
+        return senderFn(public_types_1.MPCv2KeyGenStateEnum['MPCv2-R2'], {
+            sessionId,
+            userMsg2: {
+                from: typesMPCv2_1.MPCv2PartiesEnum.USER,
+                to: typesMPCv2_1.MPCv2PartiesEnum.BITGO,
+                signature: userMsg2.payload.signature,
+                encryptedMessage: userMsg2.payload.encryptedMessage,
+            },
+            userCommitment2: userMsg2.commitment,
+            backupMsg2: {
+                from: typesMPCv2_1.MPCv2PartiesEnum.BACKUP,
+                to: typesMPCv2_1.MPCv2PartiesEnum.BITGO,
+                signature: backupMsg2.payload.signature,
+                encryptedMessage: backupMsg2.payload.encryptedMessage,
+            },
+            backupCommitment2: backupMsg2.commitment,
+        });
+    }
+    async sendKeyGenerationRound3BySender(senderFn, sessionId, payload) {
+        (0, assert_1.default)(io_ts_types_1.NonEmptyString.is(sessionId), 'Session ID is required');
+        const userMsg3 = payload.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO)?.payload;
+        (0, assert_1.default)(userMsg3, 'User to Bitgo message 3 not found in P2P messages');
+        const backupMsg3 = payload.p2pMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP && m.to === typesMPCv2_1.MPCv2PartiesEnum.BITGO)?.payload;
+        (0, assert_1.default)(backupMsg3, 'Backup to Bitgo message 3 not found in P2P messages');
+        const userMsg4 = payload.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.USER)?.payload;
+        (0, assert_1.default)(userMsg4, 'User message 1 not found in broadcast messages');
+        const backupMsg4 = payload.broadcastMessages.find((m) => m.from === typesMPCv2_1.MPCv2PartiesEnum.BACKUP)?.payload;
+        (0, assert_1.default)(backupMsg4, 'Backup message 1 not found in broadcast messages');
+        return senderFn(public_types_1.MPCv2KeyGenStateEnum['MPCv2-R3'], {
+            sessionId,
+            userMsg3: { from: 0, to: 2, ...userMsg3 },
+            backupMsg3: { from: 1, to: 2, ...backupMsg3 },
+            userMsg4: { from: 0, ...userMsg4 },
+            backupMsg4: { from: 1, ...backupMsg4 },
+        });
+    }
+    // #endregion
+    // #region sign tx request
+    /**
+     * Signs the transaction associated to the transaction request.
+     * @param {string | TxRequest} params.txRequest - transaction request object or id
+     * @param {string} params.prv - decrypted private key
+     * @param {string} params.reqId - request id
+     * @param {string} params.mpcv2PartyId - party id for the signer involved in this mpcv2 request (either 0 for user or 1 for backup)
+     * @param params.recipientSource - optional; use TssTxRecipientSource.Explicit with a non-empty txParams.recipients
+     *   list when you want TypeScript to enforce passing recipient details at compile time.
+     * @returns {Promise<TxRequest>} fully signed TxRequest object
+     */
+    async signTxRequest(params) {
+        this.bitgo.setRequestTracer(params.reqId);
+        return this.signRequestBase(params, baseTypes_1.RequestType.tx);
+    }
+    /**
+     * Signs the message associated to the transaction request.
+     * @param {string | TxRequest} params.txRequest - transaction request object or id
+     * @param {string} params.prv - decrypted private key
+     * @param {string} params.reqId - request id
+     * @returns {Promise<TxRequest>} fully signed TxRequest object
+     */
+    async signTxRequestForMessage(params) {
+        this.bitgo.setRequestTracer(params.reqId);
+        return this.signRequestBase(params, baseTypes_1.RequestType.message);
+    }
+    async signRequestBase(params, requestType) {
+        const userKeyShare = buffer_1.Buffer.from(params.prv, 'base64');
+        const txRequest = typeof params.txRequest === 'string'
+            ? await (0, tss_1.getTxRequest)(this.bitgo, this.wallet.id(), params.txRequest, params.reqId)
+            : params.txRequest;
+        let txOrMessageToSign;
+        let derivationPath;
+        let bufferContent;
+        let serializedTxHex;
+        const userGpgKey = await (0, opengpgUtils_1.generateGPGKeyPair)('secp256k1');
+        const bitgoGpgPubKey = await this.pickBitgoPubGpgKeyForSigning(true, params.reqId, txRequest.enterpriseId);
+        if (!bitgoGpgPubKey) {
+            throw new Error('Missing BitGo GPG key for MPCv2');
+        }
+        if (requestType === baseTypes_1.RequestType.tx) {
+            (0, assert_1.default)(txRequest.transactions || txRequest.unsignedTxs, 'Unable to find transactions in txRequest');
+            const unsignedTx = txRequest.apiVersion === 'full' ? txRequest.transactions[0].unsignedTx : txRequest.unsignedTxs[0];
+            if ('recipientSource' in params &&
+                params.recipientSource === baseTypes_1.TssTxRecipientSource.Explicit &&
+                !params.txParams?.recipients?.length) {
+                throw new errors_1.InvalidTransactionError('recipientSource "explicit" requires txParams.recipients with at least one recipient.');
+            }
+            // For some coins, signableHex is not a parseable transaction. Pass
+            // serializedTxHex so verifyTransaction can decode the full tx bytes.
+            // - CoinFeature.TSS_VERIFY_USE_SERIALIZED_TX_HEX: ICP hash digests,
+            //   BSC/XDC legacy EIP-155 RLP with v=chainId, etc.
+            // - Avalanche atomic (FLRP/FLR cross-chain): signableHex is SHA-256(txBody);
+            //   serializedTxHex is the PVM/EVM atomic tx (codec prefix 0x0000).
+            // For other coins, signableHex IS the unsigned transaction (e.g. EIP-1559 RLP).
+            if ((0, serializedTxHexVerify_1.shouldVerifyWithSerializedTxHex)(this.baseCoin) || (0, preHashedSignable_1.shouldUsePreHashedSignable)(this.baseCoin, unsignedTx)) {
+                await this.baseCoin.verifyTransaction({
+                    txPrebuild: { txHex: unsignedTx.serializedTxHex, txInfo: unsignedTx.signableHex },
+                    txParams: (0, recipientUtils_1.resolveEffectiveTxParams)(txRequest, params.txParams),
+                    wallet: this.wallet,
+                    walletType: this.wallet.multisigType(),
+                });
+            }
+            else {
+                await this.baseCoin.verifyTransaction({
+                    txPrebuild: { txHex: unsignedTx.signableHex },
+                    txParams: (0, recipientUtils_1.resolveEffectiveTxParams)(txRequest, params.txParams),
+                    wallet: this.wallet,
+                    walletType: this.wallet.multisigType(),
+                });
+            }
+            txOrMessageToSign = unsignedTx.signableHex;
+            derivationPath = unsignedTx.derivationPath;
+            serializedTxHex = unsignedTx.serializedTxHex;
+            bufferContent = buffer_1.Buffer.from(txOrMessageToSign, 'hex');
+        }
+        else if (requestType === baseTypes_1.RequestType.message) {
+            txOrMessageToSign = txRequest.messages[0].messageEncoded;
+            derivationPath = txRequest.messages[0].derivationPath || 'm/0';
+            bufferContent = buffer_1.Buffer.from(txOrMessageToSign, 'hex');
+        }
+        else {
+            throw new Error('Invalid request type');
+        }
+        // For Avalanche atomic transactions (cross-chain export/import between
+        // C-chain and P-chain), signableHex is already SHA-256(txBody) — a 32-byte
+        // pre-hashed digest.  Use it directly as the DKLS message hash instead of
+        // applying the coin's hash function (keccak256 for EVM coins).
+        // Same logic as getHashStringAndDerivationPath (external signer path).
+        const hashBuffer = this.getMpcv2HashBuffer(serializedTxHex, txOrMessageToSign, bufferContent);
+        const otherSigner = new sdk_lib_mpc_1.DklsDsg.Dsg(userKeyShare, params.mpcv2PartyId !== undefined ? params.mpcv2PartyId : 0, derivationPath, hashBuffer);
+        const userSignerBroadcastMsg1 = await otherSigner.init();
+        const signatureShareRound1 = await (0, ecdsaMPCv2_1.getSignatureShareRoundOne)(userSignerBroadcastMsg1, userGpgKey, params.mpcv2PartyId);
+        let latestTxRequest = await (0, common_1.sendSignatureShareV2)(this.bitgo, txRequest.walletId, txRequest.txRequestId, [signatureShareRound1], requestType, this.baseCoin.getMPCAlgorithm(), userGpgKey.publicKey, undefined, this.wallet.multisigTypeVersion(), params.reqId);
+        (0, assert_1.default)(latestTxRequest.transactions || latestTxRequest.messages, 'Invalid txRequest Object');
+        let bitgoToUserMessages1And2;
+        if (requestType === baseTypes_1.RequestType.tx) {
+            bitgoToUserMessages1And2 = latestTxRequest.transactions[0].signatureShares;
+        }
+        else {
+            bitgoToUserMessages1And2 = latestTxRequest.messages[0].signatureShares;
+        }
+        // TODO: Use codec for parsing
+        const parsedBitGoToUserSigShareRoundOne = JSON.parse(bitgoToUserMessages1And2[bitgoToUserMessages1And2.length - 1].share);
+        if (parsedBitGoToUserSigShareRoundOne.type !== 'round1Output') {
+            throw new Error('Unexpected signature share response. Unable to parse data.');
+        }
+        const serializedBitGoToUserMessagesRound1And2 = await (0, ecdsaMPCv2_1.verifyBitGoMessagesAndSignaturesRoundOne)(parsedBitGoToUserSigShareRoundOne, userGpgKey, bitgoGpgPubKey, params.mpcv2PartyId);
+        /** Round 2 **/
+        const deserializedMessages = sdk_lib_mpc_1.DklsTypes.deserializeMessages(serializedBitGoToUserMessagesRound1And2);
+        const userToBitGoMessagesRound2 = otherSigner.handleIncomingMessages({
+            p2pMessages: [],
+            broadcastMessages: deserializedMessages.broadcastMessages,
+        });
+        const userToBitGoMessagesRound3 = otherSigner.handleIncomingMessages({
+            p2pMessages: deserializedMessages.p2pMessages,
+            broadcastMessages: [],
+        });
+        const signatureShareRoundTwo = await (0, ecdsaMPCv2_1.getSignatureShareRoundTwo)(userToBitGoMessagesRound2, userToBitGoMessagesRound3, userGpgKey, bitgoGpgPubKey, params.mpcv2PartyId);
+        latestTxRequest = await (0, common_1.sendSignatureShareV2)(this.bitgo, txRequest.walletId, txRequest.txRequestId, [signatureShareRoundTwo], requestType, this.baseCoin.getMPCAlgorithm(), userGpgKey.publicKey, undefined, this.wallet.multisigTypeVersion(), params.reqId);
+        (0, assert_1.default)(latestTxRequest.transactions || latestTxRequest.messages, 'Invalid txRequest Object');
+        const txRequestSignatureShares = requestType === baseTypes_1.RequestType.tx
+            ? latestTxRequest.transactions[0].signatureShares
+            : latestTxRequest.messages[0].signatureShares;
+        // TODO: Use codec for parsing
+        const parsedBitGoToUserSigShareRoundTwo = JSON.parse(txRequestSignatureShares[txRequestSignatureShares.length - 1].share);
+        if (parsedBitGoToUserSigShareRoundTwo.type !== 'round2Output') {
+            throw new Error('Unexpected signature share response. Unable to parse data.');
+        }
+        const serializedBitGoToUserMessagesRound3 = await (0, ecdsaMPCv2_1.verifyBitGoMessagesAndSignaturesRoundTwo)(parsedBitGoToUserSigShareRoundTwo, userGpgKey, bitgoGpgPubKey, params.mpcv2PartyId);
+        /** Round 3 **/
+        const deserializedBitGoToUserMessagesRound3 = sdk_lib_mpc_1.DklsTypes.deserializeMessages({
+            p2pMessages: serializedBitGoToUserMessagesRound3.p2pMessages,
+            broadcastMessages: [],
+        });
+        const userToBitGoMessagesRound4 = otherSigner.handleIncomingMessages({
+            p2pMessages: deserializedBitGoToUserMessagesRound3.p2pMessages,
+            broadcastMessages: [],
+        });
+        const signatureShareRoundThree = await (0, ecdsaMPCv2_1.getSignatureShareRoundThree)(userToBitGoMessagesRound4, userGpgKey, bitgoGpgPubKey, params.mpcv2PartyId);
+        // Submit for final signature share combine
+        await (0, common_1.sendSignatureShareV2)(this.bitgo, txRequest.walletId, txRequest.txRequestId, [signatureShareRoundThree], requestType, this.baseCoin.getMPCAlgorithm(), userGpgKey.publicKey, undefined, this.wallet.multisigTypeVersion(), params.reqId);
+        return (0, common_1.sendTxRequest)(this.bitgo, txRequest.walletId, txRequest.txRequestId, requestType, params.reqId);
+    }
+    // #endregion
+    // #region formatting utils
+    formatBitgoBroadcastMessage(broadcastMessage) {
+        return {
+            from: broadcastMessage.from,
+            payload: { message: broadcastMessage.message, signature: broadcastMessage.signature },
+        };
+    }
+    formatP2PMessage(p2pMessage, commitment) {
+        return {
+            payload: { encryptedMessage: p2pMessage.encryptedMessage, signature: p2pMessage.signature },
+            from: p2pMessage.from,
+            to: p2pMessage.to,
+            commitment,
+        };
+    }
+    // #endregion
+    // #region private utils
+    /**
+     * Get the hash string and derivation path from the transaction request.
+     * @param {TxRequest} txRequest - the transaction request object
+     * @param {RequestType} requestType - the request type
+     * @returns {{ hashBuffer: Buffer; derivationPath: string }} - the hash string and derivation path
+     */
+    getHashStringAndDerivationPath(txRequest, requestType = baseTypes_1.RequestType.tx) {
+        let txToSign;
+        let derivationPath;
+        let serializedTxHex;
+        if (requestType === baseTypes_1.RequestType.tx) {
+            const signableTx = this.getSignableHexAndDerivationPath(txRequest, 'Unable to find transactions in txRequest');
+            txToSign = signableTx.signableHex;
+            derivationPath = signableTx.derivationPath;
+            serializedTxHex = signableTx.serializedTxHex;
+        }
+        else if (requestType === baseTypes_1.RequestType.message) {
+            // TODO(WP-2176): Add support for message signing
+            throw new Error('MPCv2 message signing not supported yet.');
+        }
+        else {
+            throw new Error('Invalid request type, got: ' + requestType);
+        }
+        const hashBuffer = this.getMpcv2HashBuffer(serializedTxHex, txToSign, buffer_1.Buffer.from(txToSign, 'hex'));
+        return { hashBuffer, derivationPath };
+    }
+    /**
+     * Build the DKLS message hash for MPCv2 signing.
+     * For pre-hashed signable material (Avalanche atomic txs), signableHex is
+     * already SHA-256(txBody) and is used directly. Otherwise the coin hash
+     * function is applied (keccak256 for EVM coins by default).
+     */
+    getMpcv2HashBuffer(serializedTxHex, signableHex, bufferContent) {
+        const unsignedTx = {
+            serializedTxHex: serializedTxHex ?? '',
+            signableHex,
+        };
+        if (serializedTxHex && (0, preHashedSignable_1.shouldUsePreHashedSignable)(this.baseCoin, unsignedTx)) {
+            (0, assert_1.default)(bufferContent.length === 32, `Avalanche pre-hashed signableHex must be 32 bytes, got ${bufferContent.length}`);
+            return bufferContent;
+        }
+        let hash;
+        try {
+            hash = this.baseCoin.getHashFunction();
+        }
+        catch (err) {
+            hash = (0, keccak_1.default)('keccak256');
+        }
+        return hash.update(bufferContent).digest();
+    }
+    // #endregion
+    // #region external signer
+    /** @inheritdoc */
+    async signEcdsaMPCv2TssUsingExternalSigner(params, externalSignerMPCv2SigningRound1Generator, externalSignerMPCv2SigningRound2Generator, externalSignerMPCv2SigningRound3Generator, requestType = baseTypes_1.RequestType.tx) {
+        const { txRequest, reqId } = params;
+        let txRequestResolved;
+        // TODO(WP-2176): Add support for message signing
+        (0, assert_1.default)(requestType === baseTypes_1.RequestType.tx, 'Only transaction signing is supported for external signer, got: ' + requestType);
+        if (typeof txRequest === 'string') {
+            txRequestResolved = await (0, tss_1.getTxRequest)(this.bitgo, this.wallet.id(), txRequest, reqId);
+        }
+        else {
+            txRequestResolved = txRequest;
+        }
+        const bitgoPublicGpgKey = await this.pickBitgoPubGpgKeyForSigning(true, params.reqId, txRequestResolved.enterpriseId);
+        if (!bitgoPublicGpgKey) {
+            throw new Error('Missing BitGo GPG key for MPCv2');
+        }
+        // round 1
+        const { signatureShareRound1, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey } = await externalSignerMPCv2SigningRound1Generator({ txRequest: txRequestResolved });
+        const round1TxRequest = await (0, common_1.sendSignatureShareV2)(this.bitgo, txRequestResolved.walletId, txRequestResolved.txRequestId, [signatureShareRound1], requestType, this.baseCoin.getMPCAlgorithm(), userGpgPubKey, undefined, this.wallet.multisigTypeVersion(), reqId);
+        // round 2
+        const { signatureShareRound2, encryptedRound2Session } = await externalSignerMPCv2SigningRound2Generator({
+            txRequest: round1TxRequest,
+            encryptedRound1Session,
+            encryptedUserGpgPrvKey,
+            bitgoPublicGpgKey: bitgoPublicGpgKey.armor(),
+        });
+        const round2TxRequest = await (0, common_1.sendSignatureShareV2)(this.bitgo, txRequestResolved.walletId, txRequestResolved.txRequestId, [signatureShareRound2], requestType, this.baseCoin.getMPCAlgorithm(), userGpgPubKey, undefined, this.wallet.multisigTypeVersion(), reqId);
+        (0, assert_1.default)(round2TxRequest.transactions && round2TxRequest.transactions[0].signatureShares, 'Missing signature shares in round 2 txRequest');
+        // round 3
+        const { signatureShareRound3 } = await externalSignerMPCv2SigningRound3Generator({
+            txRequest: round2TxRequest,
+            encryptedRound2Session,
+            encryptedUserGpgPrvKey,
+            bitgoPublicGpgKey: bitgoPublicGpgKey.armor(),
+        });
+        await (0, common_1.sendSignatureShareV2)(this.bitgo, txRequestResolved.walletId, txRequestResolved.txRequestId, [signatureShareRound3], requestType, this.baseCoin.getMPCAlgorithm(), userGpgPubKey, undefined, this.wallet.multisigTypeVersion(), reqId);
+        return (0, common_1.sendTxRequest)(this.bitgo, txRequestResolved.walletId, txRequestResolved.txRequestId, requestType, reqId);
+    }
+    async createOfflineRound1Share(params) {
+        const { prv, walletPassphrase, txRequest, encryptedPrv } = params;
+        const { hashBuffer, derivationPath } = this.getHashStringAndDerivationPath(txRequest);
+        const adata = `${hashBuffer.toString('hex')}:${derivationPath}`;
+        const userKeyShare = buffer_1.Buffer.from(prv, 'base64');
+        const userGpgKey = await (0, opengpgUtils_1.generateGPGKeyPair)('secp256k1');
+        const userSigner = new sdk_lib_mpc_1.DklsDsg.Dsg(userKeyShare, 0, derivationPath, hashBuffer);
+        const userSignerBroadcastMsg1 = await userSigner.init();
+        const signatureShareRound1 = await (0, ecdsaMPCv2_1.getSignatureShareRoundOne)(userSignerBroadcastMsg1, userGpgKey);
+        const sessionData = userSigner.getSession();
+        const userGpgPubKey = userGpgKey.publicKey;
+        const useV2 = encryptedPrv !== undefined && (0, baseTypes_1.isV2Envelope)(encryptedPrv);
+        if (useV2) {
+            const session = await this.bitgo.createEncryptionSession(walletPassphrase);
+            try {
+                const encryptedRound1Session = await session.encrypt(sessionData, `${EcdsaMPCv2Utils.DKLS23_SIGNING_ROUND1_STATE}:${adata}`);
+                const encryptedUserGpgPrvKey = await session.encrypt(userGpgKey.privateKey, `${EcdsaMPCv2Utils.DKLS23_SIGNING_USER_GPG_KEY}:${adata}`);
+                return { signatureShareRound1, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey };
+            }
+            finally {
+                session.destroy();
+            }
+        }
+        const encryptedRound1Session = await this.bitgo.encrypt({
+            input: sessionData,
+            password: walletPassphrase,
+            adata: `${EcdsaMPCv2Utils.DKLS23_SIGNING_ROUND1_STATE}:${adata}`,
+            encryptionVersion: 1,
+        });
+        const encryptedUserGpgPrvKey = await this.bitgo.encrypt({
+            input: userGpgKey.privateKey,
+            password: walletPassphrase,
+            adata: `${EcdsaMPCv2Utils.DKLS23_SIGNING_USER_GPG_KEY}:${adata}`,
+            encryptionVersion: 1,
+        });
+        return { signatureShareRound1, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey };
+    }
+    async createOfflineRound2Share(params) {
+        const { prv, walletPassphrase, encryptedUserGpgPrvKey, encryptedRound1Session, bitgoPublicGpgKey, txRequest } = params;
+        const { hashBuffer, derivationPath } = this.getHashStringAndDerivationPath(txRequest);
+        const adata = `${hashBuffer.toString('hex')}:${derivationPath}`;
+        const useV2 = (0, baseTypes_1.isV2Envelope)(encryptedRound1Session);
+        const { bitgoGpgKey, userGpgPrvKey } = await this.getBitgoAndUserGpgKeys(bitgoPublicGpgKey, encryptedUserGpgPrvKey, walletPassphrase, adata, EcdsaMPCv2Utils.DKLS23_SIGNING_USER_GPG_KEY);
+        const userGpgKey = {
+            privateKey: userGpgPrvKey.armor(),
+            publicKey: userGpgPrvKey.toPublic().armor(),
+        };
+        const signatureShares = txRequest.transactions?.[0].signatureShares;
+        (0, assert_1.default)(signatureShares, 'Missing signature shares in round 1 txRequest');
+        const parsedBitGoToUserSigShareRoundOne = JSON.parse(signatureShares[signatureShares.length - 1].share);
+        if (parsedBitGoToUserSigShareRoundOne.type !== 'round1Output') {
+            throw new Error('Unexpected signature share response. Unable to parse data.');
+        }
+        const serializedBitGoToUserMessagesRound1 = await (0, ecdsaMPCv2_1.verifyBitGoMessagesAndSignaturesRoundOne)(parsedBitGoToUserSigShareRoundOne, userGpgKey, bitgoGpgKey);
+        const round1Session = await this.bitgo.decrypt({ input: encryptedRound1Session, password: walletPassphrase });
+        this.validateAdata(adata, encryptedRound1Session, EcdsaMPCv2Utils.DKLS23_SIGNING_ROUND1_STATE);
+        const userKeyShare = buffer_1.Buffer.from(prv, 'base64');
+        const userSigner = new sdk_lib_mpc_1.DklsDsg.Dsg(userKeyShare, 0, derivationPath, hashBuffer);
+        await userSigner.setSession(round1Session);
+        const deserializedMessages = sdk_lib_mpc_1.DklsTypes.deserializeMessages(serializedBitGoToUserMessagesRound1);
+        const userToBitGoMessagesRound2 = userSigner.handleIncomingMessages({
+            p2pMessages: [],
+            broadcastMessages: deserializedMessages.broadcastMessages,
+        });
+        const userToBitGoMessagesRound3 = userSigner.handleIncomingMessages({
+            p2pMessages: deserializedMessages.p2pMessages,
+            broadcastMessages: [],
+        });
+        const signatureShareRound2 = await (0, ecdsaMPCv2_1.getSignatureShareRoundTwo)(userToBitGoMessagesRound2, userToBitGoMessagesRound3, userGpgKey, bitgoGpgKey);
+        const sessionData = userSigner.getSession();
+        if (useV2) {
+            const encSession = await this.bitgo.createEncryptionSession(walletPassphrase);
+            try {
+                const encryptedRound2Session = await encSession.encrypt(sessionData, `${EcdsaMPCv2Utils.DKLS23_SIGNING_ROUND2_STATE}:${adata}`);
+                return { signatureShareRound2, encryptedRound2Session };
+            }
+            finally {
+                encSession.destroy();
+            }
+        }
+        const encryptedRound2Session = await this.bitgo.encrypt({
+            input: sessionData,
+            password: walletPassphrase,
+            adata: `${EcdsaMPCv2Utils.DKLS23_SIGNING_ROUND2_STATE}:${adata}`,
+            encryptionVersion: 1,
+        });
+        return {
+            signatureShareRound2,
+            encryptedRound2Session,
+        };
+    }
+    async createOfflineRound3Share(params) {
+        const { prv, walletPassphrase, encryptedUserGpgPrvKey, encryptedRound2Session, bitgoPublicGpgKey, txRequest } = params;
+        (0, assert_1.default)(txRequest.transactions && txRequest.transactions.length === 1, 'Unable to find transactions in txRequest');
+        const { hashBuffer, derivationPath } = this.getHashStringAndDerivationPath(txRequest);
+        const adata = `${hashBuffer.toString('hex')}:${derivationPath}`;
+        const { bitgoGpgKey, userGpgPrvKey } = await this.getBitgoAndUserGpgKeys(bitgoPublicGpgKey, encryptedUserGpgPrvKey, walletPassphrase, adata, EcdsaMPCv2Utils.DKLS23_SIGNING_USER_GPG_KEY);
+        const userGpgKey = {
+            privateKey: userGpgPrvKey.armor(),
+            publicKey: userGpgPrvKey.toPublic().armor(),
+        };
+        const signatureShares = txRequest.transactions?.[0].signatureShares;
+        (0, assert_1.default)(signatureShares, 'Missing signature shares in round 2 txRequest');
+        const parsedBitGoToUserSigShareRoundTwo = JSON.parse(signatureShares[signatureShares.length - 1].share);
+        if (parsedBitGoToUserSigShareRoundTwo.type !== 'round2Output') {
+            throw new Error('Unexpected signature share response. Unable to parse data.');
+        }
+        const serializedBitGoToUserMessagesRound3 = await (0, ecdsaMPCv2_1.verifyBitGoMessagesAndSignaturesRoundTwo)(parsedBitGoToUserSigShareRoundTwo, userGpgKey, bitgoGpgKey);
+        const deserializedBitGoToUserMessagesRound3 = sdk_lib_mpc_1.DklsTypes.deserializeMessages({
+            p2pMessages: serializedBitGoToUserMessagesRound3.p2pMessages,
+            broadcastMessages: [],
+        });
+        const round2Session = await this.bitgo.decrypt({ input: encryptedRound2Session, password: walletPassphrase });
+        this.validateAdata(adata, encryptedRound2Session, EcdsaMPCv2Utils.DKLS23_SIGNING_ROUND2_STATE);
+        const userKeyShare = buffer_1.Buffer.from(prv, 'base64');
+        const userSigner = new sdk_lib_mpc_1.DklsDsg.Dsg(userKeyShare, 0, derivationPath, hashBuffer);
+        await userSigner.setSession(round2Session);
+        const userToBitGoMessagesRound4 = userSigner.handleIncomingMessages({
+            p2pMessages: deserializedBitGoToUserMessagesRound3.p2pMessages,
+            broadcastMessages: [],
+        });
+        const signatureShareRound3 = await (0, ecdsaMPCv2_1.getSignatureShareRoundThree)(userToBitGoMessagesRound4, userGpgKey, bitgoGpgKey);
+        return { signatureShareRound3 };
+    }
+}
+exports.EcdsaMPCv2Utils = EcdsaMPCv2Utils;
+EcdsaMPCv2Utils.DKLS23_SIGNING_USER_GPG_KEY = 'DKLS23_SIGNING_USER_GPG_KEY';
+EcdsaMPCv2Utils.DKLS23_SIGNING_ROUND1_STATE = 'DKLS23_SIGNING_ROUND1_STATE';
+EcdsaMPCv2Utils.DKLS23_SIGNING_ROUND2_STATE = 'DKLS23_SIGNING_ROUND2_STATE';
+/**
+ * Checks if the given key share, when decrypted, contains valid GG18 signing material.
+ *
+ * @param {string} keyShare - The encrypted key share string.
+ * @param {string|undefined} walletPassphrase - The passphrase used to decrypt the key share
+ * @param {BitGoBase} bitgo - BitGo instance for v1/v2 auto-detect decrypt
+ * @returns {Promise<boolean>} - Resolves `true` if the decrypted data contains valid signing material, otherwise `false`.
+ */
+async function isGG18SigningMaterial(keyShare, walletPassphrase, bitgo) {
+    try {
+        const prv = await bitgo.decrypt({ password: walletPassphrase, input: keyShare });
+        const signingMaterial = JSON.parse(prv);
+        return (signingMaterial.pShare &&
+            signingMaterial.bitgoNShare &&
+            (signingMaterial.userNShare || signingMaterial.backupNShare));
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Get the MPC v2 recovery key shares from the provided user and backup key shares.
+ * @param encryptedUserKey encrypted gg18 or MPCv2 user key
+ * @param encryptedBackupKey encrypted gg18 or MPCv2 backup key
+ * @param walletPassphrase password for user and backup key
+ * @param bitgo BitGo instance for v1/v2 auto-detect decrypt
+ * @returns MPC v2 recovery key shares
+ */
+async function getMpcV2RecoveryKeyShares(encryptedUserKey, encryptedBackupKey, walletPassphrase, bitgo) {
+    if (await isGG18SigningMaterial(encryptedUserKey, walletPassphrase, bitgo)) {
+        return getMpcV2RecoveryKeySharesFromGG18(encryptedUserKey, encryptedBackupKey, walletPassphrase, bitgo);
+    }
+    return getMpcV2RecoveryKeySharesFromReducedKey(encryptedUserKey, encryptedBackupKey, walletPassphrase, bitgo);
+}
+/**
+ * Signs a message hash using MPC v2 recovery key shares.
+ *
+ * @param {Buffer} messageHash
+ * @param {Buffer} userKeyShare
+ * @param {Buffer} backupKeyShare
+ * @param {string} commonKeyChain
+ * @returns {Promise<{ recid: number, r: string, s: string, y: string }>}
+ *
+ * @async
+ */
+async function signRecoveryMpcV2(messageHash, userKeyShare, backupKeyShare, commonKeyChain) {
+    const userDsg = new sdk_lib_mpc_1.DklsDsg.Dsg(userKeyShare, 0, 'm/0', messageHash);
+    const backupDsg = new sdk_lib_mpc_1.DklsDsg.Dsg(backupKeyShare, 1, 'm/0', messageHash);
+    const signatureString = sdk_lib_mpc_1.DklsUtils.verifyAndConvertDklsSignature(messageHash, (await sdk_lib_mpc_1.DklsUtils.executeTillRound(5, userDsg, backupDsg)), commonKeyChain, 'm/0', undefined, false);
+    const sigParts = signatureString.split(':');
+    return {
+        recid: parseInt(sigParts[0], 10),
+        r: sigParts[1],
+        s: sigParts[2],
+        y: sigParts[3],
+    };
+}
+// #region private utils
+/**
+ * Get the MPC v2 recovery key shares from the provided user and backup key shares.
+ * @param encryptedGG18UserKey encrypted gg18 user key
+ * @param encryptedGG18BackupKey encrypted gg18 backup key
+ * @param walletPassphrase password for user and backup key
+ * @returns MPC v2 recovery key shares
+ */
+async function getMpcV2RecoveryKeySharesFromGG18(encryptedGG18UserKey, encryptedGG18BackupKey, walletPassphrase, bitgo) {
+    const [userKeyCombined, backupKeyCombined] = await getKeyCombinedFromTssKeyShares(encryptedGG18UserKey, encryptedGG18BackupKey, walletPassphrase, bitgo);
+    const retrofitDataA = {
+        xShare: userKeyCombined.xShare,
+    };
+    const retrofitDataB = {
+        xShare: backupKeyCombined.xShare,
+    };
+    const [user, backup] = await sdk_lib_mpc_1.DklsUtils.generate2of2KeyShares(retrofitDataA, retrofitDataB);
+    const userKeyShare = user.getKeyShare();
+    const backupKeyShare = backup.getKeyShare();
+    return {
+        userKeyShare,
+        backupKeyShare,
+        commonKeyChain: sdk_lib_mpc_1.DklsTypes.getCommonKeychain(backupKeyShare),
+    };
+}
+/**
+ * Retrieves the MPC v2 recovery key shares from the provided user and backup key shares.
+ *
+ * @param {string} encryptedMPCv2UserKey
+ * @param {string} encryptedMPCv2BackupKey
+ * @param {string} [walletPassphrase] - The passphrase used to decrypt the key shares
+ * @returns {Promise<{ userKeyShare: KeyShare, backupKeyShare: KeyShare, commonKeyChain: string }>}
+ *
+ * @async
+ */
+async function getMpcV2RecoveryKeySharesFromReducedKey(encryptedMPCv2UserKey, encryptedMPCv2BackupKey, walletPassphrase, bitgo) {
+    const userCompressedPrv = buffer_1.Buffer.from(await bitgo.decrypt({ password: walletPassphrase, input: encryptedMPCv2UserKey }), 'base64');
+    const bakcupCompressedPrv = buffer_1.Buffer.from(await bitgo.decrypt({ password: walletPassphrase, input: encryptedMPCv2BackupKey }), 'base64');
+    const userPrvJSON = sdk_lib_mpc_1.DklsTypes.getDecodedReducedKeyShare(userCompressedPrv);
+    const backupPrvJSON = sdk_lib_mpc_1.DklsTypes.getDecodedReducedKeyShare(bakcupCompressedPrv);
+    const userKeyRetrofit = {
+        xShare: {
+            x: buffer_1.Buffer.from(userPrvJSON.prv).toString('hex'),
+            y: buffer_1.Buffer.from(userPrvJSON.pub).toString('hex'),
+            chaincode: buffer_1.Buffer.from(userPrvJSON.rootChainCode).toString('hex'),
+        },
+        xiList: userPrvJSON.xList.slice(0, 2),
+    };
+    const backupKeyRetrofit = {
+        xShare: {
+            x: buffer_1.Buffer.from(backupPrvJSON.prv).toString('hex'),
+            y: buffer_1.Buffer.from(backupPrvJSON.pub).toString('hex'),
+            chaincode: buffer_1.Buffer.from(backupPrvJSON.rootChainCode).toString('hex'),
+        },
+        xiList: backupPrvJSON.xList.slice(0, 2),
+    };
+    const [user, backup] = await sdk_lib_mpc_1.DklsUtils.generate2of2KeyShares(userKeyRetrofit, backupKeyRetrofit);
+    const userKeyShare = user.getKeyShare();
+    const backupKeyShare = backup.getKeyShare();
+    const commonKeyChain = sdk_lib_mpc_1.DklsTypes.getCommonKeychain(userKeyShare);
+    return { userKeyShare, backupKeyShare, commonKeyChain };
+}
+/**
+ * Gets the combined key for GG18
+ * @param encryptedGG18UserKey encrypted GG18 user key
+ * @param encryptedGG18BackupKey encrypted GG18 backup key
+ * @param walletPassphrase wallet passphrase
+ * @returns key shares
+ */
+async function getKeyCombinedFromTssKeyShares(encryptedGG18UserKey, encryptedGG18BackupKey, walletPassphrase, bitgo) {
+    let backupPrv;
+    let userPrv;
+    try {
+        backupPrv = await bitgo.decrypt({ password: walletPassphrase, input: encryptedGG18BackupKey });
+        userPrv = await bitgo.decrypt({ password: walletPassphrase, input: encryptedGG18UserKey });
+    }
+    catch (e) {
+        throw new Error(`Error decrypting backup keychain: ${e.message}`);
+    }
+    const userSigningMaterial = JSON.parse(userPrv);
+    const backupSigningMaterial = JSON.parse(backupPrv);
+    if (!userSigningMaterial.backupNShare) {
+        throw new Error('Invalid user key - missing backupNShare');
+    }
+    if (!backupSigningMaterial.userNShare) {
+        throw new Error('Invalid backup key - missing userNShare');
+    }
+    const MPC = new account_lib_1.Ecdsa();
+    const userKeyCombined = MPC.keyCombine(userSigningMaterial.pShare, [
+        userSigningMaterial.bitgoNShare,
+        userSigningMaterial.backupNShare,
+    ]);
+    const backupKeyCombined = MPC.keyCombine(backupSigningMaterial.pShare, [
+        backupSigningMaterial.userNShare,
+        backupSigningMaterial.bitgoNShare,
+    ]);
+    if (userKeyCombined.xShare.y !== backupKeyCombined.xShare.y ||
+        userKeyCombined.xShare.chaincode !== backupKeyCombined.xShare.chaincode) {
+        throw new Error('Common keychains do not match');
+    }
+    return [userKeyCombined, backupKeyCombined];
+}
+// #endregion
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecdsaMPCv2.js","sourceRoot":"","sources":["../../../../../../src/bitgo/utils/tss/ecdsa/ecdsaMPCv2.ts"],"names":[],"mappings":";;;;;;AAi/CA,sDAgBC;AAUD,8DAcC;AAaD,8CA8BC;AAnkDD,yDAA8G;AAC9G,oDAA4B;AAC5B,mCAAgC;AAEhC,6CAA6C;AAC7C,oDAAsC;AAGtC,sDAU6B;AAE7B,yDAAgD;AAGhD,sCAA8D;AAC9D,gDAA0E;AAC1E,6CAAgD;AAChD,8DAMuC;AAEvC,qDAAwD;AACxD,4CAesB;AACtB,4DAAkE;AAClE,oEAA2E;AAC3E,iCAAwC;AACxC,qEAA6F;AAC7F,4DAA8F;AAC9F,4CAA0D;AAE1D,sDAA6D;AAG7D,MAAa,eAAgB,SAAQ,qBAAc;IAKjD,kBAAkB;IAClB,KAAK,CAAC,eAAe,CAAC,MASrB;QACC,MAAM,EAAE,WAAW,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC,uBAAuB,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC3F,MAAM,UAAU,GAAG,MAAM,IAAA,iCAAkB,EAAC,WAAW,CAAC,CAAC;QACzD,MAAM,YAAY,GAAG,MAAM,IAAA,iCAAkB,EAAC,WAAW,CAAC,CAAC;QAE3D,kEAAkE;QAClE,oEAAoE;QACpE,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,IAAI,CAAC,oCAAoC,CAAC,MAAM,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;QACpG,MAAM,QAAQ,GAAG,cAAc,IAAI,IAAI,CAAC,sBAAsB,CAAC;QAC/D,IAAA,gBAAM,EAAC,QAAQ,EAAE,0CAA0C,CAAC,CAAC;QAC7D,MAAM,iBAAiB,GAAG,QAAQ,CAAC,KAAK,EAAE,CAAC;QAE3C,IAAI,IAAA,8CAA+B,EAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC;YACzD,uFAAuF;YACvF,IAAA,gBAAM,EAAC,IAAA,+BAAgB,EAAC,iBAAiB,EAAE,OAAO,CAAC,EAAE,8BAA8B,CAAC,CAAC;QACvF,CAAC;QAED,MAAM,aAAa,GAA0B;YAC3C,OAAO,EAAE,6BAAgB,CAAC,IAAI;YAC9B,MAAM,EAAE,UAAU,CAAC,UAAU;SAC9B,CAAC;QACF,MAAM,eAAe,GAA0B;YAC7C,OAAO,EAAE,6BAAgB,CAAC,MAAM;YAChC,MAAM,EAAE,YAAY,CAAC,UAAU;SAChC,CAAC;QACF,MAAM,cAAc,GAA0B;YAC5C,OAAO,EAAE,6BAAgB,CAAC,KAAK;YAC/B,MAAM,EAAE,iBAAiB;SAC1B,CAAC;QAEF,kBAAkB;QAClB,MAAM,sBAAsB,GAAG,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;QAC3D,MAAM,wBAAwB,GAAG,MAAM,aAAa,CAAC,OAAO,EAAE,CAAC;QAE/D,MAAM,wBAAwB,GAAG,uBAAS,CAAC,iBAAiB,CAAC;YAC3D,iBAAiB,EAAE,CAAC,sBAAsB,EAAE,wBAAwB,CAAC;YACrE,WAAW,EAAE,EAAE;SAChB,CAAC,CAAC;QACH,MAAM,cAAc,GAAG,MAAM,uBAAS,CAAC,8BAA8B,CACnE,wBAAwB,EACxB,CAAC,cAAc,CAAC,EAChB,CAAC,aAAa,EAAE,eAAe,CAAC,CACjC,CAAC;QAEF,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,iBAAiB,EAAE,eAAe,EAAE,GAAG,MAAM,IAAI,CAAC,uBAAuB,CACrG,MAAM,CAAC,UAAU,EACjB,UAAU,CAAC,SAAS,EACpB,YAAY,CAAC,SAAS,EACtB,MAAM,CAAC,QAAQ,EAAE,QAAQ;YACvB,CAAC,CAAC;gBACE,GAAG,cAAc;gBACjB,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,QAAQ;aACnC;YACH,CAAC,CAAC,cAAc,EAClB,MAAM,CAAC,MAAM,CACd,CAAC;QACF,aAAa;QAEb,kBAAkB;QAClB,MAAM,4BAA4B,GAAG,MAAM,uBAAS,CAAC,gCAAgC,CACnF,EAAE,WAAW,EAAE,EAAE,EAAE,iBAAiB,EAAE,CAAC,IAAI,CAAC,2BAA2B,CAAC,SAAS,CAAC,CAAC,EAAE,EACrF,CAAC,cAAc,CAAC,EAChB,CAAC,aAAa,EAAE,eAAe,CAAC,CACjC,CAAC;QACF,MAAM,uBAAuB,GAAG,4BAA4B,CAAC,iBAAiB,CAAC,IAAI,CACjF,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,KAAK,CACzC,CAAC;QACF,IAAA,gBAAM,EAAC,uBAAuB,EAAE,iDAAiD,CAAC,CAAC;QAEnF,MAAM,qBAAqB,GAAG,WAAW,CAAC,sBAAsB,CAAC;YAC/D,WAAW,EAAE,EAAE;YACf,iBAAiB,EAAE,CAAC,uBAAS,CAAC,2BAA2B,CAAC,uBAAuB,CAAC,EAAE,wBAAwB,CAAC;SAC9G,CAAC,CAAC;QAEH,MAAM,eAAe,GAAG,qBAAqB,CAAC,WAAW,CAAC,IAAI,CAC5D,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,KAAK,CAC3E,CAAC;QACF,IAAA,gBAAM,EAAC,eAAe,EAAE,0CAA0C,CAAC,CAAC;QACpE,MAAM,yBAAyB,GAAG,uBAAS,CAAC,mBAAmB,CAAC,eAAe,CAAC,CAAC;QAEjF,MAAM,uBAAuB,GAAG,aAAa,CAAC,sBAAsB,CAAC;YACnE,WAAW,EAAE,EAAE;YACf,iBAAiB,EAAE,CAAC,sBAAsB,EAAE,uBAAS,CAAC,2BAA2B,CAAC,uBAAuB,CAAC,CAAC;SAC5G,CAAC,CAAC;QACH,MAAM,2BAA2B,GAAG,uBAAS,CAAC,iBAAiB,CAAC,uBAAuB,CAAC,CAAC,WAAW,CAAC,IAAI,CACvG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,MAAM,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,KAAK,CAC7E,CAAC;QACF,IAAA,gBAAM,EAAC,2BAA2B,EAAE,4CAA4C,CAAC,CAAC;QAElF,MAAM,cAAc,GAAG,MAAM,uBAAS,CAAC,8BAA8B,CACnE,EAAE,WAAW,EAAE,CAAC,yBAAyB,EAAE,2BAA2B,CAAC,EAAE,iBAAiB,EAAE,EAAE,EAAE,EAChG,CAAC,cAAc,CAAC,EAChB,CAAC,aAAa,EAAE,eAAe,CAAC,CACjC,CAAC;QAEF,MAAM,EACJ,SAAS,EAAE,eAAe,EAC1B,gBAAgB,EAChB,eAAe,EACf,iBAAiB,GAClB,GAAG,MAAM,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,UAAU,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QACrF,aAAa;QAEb,kBAAkB;QAClB,gBAAM,CAAC,KAAK,CAAC,SAAS,EAAE,eAAe,EAAE,wCAAwC,CAAC,CAAC;QACnF,MAAM,8BAA8B,GAAG,MAAM,uBAAS,CAAC,gCAAgC,CACrF,EAAE,WAAW,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,CAAC,EAAE,iBAAiB,EAAE,EAAE,EAAE,EAChF,CAAC,cAAc,CAAC,EAChB,CAAC,aAAa,CAAC,CAChB,CAAC;QACF,MAAM,8BAA8B,GAAG,8BAA8B,CAAC,WAAW,CAAC,IAAI,CACpF,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,IAAI,CAC3E,CAAC;QACF,IAAA,gBAAM,EAAC,8BAA8B,EAAE,mDAAmD,CAAC,CAAC;QAC5F,MAAM,oBAAoB,GAAG,uBAAS,CAAC,qBAAqB,CAAC,8BAA8B,CAAC,CAAC;QAE7F,MAAM,+BAA+B,GAAG,MAAM,uBAAS,CAAC,gCAAgC,CACtF,EAAE,WAAW,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,CAAC,EAAE,iBAAiB,EAAE,EAAE,EAAE,EAClF,CAAC,cAAc,CAAC,EAChB,CAAC,eAAe,CAAC,CAClB,CAAC;QACF,MAAM,gCAAgC,GAAG,+BAA+B,CAAC,WAAW,CAAC,IAAI,CACvF,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,MAAM,CAC7E,CAAC;QACF,IAAA,gBAAM,EAAC,gCAAgC,EAAE,qDAAqD,CAAC,CAAC;QAChG,MAAM,sBAAsB,GAAG,uBAAS,CAAC,qBAAqB,CAAC,gCAAgC,CAAC,CAAC;QAEjG,MAAM,gBAAgB,GAAG,qBAAqB,CAAC,WAAW,CAAC,IAAI,CAC7D,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,MAAM,CAC5E,CAAC;QACF,IAAA,gBAAM,EAAC,gBAAgB,EAAE,oDAAoD,CAAC,CAAC;QAE/E,MAAM,gBAAgB,GAAG,uBAAuB,CAAC,WAAW,CAAC,IAAI,CAC/D,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,MAAM,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,IAAI,CAC5E,CAAC;QACF,IAAA,gBAAM,EAAC,gBAAgB,EAAE,oDAAoD,CAAC,CAAC;QAE/E,MAAM,kBAAkB,GAAG,WAAW,CAAC,sBAAsB,CAAC;YAC5D,iBAAiB,EAAE,EAAE;YACrB,WAAW,EAAE,CAAC,oBAAoB,EAAE,gBAAgB,CAAC;SACtD,CAAC,CAAC;QACH,MAAM,gBAAgB,GAAG,kBAAkB,CAAC,WAAW,CAAC,IAAI,CAC1D,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,MAAM,CAC5E,CAAC;QACF,IAAA,gBAAM,EAAC,gBAAgB,EAAE,oDAAoD,CAAC,CAAC;QAC/E,MAAM,eAAe,GAAG,kBAAkB,CAAC,WAAW,CAAC,IAAI,CACzD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,KAAK,CAC3E,CAAC;QACF,IAAA,gBAAM,EAAC,eAAe,EAAE,mDAAmD,CAAC,CAAC;QAC7E,MAAM,yBAAyB,GAAG,uBAAS,CAAC,mBAAmB,CAAC,eAAe,CAAC,CAAC;QAEjF,MAAM,oBAAoB,GAAG,aAAa,CAAC,sBAAsB,CAAC;YAChE,iBAAiB,EAAE,EAAE;YACrB,WAAW,EAAE,CAAC,sBAAsB,EAAE,gBAAgB,CAAC;SACxD,CAAC,CAAC;QAEH,MAAM,gBAAgB,GAAG,oBAAoB,CAAC,WAAW,CAAC,IAAI,CAC5D,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,MAAM,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,IAAI,CAC5E,CAAC;QACF,IAAA,gBAAM,EAAC,gBAAgB,EAAE,oDAAoD,CAAC,CAAC;QAC/E,MAAM,iBAAiB,GAAG,oBAAoB,CAAC,WAAW,CAAC,IAAI,CAC7D,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,MAAM,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,KAAK,CAC7E,CAAC;QACF,IAAA,gBAAM,EAAC,iBAAiB,EAAE,qDAAqD,CAAC,CAAC;QACjF,MAAM,2BAA2B,GAAG,uBAAS,CAAC,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;QAErF,MAAM,kCAAkC,GAAG,MAAM,uBAAS,CAAC,gCAAgC,CACzF,EAAE,iBAAiB,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,eAAe,EAAE,gBAAgB,CAAC,CAAC,EAAE,EAClG,CAAC,cAAc,CAAC,EAChB,CAAC,aAAa,CAAC,CAChB,CAAC;QACF,MAAM,8BAA8B,GAAG,kCAAkC,CAAC,WAAW,CAAC,IAAI,CACxF,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,IAAI,CAC3E,CAAC;QACF,IAAA,gBAAM,EAAC,8BAA8B,EAAE,mDAAmD,CAAC,CAAC;QAC5F,MAAM,oBAAoB,GAAG,uBAAS,CAAC,qBAAqB,CAAC,8BAA8B,CAAC,CAAC;QAE7F,MAAM,oCAAoC,GAAG,MAAM,uBAAS,CAAC,gCAAgC,CAC3F,EAAE,iBAAiB,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,EAAE,gBAAgB,CAAC,CAAC,EAAE,EACpG,CAAC,cAAc,CAAC,EAChB,CAAC,eAAe,CAAC,CAClB,CAAC;QACF,MAAM,gCAAgC,GAAG,oCAAoC,CAAC,WAAW,CAAC,IAAI,CAC5F,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,MAAM,CAC7E,CAAC;QACF,IAAA,gBAAM,EAAC,gCAAgC,EAAE,qDAAqD,CAAC,CAAC;QAChG,MAAM,sBAAsB,GAAG,uBAAS,CAAC,qBAAqB,CAAC,gCAAgC,CAAC,CAAC;QAEjG,MAAM,kBAAkB,GAAG,WAAW,CAAC,sBAAsB,CAAC;YAC5D,WAAW,EAAE,CAAC,gBAAgB,EAAE,oBAAoB,CAAC;YACrD,iBAAiB,EAAE,EAAE;SACtB,CAAC,CAAC;QAEH,MAAM,sBAAsB,GAAG,kBAAkB,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,IAAI,CAAC,CAAC;QAClH,IAAA,gBAAM,EAAC,sBAAsB,EAAE,gDAAgD,CAAC,CAAC;QACjF,MAAM,gCAAgC,GAAG,uBAAS,CAAC,yBAAyB,CAAC,sBAAsB,CAAC,CAAC;QAErG,MAAM,oBAAoB,GAAG,aAAa,CAAC,sBAAsB,CAAC;YAChE,WAAW,EAAE,CAAC,gBAAgB,EAAE,sBAAsB,CAAC;YACvD,iBAAiB,EAAE,EAAE;SACtB,CAAC,CAAC;QACH,MAAM,wBAAwB,GAAG,oBAAoB,CAAC,iBAAiB,CAAC,IAAI,CAC1E,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,MAAM,CAC1C,CAAC;QACF,IAAA,gBAAM,EAAC,wBAAwB,EAAE,kDAAkD,CAAC,CAAC;QACrF,MAAM,kCAAkC,GAAG,uBAAS,CAAC,yBAAyB,CAAC,wBAAwB,CAAC,CAAC;QAEzG,MAAM,cAAc,GAAG,MAAM,uBAAS,CAAC,8BAA8B,CACnE;YACE,WAAW,EAAE,CAAC,yBAAyB,EAAE,2BAA2B,CAAC;YACrE,iBAAiB,EAAE,CAAC,gCAAgC,EAAE,kCAAkC,CAAC;SAC1F,EACD,CAAC,cAAc,CAAC,EAChB,CAAC,aAAa,EAAE,eAAe,CAAC,CACjC,CAAC;QAEF,MAAM,EACJ,SAAS,EAAE,eAAe,EAC1B,SAAS,EACT,cAAc,EAAE,mBAAmB,GACpC,GAAG,MAAM,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,UAAU,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QAErF,aAAa;QAEb,4BAA4B;QAC5B,gBAAM,CAAC,KAAK,CAAC,SAAS,EAAE,eAAe,EAAE,wCAAwC,CAAC,CAAC;QACnF,MAAM,4BAA4B,GAAG,uBAAS,CAAC,mBAAmB,CAChE,MAAM,uBAAS,CAAC,gCAAgC,CAC9C,EAAE,WAAW,EAAE,EAAE,EAAE,iBAAiB,EAAE,CAAC,IAAI,CAAC,2BAA2B,CAAC,SAAS,CAAC,CAAC,EAAE,EACrF,CAAC,cAAc,CAAC,EAChB,EAAE,CACH,CACF,CAAC,iBAAiB,CAAC;QACpB,MAAM,uBAAuB,GAAG,4BAA4B,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,KAAK,CAAC,CAAC;QAE5G,IAAA,gBAAM,EAAC,uBAAuB,EAAE,iDAAiD,CAAC,CAAC;QACnF,WAAW,CAAC,sBAAsB,CAAC;YACjC,WAAW,EAAE,EAAE;YACf,iBAAiB,EAAE,CAAC,uBAAuB,EAAE,wBAAwB,CAAC;SACvE,CAAC,CAAC;QAEH,aAAa,CAAC,sBAAsB,CAAC;YACnC,WAAW,EAAE,EAAE;YACf,iBAAiB,EAAE,CAAC,uBAAuB,EAAE,sBAAsB,CAAC;SACrE,CAAC,CAAC;QAEH,MAAM,mBAAmB,GAAG,WAAW,CAAC,WAAW,EAAE,CAAC;QACtD,MAAM,qBAAqB,GAAG,aAAa,CAAC,WAAW,EAAE,CAAC;QAC1D,MAAM,0BAA0B,GAAG,WAAW,CAAC,kBAAkB,EAAE,CAAC;QACpE,MAAM,4BAA4B,GAAG,aAAa,CAAC,kBAAkB,EAAE,CAAC;QAExE,MAAM,kBAAkB,GAAG,uBAAS,CAAC,iBAAiB,CAAC,mBAAmB,CAAC,CAAC;QAC5E,MAAM,oBAAoB,GAAG,uBAAS,CAAC,iBAAiB,CAAC,qBAAqB,CAAC,CAAC;QAEhF,gBAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE,kBAAkB,EAAE,8CAA8C,CAAC,CAAC;QACtG,gBAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE,oBAAoB,EAAE,gDAAgD,CAAC,CAAC;QAE1G,MAAM,iBAAiB,GACrB,MAAM,CAAC,iBAAiB,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,uBAAuB,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC3G,IAAI,CAAC;YACH,MAAM,mBAAmB,GAAG,IAAI,CAAC,eAAe,CAC9C,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC1B,MAAM,CAAC,UAAU,EACjB,MAAM,CAAC,8BAA8B,EACrC,MAAM,CAAC,YAAY,EACnB,iBAAiB,EACjB,MAAM,CAAC,iBAAiB,EACxB,MAAM,CAAC,UAAU,EACjB,MAAM,CAAC,MAAM,CACd,CAAC;YACF,MAAM,qBAAqB,GAAG,IAAI,CAAC,iBAAiB,CAClD,mBAAmB,EACnB,qBAAqB,EACrB,4BAA4B,EAC5B,MAAM,CAAC,UAAU,EACjB,MAAM,CAAC,8BAA8B,EACrC,iBAAiB,EACjB,MAAM,CAAC,iBAAiB,EACxB,MAAM,CAAC,MAAM,CACd,CAAC;YACF,MAAM,oBAAoB,GAAG,IAAI,CAAC,gBAAgB,CAAC,mBAAmB,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;YAEvF,MAAM,CAAC,YAAY,EAAE,cAAc,EAAE,aAAa,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;gBACtE,mBAAmB;gBACnB,qBAAqB;gBACrB,oBAAoB;aACrB,CAAC,CAAC;YACH,aAAa;YAEb,OAAO;gBACL,YAAY;gBACZ,cAAc;gBACd,aAAa;aACd,CAAC;QACJ,CAAC;gBAAS,CAAC;YACT,iBAAiB,EAAE,OAAO,EAAE,CAAC;QAC/B,CAAC;IACH,CAAC;IAED,yBAAyB;IACzB,KAAK,CAAC,yBAAyB,CAC7B,gBAA8C,EAC9C,cAAsB,EACtB,eAAwB,EACxB,sBAA+B,EAC/B,UAAmB,EACnB,8BAAuC,EACvC,YAAwC,EACxC,iBAIC,EACD,iBAAqC,EACrC,UAAmB,EACnB,MAAe;QAEf,IAAI,MAAc,CAAC;QACnB,IAAI,YAAY,GAAuB,SAAS,CAAC;QACjD,IAAI,mBAAmB,GAAuB,SAAS,CAAC;QACxD,IAAI,qBAAqB,GAAuB,SAAS,CAAC;QAC1D,QAAQ,gBAAgB,EAAE,CAAC;YACzB,KAAK,6BAAgB,CAAC,IAAI,CAAC;YAC3B,KAAK,6BAAgB,CAAC,MAAM;gBAC1B,MAAM,GAAG,gBAAgB,KAAK,6BAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC;gBACxE,IAAA,gBAAM,EAAC,eAAe,EAAE,oCAAoC,MAAM,WAAW,CAAC,CAAC;gBAC/E,IAAA,gBAAM,EAAC,sBAAsB,EAAE,4CAA4C,MAAM,WAAW,CAAC,CAAC;gBAC9F,IAAA,gBAAM,EAAC,UAAU,EAAE,8BAA8B,MAAM,WAAW,CAAC,CAAC;gBACpE,qBAAqB,GAAG,eAAe,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;gBAC3D,IAAI,iBAAiB,EAAE,CAAC;oBACtB,YAAY,GAAG,MAAM,iBAAiB,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC;oBACtE,mBAAmB,GAAG,MAAM,iBAAiB,CAAC,OAAO,CACnD,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAC1F,CAAC;gBACJ,CAAC;qBAAM,CAAC;oBACN,YAAY,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;wBACtC,KAAK,EAAE,qBAAqB;wBAC5B,QAAQ,EAAE,UAAU;wBACpB,iBAAiB;qBAClB,CAAC,CAAC;oBACH,gFAAgF;oBAChF,sFAAsF;oBACtF,+EAA+E;oBAC/E,yCAAyC;oBACzC,mBAAmB,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;wBAC7C,qFAAqF;wBACrF,yJAAyJ;wBACzJ,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC;wBAChG,QAAQ,EAAE,UAAU;wBACpB,iBAAiB;qBAClB,CAAC,CAAC;gBACL,CAAC;gBACD,MAAM;YACR,KAAK,6BAAgB,CAAC,KAAK;gBACzB,MAAM,GAAG,OAAO,CAAC;gBACjB,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QACjD,CAAC;QAED,MAAM,uBAAuB,GAAuB;YAClD,MAAM;YACN,OAAO,EAAE,KAAgB;YACzB,cAAc;YACd,YAAY;YACZ,8BAA8B;YAC9B,OAAO,EAAE,IAAI;YACb,MAAM;SACP,CAAC;QAEF,IAAI,YAAY,IAAI,gBAAgB,KAAK,6BAAgB,CAAC,IAAI,IAAI,qBAAqB,EAAE,CAAC;YACxF,sGAAsG;YACtG,IAAA,gBAAM,EAAC,UAAU,EAAE,yEAAyE,CAAC,CAAC;YAC9F,uBAAuB,CAAC,YAAY,GAAG;gBACrC,WAAW,EAAE,YAAY,CAAC,WAAW;gBACrC,OAAO,EAAE,YAAY,CAAC,OAAO;gBAC7B,YAAY,EAAE,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;oBACrC,KAAK,EAAE,qBAAqB;oBAC5B,QAAQ,EAAE,YAAY,CAAC,UAAU;oBACjC,iBAAiB;iBAClB,CAAC;gBACF,YAAY,EAAE,UAAU;aACzB,CAAC;QACJ,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;QAC5C,OAAO,EAAE,GAAG,CAAC,MAAM,SAAS,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,CAAC;IACzG,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,qBAAqB,CAC1B,iBAAyB,EACzB,OAAwD;QAExD,MAAM,GAAG,GAAG,IAAI,mBAAK,EAAE,CAAC;QACxB,MAAM,MAAM,GAAG;YACb,KAAK,CAAC,IAAI,CAAC,IAAA,8BAAgB,EAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAC3C,KAAK,CAAC,IAAI,CAAC,IAAA,8BAAgB,EAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAC3C,KAAK,CAAC,IAAI,CAAC,IAAA,8BAAgB,EAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;SAC5C,CAAC;QACF,OAAO,eAAe,CAAC,gCAAgC,CAAC;YACtD,kBAAkB,EAAE,iBAAiB;YACrC,eAAe,EAAE,OAAO,KAAK,6BAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1D,MAAM;YACN,GAAG;SACJ,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,iCAAiC,CAAC,MAAkE;QAIlG,MAAM,GAAG,GAAG,IAAI,mBAAK,EAAE,CAAC;QACxB,MAAM,MAAM,GAAG;YACb,KAAK,CAAC,IAAI,CAAC,IAAA,8BAAgB,EAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAC3C,KAAK,CAAC,IAAI,CAAC,IAAA,8BAAgB,EAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAC3C,KAAK,CAAC,IAAI,CAAC,IAAA,8BAAgB,EAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;SAC5C,CAAC;QACF,OAAO;YACL,iBAAiB,EAAE,eAAe,CAAC,gCAAgC,CAAC;gBAClE,kBAAkB,EAAE,MAAM,CAAC,iBAAiB;gBAC5C,eAAe,EAAE,CAAC;gBAClB,MAAM;gBACN,GAAG;aACJ,CAAC;YACF,mBAAmB,EAAE,eAAe,CAAC,gCAAgC,CAAC;gBACpE,kBAAkB,EAAE,MAAM,CAAC,mBAAmB;gBAC9C,eAAe,EAAE,CAAC;gBAClB,MAAM;gBACN,GAAG;aACJ,CAAC;SACH,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,gCAAgC,CAAC,EACtC,kBAAkB,EAClB,eAAe,EACf,MAAM,EACN,GAAG,GAMJ;QACC,MAAM,eAAe,GAAqC,IAAI,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;QACzF,IAAI,WAAW,GAA4B,SAAS,CAAC;QACrD,QAAQ,eAAe,EAAE,CAAC;YACxB,KAAK,CAAC;gBACJ,IAAA,gBAAM,EAAC,eAAe,CAAC,YAAY,EAAE,oDAAoD,CAAC,CAAC;gBAC3F,IAAA,gBAAM,EAAC,eAAe,CAAC,WAAW,EAAE,mDAAmD,CAAC,CAAC;gBACzF,WAAW,GAAG,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC,MAAM,EAAE;oBACnD,eAAe,CAAC,YAAY;oBAC5B,eAAe,CAAC,WAAW;iBAC5B,CAAC,CAAC;gBACH,MAAM;YACR,KAAK,CAAC;gBACJ,IAAA,gBAAM,EAAC,eAAe,CAAC,UAAU,EAAE,oDAAoD,CAAC,CAAC;gBACzF,IAAA,gBAAM,EAAC,eAAe,CAAC,WAAW,EAAE,mDAAmD,CAAC,CAAC;gBACzF,WAAW,GAAG,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC,eAAe,CAAC,UAAU,EAAE,eAAe,CAAC,WAAW,CAAC,CAAC,CAAC;gBAChH,MAAM;YACR,KAAK,CAAC;gBACJ,IAAA,gBAAM,EAAC,eAAe,CAAC,UAAU,EAAE,oDAAoD,CAAC,CAAC;gBACzF,IAAA,gBAAM,EAAC,eAAe,CAAC,YAAY,EAAE,oDAAoD,CAAC,CAAC;gBAC3F,WAAW,GAAG,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC,MAAM,EAAE;oBACnD,eAAe,CAAC,UAAU;oBAC1B,eAAe,CAAC,YAAY;iBAC7B,CAAC,CAAC;gBACH,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QACjD,CAAC;QACD,OAAO;YACL,MAAM,EAAE,WAAW,CAAC,MAAM;YAC1B,MAAM,EAAE,MAAM;SACf,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,eAAe,CAC3B,cAAsB,EACtB,eAAuB,EACvB,sBAA8B,EAC9B,UAAkB,EAClB,8BAAuC,EACvC,YAAwC,EACxC,iBAIC,EACD,iBAAqC,EACrC,UAAmB,EACnB,MAAe;QAEf,OAAO,IAAI,CAAC,yBAAyB,CACnC,6BAAgB,CAAC,IAAI,EACrB,cAAc,EACd,eAAe,EACf,sBAAsB,EACtB,UAAU,EACV,8BAA8B,EAC9B,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,EACjB,UAAU,EACV,MAAM,CACP,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,iBAAiB,CAC7B,cAAsB,EACtB,eAAuB,EACvB,sBAA8B,EAC9B,UAAkB,EAClB,8BAAuC,EACvC,iBAIC,EACD,iBAAqC,EACrC,MAAe;QAEf,OAAO,IAAI,CAAC,yBAAyB,CACnC,6BAAgB,CAAC,MAAM,EACvB,cAAc,EACd,eAAe,EACf,sBAAsB,EACtB,UAAU,EACV,8BAA8B,EAC9B,SAAS,EACT,iBAAiB,EACjB,iBAAiB,EACjB,SAAS,EACT,MAAM,CACP,CAAC;IACJ,CAAC;IAEO,uBAAuB,CAAC,CAAS,EAAE,CAAS,EAAE,QAAmC;QACvF,IAAI,QAAQ,EAAE,CAAC;YACb,MAAM,YAAY,GAAG,IAAI,CAAC,iCAAiC,CAAC;gBAC1D,iBAAiB,EAAE,QAAQ,CAAC,gBAAgB;gBAC5C,mBAAmB,EAAE,QAAQ,CAAC,kBAAkB;aACjD,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,IAAI,qBAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,6BAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,YAAY,CAAC,iBAAiB,CAAC,CAAC;YAC5G,MAAM,aAAa,GAAG,IAAI,qBAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,6BAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,YAAY,CAAC,mBAAmB,CAAC,CAAC;YAElH,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;QACxC,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,qBAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,6BAAgB,CAAC,IAAI,CAAC,CAAC;QACjE,MAAM,aAAa,GAAG,IAAI,qBAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,6BAAgB,CAAC,MAAM,CAAC,CAAC;QAErE,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;IACxC,CAAC;IAEO,KAAK,CAAC,gBAAgB,CAAC,cAAsB,EAAE,MAAe;QACpE,OAAO,IAAI,CAAC,yBAAyB,CACnC,6BAAgB,CAAC,KAAK,EACtB,cAAc,EACd,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,MAAM,CACP,CAAC;IACJ,CAAC;IACD,aAAa;IAEb;;;OAGG;IACH,KAAK,CAAC,iCAAiC,CAAC,MAGvC;QACC,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;QACzC,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,IAAI,CAAC,oCAAoC,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;QAC7F,MAAM,QAAQ,GAAG,cAAc,IAAI,IAAI,CAAC,sBAAsB,CAAC;QAC/D,IAAA,gBAAM,EAAC,QAAQ,EAAE,0CAA0C,CAAC,CAAC;QAC7D,MAAM,iBAAiB,GAAG,QAAQ,CAAC,KAAK,EAAE,CAAC;QAE3C,IAAI,IAAA,8CAA+B,EAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC;YACzD,IAAA,gBAAM,EAAC,IAAA,+BAAgB,EAAC,iBAAiB,EAAE,OAAO,CAAC,EAAE,8BAA8B,CAAC,CAAC;QACvF,CAAC;QAED,uEAAuE;QACvE,MAAM,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,cAAc,EAAE,SAAS,EAAE,WAAW,EAAE,GACpF,MAAM,SAAS,CAAC,kBAAkB,CAAC;YACjC,UAAU;YACV,iBAAiB;SAClB,CAAC,CAAC;QAEL,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,eAAe,EAAE,iBAAiB,EAAE,GAAG,MAAM,IAAI,CAAC,uBAAuB,CACrG,UAAU,EACV,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,CACf,CAAC;QAEF,8DAA8D;QAC9D,MAAM,EACJ,cAAc,EACd,SAAS,EAAE,eAAe,EAC1B,WAAW,EAAE,iBAAiB,GAC/B,GAAG,MAAM,SAAS,CAAC,cAAc,CAAC;YACjC,SAAS;YACT,SAAS;YACT,eAAe;YACf,iBAAiB;YACjB,SAAS;YACT,WAAW;SACZ,CAAC,CAAC;QAEH,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,uBAAuB,CAAC,UAAU,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QACjG,gBAAM,CAAC,WAAW,CAAC,cAAc,CAAC,SAAS,EAAE,SAAS,EAAE,mCAAmC,CAAC,CAAC;QAE7F,8DAA8D;QAC9D,MAAM,EACJ,cAAc,EACd,SAAS,EAAE,eAAe,EAC1B,WAAW,EAAE,iBAAiB,GAC/B,GAAG,MAAM,SAAS,CAAC,cAAc,CAAC;YACjC,SAAS;YACT,gBAAgB,EAAE,cAAc,CAAC,gBAAgB;YACjD,eAAe,EAAE,cAAc,CAAC,eAAe;YAC/C,iBAAiB,EAAE,cAAc,CAAC,iBAAiB;YACnD,SAAS,EAAE,eAAe;YAC1B,WAAW,EAAE,iBAAiB;SAC/B,CAAC,CAAC;QAEH,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,uBAAuB,CAAC,UAAU,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QACjG,gBAAM,CAAC,WAAW,CAAC,cAAc,CAAC,SAAS,EAAE,SAAS,EAAE,mCAAmC,CAAC,CAAC;QAE7F,+FAA+F;QAC/F,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,SAAS,CAAC,gBAAgB,CAAC;YAC1D,SAAS;YACT,SAAS,EAAE,cAAc,CAAC,SAAS;YACnC,mBAAmB,EAAE,cAAc,CAAC,cAAc;YAClD,SAAS,EAAE,eAAe;YAC1B,WAAW,EAAE,iBAAiB;SAC/B,CAAC,CAAC;QACH,gBAAM,CAAC,WAAW,CAAC,cAAc,EAAE,cAAc,CAAC,cAAc,EAAE,+BAA+B,CAAC,CAAC;QAEnG,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;QAC5C,MAAM,CAAC,YAAY,EAAE,cAAc,EAAE,aAAa,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YACtE,SAAS,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;YAChF,SAAS,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;YAClF,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC;SACtC,CAAC,CAAC;QAEH,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,CAAC;IACzD,CAAC;IAED,KAAK,CAAC,uBAAuB,CAC3B,UAAkB,EAClB,gBAAwB,EACxB,kBAA0B,EAC1B,OAA0D,EAC1D,MAAe;QAEf,OAAO,IAAI,CAAC,+BAA+B,CACzC,IAAA,kDAAyB,EAAC,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,CAAC,EACzD,gBAAgB,EAChB,kBAAkB,EAClB,OAAO,CACR,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,uBAAuB,CAC3B,UAAkB,EAClB,SAAiB,EACjB,OAAkC;QAElC,OAAO,IAAI,CAAC,+BAA+B,CAAC,IAAA,kDAAyB,EAAC,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IACrH,CAAC;IAED,KAAK,CAAC,uBAAuB,CAC3B,UAAkB,EAClB,SAAiB,EACjB,OAAkC;QAElC,OAAO,IAAI,CAAC,+BAA+B,CAAC,IAAA,kDAAyB,EAAC,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IACrH,CAAC;IAED,KAAK,CAAC,+BAA+B,CACnC,QAA2D,EAC3D,gBAAwB,EACxB,kBAA0B,EAC1B,OAA0D;QAE1D,IAAA,gBAAM,EAAC,4BAAc,CAAC,EAAE,CAAC,gBAAgB,CAAC,EAAE,iCAAiC,CAAC,CAAC;QAC/E,IAAA,gBAAM,EAAC,4BAAc,CAAC,EAAE,CAAC,kBAAkB,CAAC,EAAE,mCAAmC,CAAC,CAAC;QACnF,MAAM,QAAQ,GAAG,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;QAClG,IAAA,gBAAM,EAAC,QAAQ,EAAE,gDAAgD,CAAC,CAAC;QACnE,MAAM,UAAU,GAAG,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;QACtG,IAAA,gBAAM,EAAC,UAAU,EAAE,kDAAkD,CAAC,CAAC;QAEvE,OAAO,QAAQ,CAAC,mCAAoB,CAAC,UAAU,CAAC,EAAE;YAChD,gBAAgB;YAChB,kBAAkB;YAClB,QAAQ,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,QAAQ,EAAE;YAClC,UAAU,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,UAAU,EAAE;YACtC,QAAQ,EAAE,OAAO,CAAC,QAAQ;SAC3B,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,+BAA+B,CACnC,QAA2D,EAC3D,SAAiB,EACjB,OAAkC;QAElC,IAAA,gBAAM,EAAC,4BAAc,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,wBAAwB,CAAC,CAAC;QAC/D,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CACvC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,KAAK,CAC3E,CAAC;QACF,IAAA,gBAAM,EAAC,QAAQ,EAAE,mDAAmD,CAAC,CAAC;QACtE,IAAA,gBAAM,EAAC,QAAQ,CAAC,UAAU,EAAE,oDAAoD,CAAC,CAAC;QAClF,IAAA,gBAAM,EAAC,4BAAc,CAAC,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,sCAAsC,CAAC,CAAC;QACvF,MAAM,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CACzC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,MAAM,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,KAAK,CAC7E,CAAC;QACF,IAAA,gBAAM,EAAC,UAAU,EAAE,qDAAqD,CAAC,CAAC;QAC1E,IAAA,gBAAM,EAAC,UAAU,CAAC,UAAU,EAAE,sDAAsD,CAAC,CAAC;QACtF,IAAA,gBAAM,EAAC,4BAAc,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,wCAAwC,CAAC,CAAC;QAE3F,OAAO,QAAQ,CAAC,mCAAoB,CAAC,UAAU,CAAC,EAAE;YAChD,SAAS;YACT,QAAQ,EAAE;gBACR,IAAI,EAAE,6BAAgB,CAAC,IAAI;gBAC3B,EAAE,EAAE,6BAAgB,CAAC,KAAK;gBAC1B,SAAS,EAAE,QAAQ,CAAC,OAAO,CAAC,SAAS;gBACrC,gBAAgB,EAAE,QAAQ,CAAC,OAAO,CAAC,gBAAgB;aACpD;YACD,eAAe,EAAE,QAAQ,CAAC,UAAU;YACpC,UAAU,EAAE;gBACV,IAAI,EAAE,6BAAgB,CAAC,MAAM;gBAC7B,EAAE,EAAE,6BAAgB,CAAC,KAAK;gBAC1B,SAAS,EAAE,UAAU,CAAC,OAAO,CAAC,SAAS;gBACvC,gBAAgB,EAAE,UAAU,CAAC,OAAO,CAAC,gBAAgB;aACtD;YACD,iBAAiB,EAAE,UAAU,CAAC,UAAU;SACzC,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,+BAA+B,CACnC,QAA2D,EAC3D,SAAiB,EACjB,OAAkC;QAElC,IAAA,gBAAM,EAAC,4BAAc,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,wBAAwB,CAAC,CAAC;QAC/D,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CACvC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,KAAK,CAC3E,EAAE,OAAO,CAAC;QACX,IAAA,gBAAM,EAAC,QAAQ,EAAE,mDAAmD,CAAC,CAAC;QACtE,MAAM,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CACzC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,MAAM,IAAI,CAAC,CAAC,EAAE,KAAK,6BAAgB,CAAC,KAAK,CAC7E,EAAE,OAAO,CAAC;QACX,IAAA,gBAAM,EAAC,UAAU,EAAE,qDAAqD,CAAC,CAAC;QAC1E,MAAM,QAAQ,GAAG,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;QAClG,IAAA,gBAAM,EAAC,QAAQ,EAAE,gDAAgD,CAAC,CAAC;QACnE,MAAM,UAAU,GAAG,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,6BAAgB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;QACtG,IAAA,gBAAM,EAAC,UAAU,EAAE,kDAAkD,CAAC,CAAC;QAEvE,OAAO,QAAQ,CAAC,mCAAoB,CAAC,UAAU,CAAC,EAAE;YAChD,SAAS;YACT,QAAQ,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,QAAQ,EAAE;YACzC,UAAU,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,UAAU,EAAE;YAC7C,QAAQ,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,QAAQ,EAAE;YAClC,UAAU,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,UAAU,EAAE;SACvC,CAAC,CAAC;IACL,CAAC;IAED,aAAa;IAEb,0BAA0B;IAE1B;;;;;;;;;OASG;IAEH,KAAK,CAAC,aAAa,CAAC,MAAqC;QACvD,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC1C,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,uBAAW,CAAC,EAAE,CAAC,CAAC;IACtD,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,uBAAuB,CAAC,MAAkC;QAC9D,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC1C,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,uBAAW,CAAC,OAAO,CAAC,CAAC;IAC3D,CAAC;IAEO,KAAK,CAAC,eAAe,CAC3B,MAAqD,EACrD,WAAwB;QAExB,MAAM,YAAY,GAAG,eAAM,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACvD,MAAM,SAAS,GACb,OAAO,MAAM,CAAC,SAAS,KAAK,QAAQ;YAClC,CAAC,CAAC,MAAM,IAAA,kBAAY,EAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC;YAClF,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC;QACvB,IAAI,iBAAiB,CAAC;QACtB,IAAI,cAAc,CAAC;QACnB,IAAI,aAAa,CAAC;QAClB,IAAI,eAAmC,CAAC;QACxC,MAAM,UAAU,GAAG,MAAM,IAAA,iCAAkB,EAAC,WAAW,CAAC,CAAC;QACzD,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,4BAA4B,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;QAE3G,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;QACrD,CAAC;QAED,IAAI,WAAW,KAAK,uBAAW,CAAC,EAAE,EAAE,CAAC;YACnC,IAAA,gBAAM,EAAC,SAAS,CAAC,YAAY,IAAI,SAAS,CAAC,WAAW,EAAE,0CAA0C,CAAC,CAAC;YACpG,MAAM,UAAU,GACd,SAAS,CAAC,UAAU,KAAK,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,YAAa,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;YAErG,IACE,iBAAiB,IAAI,MAAM;gBAC3B,MAAM,CAAC,eAAe,KAAK,gCAAoB,CAAC,QAAQ;gBACxD,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,EAAE,MAAM,EACpC,CAAC;gBACD,MAAM,IAAI,gCAAuB,CAC/B,sFAAsF,CACvF,CAAC;YACJ,CAAC;YAED,mEAAmE;YACnE,qEAAqE;YACrE,oEAAoE;YACpE,oDAAoD;YACpD,6EAA6E;YAC7E,oEAAoE;YACpE,gFAAgF;YAChF,IAAI,IAAA,uDAA+B,EAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,IAAA,8CAA0B,EAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,EAAE,CAAC;gBAC5G,MAAM,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC;oBACpC,UAAU,EAAE,EAAE,KAAK,EAAE,UAAU,CAAC,eAAe,EAAE,MAAM,EAAE,UAAU,CAAC,WAAW,EAAE;oBACjF,QAAQ,EAAE,IAAA,yCAAwB,EAAC,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC;oBAC9D,MAAM,EAAE,IAAI,CAAC,MAAM;oBACnB,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE;iBACvC,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC;oBACpC,UAAU,EAAE,EAAE,KAAK,EAAE,UAAU,CAAC,WAAW,EAAE;oBAC7C,QAAQ,EAAE,IAAA,yCAAwB,EAAC,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC;oBAC9D,MAAM,EAAE,IAAI,CAAC,MAAM;oBACnB,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE;iBACvC,CAAC,CAAC;YACL,CAAC;YACD,iBAAiB,GAAG,UAAU,CAAC,WAAW,CAAC;YAC3C,cAAc,GAAG,UAAU,CAAC,cAAc,CAAC;YAC3C,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC;YAC7C,aAAa,GAAG,eAAM,CAAC,IAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;QACxD,CAAC;aAAM,IAAI,WAAW,KAAK,uBAAW,CAAC,OAAO,EAAE,CAAC;YAC/C,iBAAiB,GAAG,SAAS,CAAC,QAAS,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC;YAC1D,cAAc,GAAG,SAAS,CAAC,QAAS,CAAC,CAAC,CAAC,CAAC,cAAc,IAAI,KAAK,CAAC;YAChE,aAAa,GAAG,eAAM,CAAC,IAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;QACxD,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;QAC1C,CAAC;QAED,uEAAuE;QACvE,2EAA2E;QAC3E,0EAA0E;QAC1E,+DAA+D;QAC/D,uEAAuE;QACvE,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,eAAe,EAAE,iBAAiB,EAAE,aAAa,CAAC,CAAC;QAC9F,MAAM,WAAW,GAAG,IAAI,qBAAO,CAAC,GAAG,CACjC,YAAY,EACZ,MAAM,CAAC,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,EAC3D,cAAc,EACd,UAAU,CACX,CAAC;QACF,MAAM,uBAAuB,GAAG,MAAM,WAAW,CAAC,IAAI,EAAE,CAAC;QACzD,MAAM,oBAAoB,GAAG,MAAM,IAAA,sCAAyB,EAC1D,uBAAuB,EACvB,UAAU,EACV,MAAM,CAAC,YAAY,CACpB,CAAC;QAEF,IAAI,eAAe,GAAG,MAAM,IAAA,6BAAoB,EAC9C,IAAI,CAAC,KAAK,EACV,SAAS,CAAC,QAAQ,EAClB,SAAS,CAAC,WAAW,EACrB,CAAC,oBAAoB,CAAC,EACtB,WAAW,EACX,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,EAC/B,UAAU,CAAC,SAAS,EACpB,SAAS,EACT,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,EACjC,MAAM,CAAC,KAAK,CACb,CAAC;QAEF,IAAA,gBAAM,EAAC,eAAe,CAAC,YAAY,IAAI,eAAe,CAAC,QAAQ,EAAE,0BAA0B,CAAC,CAAC;QAE7F,IAAI,wBAA6B,CAAC;QAClC,IAAI,WAAW,KAAK,uBAAW,CAAC,EAAE,EAAE,CAAC;YACnC,wBAAwB,GAAG,eAAe,CAAC,YAAa,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC;QAC9E,CAAC;aAAM,CAAC;YACN,wBAAwB,GAAG,eAAe,CAAC,QAAS,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC;QAC1E,CAAC;QACD,8BAA8B;QAC9B,MAAM,iCAAiC,GAAG,IAAI,CAAC,KAAK,CAClD,wBAAwB,CAAC,wBAAwB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CACjC,CAAC;QACrC,IAAI,iCAAiC,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;YAC9D,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;QAChF,CAAC;QACD,MAAM,uCAAuC,GAAG,MAAM,IAAA,qDAAwC,EAC5F,iCAAiC,EACjC,UAAU,EACV,cAAc,EACd,MAAM,CAAC,YAAY,CACpB,CAAC;QAEF,eAAe;QACf,MAAM,oBAAoB,GAAG,uBAAS,CAAC,mBAAmB,CAAC,uCAAuC,CAAC,CAAC;QACpG,MAAM,yBAAyB,GAAG,WAAW,CAAC,sBAAsB,CAAC;YACnE,WAAW,EAAE,EAAE;YACf,iBAAiB,EAAE,oBAAoB,CAAC,iBAAiB;SAC1D,CAAC,CAAC;QACH,MAAM,yBAAyB,GAAG,WAAW,CAAC,sBAAsB,CAAC;YACnE,WAAW,EAAE,oBAAoB,CAAC,WAAW;YAC7C,iBAAiB,EAAE,EAAE;SACtB,CAAC,CAAC;QACH,MAAM,sBAAsB,GAAG,MAAM,IAAA,sCAAyB,EAC5D,yBAAyB,EACzB,yBAAyB,EACzB,UAAU,EACV,cAAc,EACd,MAAM,CAAC,YAAY,CACpB,CAAC;QACF,eAAe,GAAG,MAAM,IAAA,6BAAoB,EAC1C,IAAI,CAAC,KAAK,EACV,SAAS,CAAC,QAAQ,EAClB,SAAS,CAAC,WAAW,EACrB,CAAC,sBAAsB,CAAC,EACxB,WAAW,EACX,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,EAC/B,UAAU,CAAC,SAAS,EACpB,SAAS,EACT,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,EACjC,MAAM,CAAC,KAAK,CACb,CAAC;QACF,IAAA,gBAAM,EAAC,eAAe,CAAC,YAAY,IAAI,eAAe,CAAC,QAAQ,EAAE,0BAA0B,CAAC,CAAC;QAE7F,MAAM,wBAAwB,GAC5B,WAAW,KAAK,uBAAW,CAAC,EAAE;YAC5B,CAAC,CAAC,eAAe,CAAC,YAAa,CAAC,CAAC,CAAC,CAAC,eAAe;YAClD,CAAC,CAAC,eAAe,CAAC,QAAS,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC;QACnD,8BAA8B;QAC9B,MAAM,iCAAiC,GAAG,IAAI,CAAC,KAAK,CAClD,wBAAwB,CAAC,wBAAwB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CACjC,CAAC;QACrC,IAAI,iCAAiC,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;YAC9D,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;QAChF,CAAC;QACD,MAAM,mCAAmC,GAAG,MAAM,IAAA,qDAAwC,EACxF,iCAAiC,EACjC,UAAU,EACV,cAAc,EACd,MAAM,CAAC,YAAY,CACpB,CAAC;QAEF,eAAe;QACf,MAAM,qCAAqC,GAAG,uBAAS,CAAC,mBAAmB,CAAC;YAC1E,WAAW,EAAE,mCAAmC,CAAC,WAAW;YAC5D,iBAAiB,EAAE,EAAE;SACtB,CAAC,CAAC;QACH,MAAM,yBAAyB,GAAG,WAAW,CAAC,sBAAsB,CAAC;YACnE,WAAW,EAAE,qCAAqC,CAAC,WAAW;YAC9D,iBAAiB,EAAE,EAAE;SACtB,CAAC,CAAC;QAEH,MAAM,wBAAwB,GAAG,MAAM,IAAA,wCAA2B,EAChE,yBAAyB,EACzB,UAAU,EACV,cAAc,EACd,MAAM,CAAC,YAAY,CACpB,CAAC;QACF,2CAA2C;QAC3C,MAAM,IAAA,6BAAoB,EACxB,IAAI,CAAC,KAAK,EACV,SAAS,CAAC,QAAQ,EAClB,SAAS,CAAC,WAAW,EACrB,CAAC,wBAAwB,CAAC,EAC1B,WAAW,EACX,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,EAC/B,UAAU,CAAC,SAAS,EACpB,SAAS,EACT,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,EACjC,MAAM,CAAC,KAAK,CACb,CAAC;QAEF,OAAO,IAAA,sBAAa,EAAC,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,QAAQ,EAAE,SAAS,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACzG,CAAC;IAED,aAAa;IAEb,2BAA2B;IAC3B,2BAA2B,CAAC,gBAAuC;QACjE,OAAO;YACL,IAAI,EAAE,gBAAgB,CAAC,IAAI;YAC3B,OAAO,EAAE,EAAE,OAAO,EAAE,gBAAgB,CAAC,OAAO,EAAE,SAAS,EAAE,gBAAgB,CAAC,SAAS,EAAE;SACtF,CAAC;IACJ,CAAC;IAED,gBAAgB,CAAC,UAA2B,EAAE,UAAmB;QAC/D,OAAO;YACL,OAAO,EAAE,EAAE,gBAAgB,EAAE,UAAU,CAAC,gBAAgB,EAAE,SAAS,EAAE,UAAU,CAAC,SAAS,EAAE;YAC3F,IAAI,EAAE,UAAU,CAAC,IAAI;YACrB,EAAE,EAAE,UAAU,CAAC,EAAE;YACjB,UAAU;SACX,CAAC;IACJ,CAAC;IACD,aAAa;IAEb,wBAAwB;IACxB;;;;;OAKG;IACK,8BAA8B,CACpC,SAAoB,EACpB,cAA2B,uBAAW,CAAC,EAAE;QAEzC,IAAI,QAAgB,CAAC;QACrB,IAAI,cAAsB,CAAC;QAC3B,IAAI,eAAmC,CAAC;QACxC,IAAI,WAAW,KAAK,uBAAW,CAAC,EAAE,EAAE,CAAC;YACnC,MAAM,UAAU,GAAG,IAAI,CAAC,+BAA+B,CAAC,SAAS,EAAE,0CAA0C,CAAC,CAAC;YAC/G,QAAQ,GAAG,UAAU,CAAC,WAAW,CAAC;YAClC,cAAc,GAAG,UAAU,CAAC,cAAc,CAAC;YAC3C,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC;QAC/C,CAAC;aAAM,IAAI,WAAW,KAAK,uBAAW,CAAC,OAAO,EAAE,CAAC;YAC/C,iDAAiD;YACjD,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;QAC9D,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,KAAK,CAAC,6BAA6B,GAAG,WAAW,CAAC,CAAC;QAC/D,CAAC;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,eAAe,EAAE,QAAQ,EAAE,eAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC;QACpG,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC;IACxC,CAAC;IAED;;;;;OAKG;IACK,kBAAkB,CAAC,eAAmC,EAAE,WAAmB,EAAE,aAAqB;QACxG,MAAM,UAAU,GAAwB;YACtC,eAAe,EAAE,eAAe,IAAI,EAAE;YACtC,WAAW;SACZ,CAAC;QACF,IAAI,eAAe,IAAI,IAAA,8CAA0B,EAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,EAAE,CAAC;YAC7E,IAAA,gBAAM,EACJ,aAAa,CAAC,MAAM,KAAK,EAAE,EAC3B,0DAA0D,aAAa,CAAC,MAAM,EAAE,CACjF,CAAC;YACF,OAAO,aAAa,CAAC;QACvB,CAAC;QAED,IAAI,IAAU,CAAC;QACf,IAAI,CAAC;YACH,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,CAAC;QACzC,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,GAAG,IAAA,gBAAgB,EAAC,WAAW,CAAS,CAAC;QAC/C,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,MAAM,EAAE,CAAC;IAC7C,CAAC;IAED,aAAa;IAEb,0BAA0B;IAC1B,kBAAkB;IAClB,KAAK,CAAC,oCAAoC,CACxC,MAAuC,EACvC,yCAAqF,EACrF,yCAAqF,EACrF,yCAAqF,EACrF,cAA2B,uBAAW,CAAC,EAAE;QAEzC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC;QACpC,IAAI,iBAA4B,CAAC;QAEjC,iDAAiD;QACjD,IAAA,gBAAM,EACJ,WAAW,KAAK,uBAAW,CAAC,EAAE,EAC9B,kEAAkE,GAAG,WAAW,CACjF,CAAC;QAEF,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;YAClC,iBAAiB,GAAG,MAAM,IAAA,kBAAY,EAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QACzF,CAAC;aAAM,CAAC;YACN,iBAAiB,GAAG,SAAS,CAAC;QAChC,CAAC;QAED,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,4BAA4B,CAC/D,IAAI,EACJ,MAAM,CAAC,KAAK,EACZ,iBAAiB,CAAC,YAAY,CAC/B,CAAC;QAEF,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;QACrD,CAAC;QAED,UAAU;QACV,MAAM,EAAE,oBAAoB,EAAE,aAAa,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,GAC3F,MAAM,yCAAyC,CAAC,EAAE,SAAS,EAAE,iBAAiB,EAAE,CAAC,CAAC;QACpF,MAAM,eAAe,GAAG,MAAM,IAAA,6BAAoB,EAChD,IAAI,CAAC,KAAK,EACV,iBAAiB,CAAC,QAAQ,EAC1B,iBAAiB,CAAC,WAAW,EAC7B,CAAC,oBAAoB,CAAC,EACtB,WAAW,EACX,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,EAC/B,aAAa,EACb,SAAS,EACT,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,EACjC,KAAK,CACN,CAAC;QAEF,UAAU;QACV,MAAM,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,GAAG,MAAM,yCAAyC,CAAC;YACvG,SAAS,EAAE,eAAe;YAC1B,sBAAsB;YACtB,sBAAsB;YACtB,iBAAiB,EAAE,iBAAiB,CAAC,KAAK,EAAE;SAC7C,CAAC,CAAC;QACH,MAAM,eAAe,GAAG,MAAM,IAAA,6BAAoB,EAChD,IAAI,CAAC,KAAK,EACV,iBAAiB,CAAC,QAAQ,EAC1B,iBAAiB,CAAC,WAAW,EAC7B,CAAC,oBAAoB,CAAC,EACtB,WAAW,EACX,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,EAC/B,aAAa,EACb,SAAS,EACT,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,EACjC,KAAK,CACN,CAAC;QACF,IAAA,gBAAM,EACJ,eAAe,CAAC,YAAY,IAAI,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,eAAe,EAC/E,+CAA+C,CAChD,CAAC;QAEF,UAAU;QACV,MAAM,EAAE,oBAAoB,EAAE,GAAG,MAAM,yCAAyC,CAAC;YAC/E,SAAS,EAAE,eAAe;YAC1B,sBAAsB;YACtB,sBAAsB;YACtB,iBAAiB,EAAE,iBAAiB,CAAC,KAAK,EAAE;SAC7C,CAAC,CAAC;QACH,MAAM,IAAA,6BAAoB,EACxB,IAAI,CAAC,KAAK,EACV,iBAAiB,CAAC,QAAQ,EAC1B,iBAAiB,CAAC,WAAW,EAC7B,CAAC,oBAAoB,CAAC,EACtB,WAAW,EACX,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,EAC/B,aAAa,EACb,SAAS,EACT,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,EACjC,KAAK,CACN,CAAC;QAEF,OAAO,IAAA,sBAAa,EAAC,IAAI,CAAC,KAAK,EAAE,iBAAiB,CAAC,QAAQ,EAAE,iBAAiB,CAAC,WAAW,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;IAClH,CAAC;IAED,KAAK,CAAC,wBAAwB,CAAC,MAK9B;QAMC,MAAM,EAAE,GAAG,EAAE,gBAAgB,EAAE,SAAS,EAAE,YAAY,EAAE,GAAG,MAAM,CAAC;QAClE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,GAAG,IAAI,CAAC,8BAA8B,CAAC,SAAS,CAAC,CAAC;QACtF,MAAM,KAAK,GAAG,GAAG,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,cAAc,EAAE,CAAC;QAEhE,MAAM,YAAY,GAAG,eAAM,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,MAAM,IAAA,iCAAkB,EAAC,WAAW,CAAC,CAAC;QAEzD,MAAM,UAAU,GAAG,IAAI,qBAAO,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC,EAAE,cAAc,EAAE,UAAU,CAAC,CAAC;QAChF,MAAM,uBAAuB,GAAG,MAAM,UAAU,CAAC,IAAI,EAAE,CAAC;QACxD,MAAM,oBAAoB,GAAG,MAAM,IAAA,sCAAyB,EAAC,uBAAuB,EAAE,UAAU,CAAC,CAAC;QAClG,MAAM,WAAW,GAAG,UAAU,CAAC,UAAU,EAAE,CAAC;QAC5C,MAAM,aAAa,GAAG,UAAU,CAAC,SAAS,CAAC;QAE3C,MAAM,KAAK,GAAG,YAAY,KAAK,SAAS,IAAI,IAAA,wBAAY,EAAC,YAAY,CAAC,CAAC;QACvE,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,uBAAuB,CAAC,gBAAgB,CAAC,CAAC;YAC3E,IAAI,CAAC;gBACH,MAAM,sBAAsB,GAAG,MAAM,OAAO,CAAC,OAAO,CAClD,WAAW,EACX,GAAG,eAAe,CAAC,2BAA2B,IAAI,KAAK,EAAE,CAC1D,CAAC;gBACF,MAAM,sBAAsB,GAAG,MAAM,OAAO,CAAC,OAAO,CAClD,UAAU,CAAC,UAAU,EACrB,GAAG,eAAe,CAAC,2BAA2B,IAAI,KAAK,EAAE,CAC1D,CAAC;gBACF,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,CAAC;YACjG,CAAC;oBAAS,CAAC;gBACT,OAAO,CAAC,OAAO,EAAE,CAAC;YACpB,CAAC;QACH,CAAC;QAED,MAAM,sBAAsB,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;YACtD,KAAK,EAAE,WAAW;YAClB,QAAQ,EAAE,gBAAgB;YAC1B,KAAK,EAAE,GAAG,eAAe,CAAC,2BAA2B,IAAI,KAAK,EAAE;YAChE,iBAAiB,EAAE,CAAC;SACrB,CAAC,CAAC;QACH,MAAM,sBAAsB,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;YACtD,KAAK,EAAE,UAAU,CAAC,UAAU;YAC5B,QAAQ,EAAE,gBAAgB;YAC1B,KAAK,EAAE,GAAG,eAAe,CAAC,2BAA2B,IAAI,KAAK,EAAE;YAChE,iBAAiB,EAAE,CAAC;SACrB,CAAC,CAAC;QAEH,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,CAAC;IACjG,CAAC;IAED,KAAK,CAAC,wBAAwB,CAAC,MAO9B;QAIC,MAAM,EAAE,GAAG,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,SAAS,EAAE,GAC3G,MAAM,CAAC;QAET,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,GAAG,IAAI,CAAC,8BAA8B,CAAC,SAAS,CAAC,CAAC;QACtF,MAAM,KAAK,GAAG,GAAG,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,cAAc,EAAE,CAAC;QAEhE,MAAM,KAAK,GAAG,IAAA,wBAAY,EAAC,sBAAsB,CAAC,CAAC;QAEnD,MAAM,EAAE,WAAW,EAAE,aAAa,EAAE,GAAG,MAAM,IAAI,CAAC,sBAAsB,CACtE,iBAAiB,EACjB,sBAAsB,EACtB,gBAAgB,EAChB,KAAK,EACL,eAAe,CAAC,2BAA2B,CAC5C,CAAC;QACF,MAAM,UAAU,GAAkC;YAChD,UAAU,EAAE,aAAa,CAAC,KAAK,EAAE;YACjC,SAAS,EAAE,aAAa,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE;SAC5C,CAAC;QAEF,MAAM,eAAe,GAAG,SAAS,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC;QACpE,IAAA,gBAAM,EAAC,eAAe,EAAE,+CAA+C,CAAC,CAAC;QACzE,MAAM,iCAAiC,GAAG,IAAI,CAAC,KAAK,CAClD,eAAe,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CACf,CAAC;QACrC,IAAI,iCAAiC,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;YAC9D,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;QAChF,CAAC;QACD,MAAM,mCAAmC,GAAG,MAAM,IAAA,qDAAwC,EACxF,iCAAiC,EACjC,UAAU,EACV,WAAW,CACZ,CAAC;QAEF,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,sBAAsB,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC,CAAC;QAC9G,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,sBAAsB,EAAE,eAAe,CAAC,2BAA2B,CAAC,CAAC;QAE/F,MAAM,YAAY,GAAG,eAAM,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,IAAI,qBAAO,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC,EAAE,cAAc,EAAE,UAAU,CAAC,CAAC;QAChF,MAAM,UAAU,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;QAE3C,MAAM,oBAAoB,GAAG,uBAAS,CAAC,mBAAmB,CAAC,mCAAmC,CAAC,CAAC;QAChG,MAAM,yBAAyB,GAAG,UAAU,CAAC,sBAAsB,CAAC;YAClE,WAAW,EAAE,EAAE;YACf,iBAAiB,EAAE,oBAAoB,CAAC,iBAAiB;SAC1D,CAAC,CAAC;QACH,MAAM,yBAAyB,GAAG,UAAU,CAAC,sBAAsB,CAAC;YAClE,WAAW,EAAE,oBAAoB,CAAC,WAAW;YAC7C,iBAAiB,EAAE,EAAE;SACtB,CAAC,CAAC;QACH,MAAM,oBAAoB,GAAG,MAAM,IAAA,sCAAyB,EAC1D,yBAAyB,EACzB,yBAAyB,EACzB,UAAU,EACV,WAAW,CACZ,CAAC;QACF,MAAM,WAAW,GAAG,UAAU,CAAC,UAAU,EAAE,CAAC;QAE5C,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,uBAAuB,CAAC,gBAAgB,CAAC,CAAC;YAC9E,IAAI,CAAC;gBACH,MAAM,sBAAsB,GAAG,MAAM,UAAU,CAAC,OAAO,CACrD,WAAW,EACX,GAAG,eAAe,CAAC,2BAA2B,IAAI,KAAK,EAAE,CAC1D,CAAC;gBACF,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,CAAC;YAC1D,CAAC;oBAAS,CAAC;gBACT,UAAU,CAAC,OAAO,EAAE,CAAC;YACvB,CAAC;QACH,CAAC;QAED,MAAM,sBAAsB,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;YACtD,KAAK,EAAE,WAAW;YAClB,QAAQ,EAAE,gBAAgB;YAC1B,KAAK,EAAE,GAAG,eAAe,CAAC,2BAA2B,IAAI,KAAK,EAAE;YAChE,iBAAiB,EAAE,CAAC;SACrB,CAAC,CAAC;QAEH,OAAO;YACL,oBAAoB;YACpB,sBAAsB;SACvB,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,wBAAwB,CAAC,MAO9B;QAGC,MAAM,EAAE,GAAG,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,SAAS,EAAE,GAC3G,MAAM,CAAC;QAET,IAAA,gBAAM,EAAC,SAAS,CAAC,YAAY,IAAI,SAAS,CAAC,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,0CAA0C,CAAC,CAAC;QAClH,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,GAAG,IAAI,CAAC,8BAA8B,CAAC,SAAS,CAAC,CAAC;QACtF,MAAM,KAAK,GAAG,GAAG,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,cAAc,EAAE,CAAC;QAEhE,MAAM,EAAE,WAAW,EAAE,aAAa,EAAE,GAAG,MAAM,IAAI,CAAC,sBAAsB,CACtE,iBAAiB,EACjB,sBAAsB,EACtB,gBAAgB,EAChB,KAAK,EACL,eAAe,CAAC,2BAA2B,CAC5C,CAAC;QACF,MAAM,UAAU,GAAkC;YAChD,UAAU,EAAE,aAAa,CAAC,KAAK,EAAE;YACjC,SAAS,EAAE,aAAa,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE;SAC5C,CAAC;QAEF,MAAM,eAAe,GAAG,SAAS,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC;QACpE,IAAA,gBAAM,EAAC,eAAe,EAAE,+CAA+C,CAAC,CAAC;QACzE,MAAM,iCAAiC,GAAG,IAAI,CAAC,KAAK,CAClD,eAAe,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CACf,CAAC;QACrC,IAAI,iCAAiC,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;YAC9D,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;QAChF,CAAC;QACD,MAAM,mCAAmC,GAAG,MAAM,IAAA,qDAAwC,EACxF,iCAAiC,EACjC,UAAU,EACV,WAAW,CACZ,CAAC;QAEF,MAAM,qCAAqC,GAAG,uBAAS,CAAC,mBAAmB,CAAC;YAC1E,WAAW,EAAE,mCAAmC,CAAC,WAAW;YAC5D,iBAAiB,EAAE,EAAE;SACtB,CAAC,CAAC;QAEH,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,sBAAsB,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC,CAAC;QAC9G,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,sBAAsB,EAAE,eAAe,CAAC,2BAA2B,CAAC,CAAC;QAE/F,MAAM,YAAY,GAAG,eAAM,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,IAAI,qBAAO,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC,EAAE,cAAc,EAAE,UAAU,CAAC,CAAC;QAChF,MAAM,UAAU,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;QAE3C,MAAM,yBAAyB,GAAG,UAAU,CAAC,sBAAsB,CAAC;YAClE,WAAW,EAAE,qCAAqC,CAAC,WAAW;YAC9D,iBAAiB,EAAE,EAAE;SACtB,CAAC,CAAC;QAEH,MAAM,oBAAoB,GAAG,MAAM,IAAA,wCAA2B,EAAC,yBAAyB,EAAE,UAAU,EAAE,WAAW,CAAC,CAAC;QAEnH,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAClC,CAAC;;AAv6CH,0CAy6CC;AAx6CyB,2CAA2B,GAAG,6BAA6B,CAAC;AAC5D,2CAA2B,GAAG,6BAA6B,CAAC;AAC5D,2CAA2B,GAAG,6BAA6B,CAAC;AAw6CtF;;;;;;;GAOG;AACI,KAAK,UAAU,qBAAqB,CACzC,QAAgB,EAChB,gBAAoC,EACpC,KAAgB;IAEhB,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,gBAAgB,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;QACjF,MAAM,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACxC,OAAO,CACL,eAAe,CAAC,MAAM;YACtB,eAAe,CAAC,WAAW;YAC3B,CAAC,eAAe,CAAC,UAAU,IAAI,eAAe,CAAC,YAAY,CAAC,CAC7D,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACI,KAAK,UAAU,yBAAyB,CAC7C,gBAAwB,EACxB,kBAA0B,EAC1B,gBAAoC,EACpC,KAAgB;IAMhB,IAAI,MAAM,qBAAqB,CAAC,gBAAgB,EAAE,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC;QAC3E,OAAO,iCAAiC,CAAC,gBAAgB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,KAAK,CAAC,CAAC;IAC1G,CAAC;IACD,OAAO,uCAAuC,CAAC,gBAAgB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,KAAK,CAAC,CAAC;AAChH,CAAC;AAED;;;;;;;;;;GAUG;AACI,KAAK,UAAU,iBAAiB,CACrC,WAAmB,EACnB,YAAoB,EACpB,cAAsB,EACtB,cAAsB;IAOtB,MAAM,OAAO,GAAG,IAAI,qBAAO,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC;IACrE,MAAM,SAAS,GAAG,IAAI,qBAAO,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC;IAEzE,MAAM,eAAe,GAAG,uBAAS,CAAC,6BAA6B,CAC7D,WAAW,EACX,CAAC,MAAM,uBAAS,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,CAAC,CAAwC,EAChG,cAAc,EACd,KAAK,EACL,SAAS,EACT,KAAK,CACN,CAAC;IACF,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAE5C,OAAO;QACL,KAAK,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;QAChC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;QACd,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;QACd,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;KACf,CAAC;AACJ,CAAC;AAED,wBAAwB;AAExB;;;;;;GAMG;AACH,KAAK,UAAU,iCAAiC,CAC9C,oBAA4B,EAC5B,sBAA8B,EAC9B,gBAAoC,EACpC,KAAgB;IAMhB,MAAM,CAAC,eAAe,EAAE,iBAAiB,CAAC,GAAG,MAAM,8BAA8B,CAC/E,oBAAoB,EACpB,sBAAsB,EACtB,gBAAgB,EAChB,KAAK,CACN,CAAC;IACF,MAAM,aAAa,GAA2B;QAC5C,MAAM,EAAE,eAAe,CAAC,MAAM;KAC/B,CAAC;IACF,MAAM,aAAa,GAA2B;QAC5C,MAAM,EAAE,iBAAiB,CAAC,MAAM;KACjC,CAAC;IACF,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,MAAM,uBAAS,CAAC,qBAAqB,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IAE3F,MAAM,YAAY,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IACxC,MAAM,cAAc,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC;IAC5C,OAAO;QACL,YAAY;QACZ,cAAc;QACd,cAAc,EAAE,uBAAS,CAAC,iBAAiB,CAAC,cAAc,CAAC;KAC5D,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,KAAK,UAAU,uCAAuC,CACpD,qBAA6B,EAC7B,uBAA+B,EAC/B,gBAAoC,EACpC,KAAgB;IAMhB,MAAM,iBAAiB,GAAG,eAAM,CAAC,IAAI,CACnC,MAAM,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,gBAAgB,EAAE,KAAK,EAAE,qBAAqB,EAAE,CAAC,EACjF,QAAQ,CACT,CAAC;IACF,MAAM,mBAAmB,GAAG,eAAM,CAAC,IAAI,CACrC,MAAM,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,gBAAgB,EAAE,KAAK,EAAE,uBAAuB,EAAE,CAAC,EACnF,QAAQ,CACT,CAAC;IAEF,MAAM,WAAW,GAA8B,uBAAS,CAAC,yBAAyB,CAAC,iBAAiB,CAAC,CAAC;IACtG,MAAM,aAAa,GAA8B,uBAAS,CAAC,yBAAyB,CAAC,mBAAmB,CAAC,CAAC;IAC1G,MAAM,eAAe,GAA2B;QAC9C,MAAM,EAAE;YACN,CAAC,EAAE,eAAM,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;YAC/C,CAAC,EAAE,eAAM,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;YAC/C,SAAS,EAAE,eAAM,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;SAClE;QACD,MAAM,EAAE,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;KACtC,CAAC;IACF,MAAM,iBAAiB,GAA2B;QAChD,MAAM,EAAE;YACN,CAAC,EAAE,eAAM,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;YACjD,CAAC,EAAE,eAAM,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;YACjD,SAAS,EAAE,eAAM,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;SACpE;QACD,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;KACxC,CAAC;IACF,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,MAAM,uBAAS,CAAC,qBAAqB,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAAC;IACjG,MAAM,YAAY,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IACxC,MAAM,cAAc,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC;IAC5C,MAAM,cAAc,GAAG,uBAAS,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;IACjE,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC;AAC1D,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,8BAA8B,CAC3C,oBAA4B,EAC5B,sBAA8B,EAC9B,gBAAoC,EACpC,KAAgB;IAEhB,IAAI,SAAS,CAAC;IACd,IAAI,OAAO,CAAC;IACZ,IAAI,CAAC;QACH,SAAS,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,gBAAgB,EAAE,KAAK,EAAE,sBAAsB,EAAE,CAAC,CAAC;QAC/F,OAAO,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,gBAAgB,EAAE,KAAK,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAC7F,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IACpE,CAAC;IAED,MAAM,mBAAmB,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAqC,CAAC;IACpF,MAAM,qBAAqB,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAqC,CAAC;IAExF,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;IAC7D,CAAC;IAED,IAAI,CAAC,qBAAqB,CAAC,UAAU,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;IAC7D,CAAC;IAED,MAAM,GAAG,GAAG,IAAI,mBAAK,EAAE,CAAC;IAExB,MAAM,eAAe,GAAG,GAAG,CAAC,UAAU,CAAC,mBAAmB,CAAC,MAAM,EAAE;QACjE,mBAAmB,CAAC,WAAW;QAC/B,mBAAmB,CAAC,YAAY;KACjC,CAAC,CAAC;IACH,MAAM,iBAAiB,GAAG,GAAG,CAAC,UAAU,CAAC,qBAAqB,CAAC,MAAM,EAAE;QACrE,qBAAqB,CAAC,UAAU;QAChC,qBAAqB,CAAC,WAAW;KAClC,CAAC,CAAC;IACH,IACE,eAAe,CAAC,MAAM,CAAC,CAAC,KAAK,iBAAiB,CAAC,MAAM,CAAC,CAAC;QACvD,eAAe,CAAC,MAAM,CAAC,SAAS,KAAK,iBAAiB,CAAC,MAAM,CAAC,SAAS,EACvE,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;IACnD,CAAC;IACD,OAAO,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAAC;AAC9C,CAAC;AAED,aAAa","sourcesContent":["import { EncryptionVersion } from '../../../../api';\nimport { bigIntToBufferBE, DklsComms, DklsDkg, DklsDsg, DklsTypes, DklsUtils } from '@bitgo-beta/sdk-lib-mpc';\nimport assert from 'assert';\nimport { Buffer } from 'buffer';\nimport { Hash } from 'crypto';\nimport { NonEmptyString } from 'io-ts-types';\nimport createKeccakHash from 'keccak';\nimport * as pgp from 'openpgp';\nimport { KeychainsTriplet } from '../../../baseCoin';\nimport {\n  MPCv2BroadcastMessage,\n  MPCv2KeyGenRound1Response,\n  MPCv2KeyGenRound2Response,\n  MPCv2KeyGenRound3Response,\n  MPCv2KeyGenStateEnum,\n  MPCv2P2PMessage,\n  MPCv2PartyFromStringOrNumber,\n  MPCv2SignatureShareRound1Output,\n  MPCv2SignatureShareRound2Output,\n} from '@bitgo/public-types';\n\nimport { Ecdsa } from '../../../../account-lib';\nimport { AddKeychainOptions, Keychain, KeyType, WebauthnKeyEncryptionInfo } from '../../../keychain';\nimport { DecryptedRetrofitPayload } from '../../../keychain/iKeychains';\nimport { ECDSAMethodTypes, getTxRequest } from '../../../tss';\nimport { sendSignatureShareV2, sendTxRequest } from '../../../tss/common';\nimport { MPCv2PartiesEnum } from './typesMPCv2';\nimport {\n  getSignatureShareRoundOne,\n  getSignatureShareRoundThree,\n  getSignatureShareRoundTwo,\n  verifyBitGoMessagesAndSignaturesRoundOne,\n  verifyBitGoMessagesAndSignaturesRoundTwo,\n} from '../../../tss/ecdsa/ecdsaMPCv2';\nimport { KeyCombined } from '../../../tss/ecdsa/types';\nimport { generateGPGKeyPair } from '../../opengpgUtils';\nimport {\n  CustomMPCv2SigningRound1GeneratingFunction,\n  CustomMPCv2SigningRound2GeneratingFunction,\n  CustomMPCv2SigningRound3GeneratingFunction,\n  RequestType,\n  SignatureShareRecord,\n  TSSParams,\n  TSSParamsForMessage,\n  TSSParamsForMessageWithPrv,\n  TSSParamsWithPrv,\n  TssSignTxRequestParamsWithPrv,\n  TssTxRecipientSource,\n  TxRequest,\n  isV2Envelope,\n  SignableTransaction,\n} from '../baseTypes';\nimport { shouldUsePreHashedSignable } from '../preHashedSignable';\nimport { shouldVerifyWithSerializedTxHex } from '../serializedTxHexVerify';\nimport { BaseEcdsaUtils } from './base';\nimport { EcdsaMPCv2KeyGenSendFn, KeyGenSenderForEnterprise } from './ecdsaMPCv2KeyGenSender';\nimport { envRequiresBitgoPubGpgKeyConfig, isBitgoMpcPubKey } from '../../../tss/bitgoPubKeys';\nimport { InvalidTransactionError } from '../../../errors';\nimport { BitGoBase } from '../../../bitgoBase';\nimport { resolveEffectiveTxParams } from '../recipientUtils';\nimport type { EcdsaMPCv2KeyGenCallbacks } from '../../../wallet/iWallets';\n\nexport class EcdsaMPCv2Utils extends BaseEcdsaUtils {\n  private static readonly DKLS23_SIGNING_USER_GPG_KEY = 'DKLS23_SIGNING_USER_GPG_KEY';\n  private static readonly DKLS23_SIGNING_ROUND1_STATE = 'DKLS23_SIGNING_ROUND1_STATE';\n  private static readonly DKLS23_SIGNING_ROUND2_STATE = 'DKLS23_SIGNING_ROUND2_STATE';\n\n  /** @inheritdoc */\n  async createKeychains(params: {\n    passphrase: string;\n    enterprise: string;\n    originalPasscodeEncryptionCode?: string;\n    retrofit?: DecryptedRetrofitPayload;\n    webauthnInfo?: WebauthnKeyEncryptionInfo;\n    encryptionVersion?: EncryptionVersion;\n    // Wallet Safes v1 (@experimental): tags the resulting user/backup/bitgo root keys with this safe.\n    safeId?: string;\n  }): Promise<KeychainsTriplet> {\n    const { userSession, backupSession } = this.getUserAndBackupSession(2, 3, params.retrofit);\n    const userGpgKey = await generateGPGKeyPair('secp256k1');\n    const backupGpgKey = await generateGPGKeyPair('secp256k1');\n\n    // Get the BitGo public key based on user/enterprise feature flags\n    // If it doesn't work, use the default public key from the constants\n    const { mpcv2PublicKey } = await this.getBitgoGpgPubkeyBasedOnFeatureFlags(params.enterprise, true);\n    const mpcv2Key = mpcv2PublicKey ?? this.bitgoMPCv2PublicGpgKey;\n    assert(mpcv2Key, 'Failed to get BitGo MPCv2 GPG public key');\n    const bitgoPublicGpgKey = mpcv2Key.armor();\n\n    if (envRequiresBitgoPubGpgKeyConfig(this.bitgo.getEnv())) {\n      // Ensure the public key is one of the expected BitGo public keys when in test or prod.\n      assert(isBitgoMpcPubKey(bitgoPublicGpgKey, 'mpcv2'), 'Invalid BitGo GPG public key');\n    }\n\n    const userGpgPrvKey: DklsTypes.PartyGpgKey = {\n      partyId: MPCv2PartiesEnum.USER,\n      gpgKey: userGpgKey.privateKey,\n    };\n    const backupGpgPrvKey: DklsTypes.PartyGpgKey = {\n      partyId: MPCv2PartiesEnum.BACKUP,\n      gpgKey: backupGpgKey.privateKey,\n    };\n    const bitgoGpgPubKey: DklsTypes.PartyGpgKey = {\n      partyId: MPCv2PartiesEnum.BITGO,\n      gpgKey: bitgoPublicGpgKey,\n    };\n\n    // #region round 1\n    const userRound1BroadcastMsg = await userSession.initDkg();\n    const backupRound1BroadcastMsg = await backupSession.initDkg();\n\n    const round1SerializedMessages = DklsTypes.serializeMessages({\n      broadcastMessages: [userRound1BroadcastMsg, backupRound1BroadcastMsg],\n      p2pMessages: [],\n    });\n    const round1Messages = await DklsComms.encryptAndAuthOutgoingMessages(\n      round1SerializedMessages,\n      [bitgoGpgPubKey],\n      [userGpgPrvKey, backupGpgPrvKey]\n    );\n\n    const { sessionId, bitgoMsg1, bitgoToBackupMsg2, bitgoToUserMsg2 } = await this.sendKeyGenerationRound1(\n      params.enterprise,\n      userGpgKey.publicKey,\n      backupGpgKey.publicKey,\n      params.retrofit?.walletId\n        ? {\n            ...round1Messages,\n            walletId: params.retrofit.walletId,\n          }\n        : round1Messages,\n      params.safeId\n    );\n    // #endregion\n\n    // #region round 2\n    const bitgoRound1BroadcastMessages = await DklsComms.decryptAndVerifyIncomingMessages(\n      { p2pMessages: [], broadcastMessages: [this.formatBitgoBroadcastMessage(bitgoMsg1)] },\n      [bitgoGpgPubKey],\n      [userGpgPrvKey, backupGpgPrvKey]\n    );\n    const bitgoRound1BroadcastMsg = bitgoRound1BroadcastMessages.broadcastMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BITGO\n    );\n    assert(bitgoRound1BroadcastMsg, 'BitGo message 1 not found in broadcast messages');\n\n    const userRound2P2PMessages = userSession.handleIncomingMessages({\n      p2pMessages: [],\n      broadcastMessages: [DklsTypes.deserializeBroadcastMessage(bitgoRound1BroadcastMsg), backupRound1BroadcastMsg],\n    });\n\n    const userToBitgoMsg2 = userRound2P2PMessages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.USER && m.to === MPCv2PartiesEnum.BITGO\n    );\n    assert(userToBitgoMsg2, 'User message 2 not found in P2P messages');\n    const serializedUserToBitgoMsg2 = DklsTypes.serializeP2PMessage(userToBitgoMsg2);\n\n    const backupRound2P2PMessages = backupSession.handleIncomingMessages({\n      p2pMessages: [],\n      broadcastMessages: [userRound1BroadcastMsg, DklsTypes.deserializeBroadcastMessage(bitgoRound1BroadcastMsg)],\n    });\n    const serializedBackupToBitgoMsg2 = DklsTypes.serializeMessages(backupRound2P2PMessages).p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BACKUP && m.to === MPCv2PartiesEnum.BITGO\n    );\n    assert(serializedBackupToBitgoMsg2, 'Backup message 2 not found in P2P messages');\n\n    const round2Messages = await DklsComms.encryptAndAuthOutgoingMessages(\n      { p2pMessages: [serializedUserToBitgoMsg2, serializedBackupToBitgoMsg2], broadcastMessages: [] },\n      [bitgoGpgPubKey],\n      [userGpgPrvKey, backupGpgPrvKey]\n    );\n\n    const {\n      sessionId: sessionIdRound2,\n      bitgoCommitment2,\n      bitgoToUserMsg3,\n      bitgoToBackupMsg3,\n    } = await this.sendKeyGenerationRound2(params.enterprise, sessionId, round2Messages);\n    // #endregion\n\n    // #region round 3\n    assert.equal(sessionId, sessionIdRound2, 'Round 1 and 2 Session IDs do not match');\n    const decryptedBitgoToUserRound2Msgs = await DklsComms.decryptAndVerifyIncomingMessages(\n      { p2pMessages: [this.formatP2PMessage(bitgoToUserMsg2)], broadcastMessages: [] },\n      [bitgoGpgPubKey],\n      [userGpgPrvKey]\n    );\n    const serializedBitgoToUserRound2Msg = decryptedBitgoToUserRound2Msgs.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BITGO && m.to === MPCv2PartiesEnum.USER\n    );\n    assert(serializedBitgoToUserRound2Msg, 'BitGo to User message 2 not found in P2P messages');\n    const bitgoToUserRound2Msg = DklsTypes.deserializeP2PMessage(serializedBitgoToUserRound2Msg);\n\n    const decryptedBitgoToBackupRound2Msg = await DklsComms.decryptAndVerifyIncomingMessages(\n      { p2pMessages: [this.formatP2PMessage(bitgoToBackupMsg2)], broadcastMessages: [] },\n      [bitgoGpgPubKey],\n      [backupGpgPrvKey]\n    );\n    const serializedBitgoToBackupRound2Msg = decryptedBitgoToBackupRound2Msg.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BITGO && m.to === MPCv2PartiesEnum.BACKUP\n    );\n    assert(serializedBitgoToBackupRound2Msg, 'BitGo to Backup message 2 not found in P2P messages');\n    const bitgoToBackupRound2Msg = DklsTypes.deserializeP2PMessage(serializedBitgoToBackupRound2Msg);\n\n    const userToBackupMsg2 = userRound2P2PMessages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.USER && m.to === MPCv2PartiesEnum.BACKUP\n    );\n    assert(userToBackupMsg2, 'User to Backup message 2 not found in P2P messages');\n\n    const backupToUserMsg2 = backupRound2P2PMessages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BACKUP && m.to === MPCv2PartiesEnum.USER\n    );\n    assert(backupToUserMsg2, 'Backup to User message 2 not found in P2P messages');\n\n    const userRound3Messages = userSession.handleIncomingMessages({\n      broadcastMessages: [],\n      p2pMessages: [bitgoToUserRound2Msg, backupToUserMsg2],\n    });\n    const userToBackupMsg3 = userRound3Messages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.USER && m.to === MPCv2PartiesEnum.BACKUP\n    );\n    assert(userToBackupMsg3, 'User to Backup message 3 not found in P2P messages');\n    const userToBitgoMsg3 = userRound3Messages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.USER && m.to === MPCv2PartiesEnum.BITGO\n    );\n    assert(userToBitgoMsg3, 'User to Bitgo message 3 not found in P2P messages');\n    const serializedUserToBitgoMsg3 = DklsTypes.serializeP2PMessage(userToBitgoMsg3);\n\n    const backupRound3Messages = backupSession.handleIncomingMessages({\n      broadcastMessages: [],\n      p2pMessages: [bitgoToBackupRound2Msg, userToBackupMsg2],\n    });\n\n    const backupToUserMsg3 = backupRound3Messages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BACKUP && m.to === MPCv2PartiesEnum.USER\n    );\n    assert(backupToUserMsg3, 'Backup to User message 3 not found in P2P messages');\n    const backupToBitgoMsg3 = backupRound3Messages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BACKUP && m.to === MPCv2PartiesEnum.BITGO\n    );\n    assert(backupToBitgoMsg3, 'Backup to Bitgo message 3 not found in P2P messages');\n    const serializedBackupToBitgoMsg3 = DklsTypes.serializeP2PMessage(backupToBitgoMsg3);\n\n    const decryptedBitgoToUserRound3Messages = await DklsComms.decryptAndVerifyIncomingMessages(\n      { broadcastMessages: [], p2pMessages: [this.formatP2PMessage(bitgoToUserMsg3, bitgoCommitment2)] },\n      [bitgoGpgPubKey],\n      [userGpgPrvKey]\n    );\n    const serializedBitgoToUserRound3Msg = decryptedBitgoToUserRound3Messages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BITGO && m.to === MPCv2PartiesEnum.USER\n    );\n    assert(serializedBitgoToUserRound3Msg, 'BitGo to User message 3 not found in P2P messages');\n    const bitgoToUserRound3Msg = DklsTypes.deserializeP2PMessage(serializedBitgoToUserRound3Msg);\n\n    const decryptedBitgoToBackupRound3Messages = await DklsComms.decryptAndVerifyIncomingMessages(\n      { broadcastMessages: [], p2pMessages: [this.formatP2PMessage(bitgoToBackupMsg3, bitgoCommitment2)] },\n      [bitgoGpgPubKey],\n      [backupGpgPrvKey]\n    );\n    const serializedBitgoToBackupRound3Msg = decryptedBitgoToBackupRound3Messages.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BITGO && m.to === MPCv2PartiesEnum.BACKUP\n    );\n    assert(serializedBitgoToBackupRound3Msg, 'BitGo to Backup message 3 not found in P2P messages');\n    const bitgoToBackupRound3Msg = DklsTypes.deserializeP2PMessage(serializedBitgoToBackupRound3Msg);\n\n    const userRound4Messages = userSession.handleIncomingMessages({\n      p2pMessages: [backupToUserMsg3, bitgoToUserRound3Msg],\n      broadcastMessages: [],\n    });\n\n    const userRound4BroadcastMsg = userRound4Messages.broadcastMessages.find((m) => m.from === MPCv2PartiesEnum.USER);\n    assert(userRound4BroadcastMsg, 'User message 4 not found in broadcast messages');\n    const serializedUserRound4BroadcastMsg = DklsTypes.serializeBroadcastMessage(userRound4BroadcastMsg);\n\n    const backupRound4Messages = backupSession.handleIncomingMessages({\n      p2pMessages: [userToBackupMsg3, bitgoToBackupRound3Msg],\n      broadcastMessages: [],\n    });\n    const backupRound4BroadcastMsg = backupRound4Messages.broadcastMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BACKUP\n    );\n    assert(backupRound4BroadcastMsg, 'Backup message 4 not found in broadcast messages');\n    const serializedBackupRound4BroadcastMsg = DklsTypes.serializeBroadcastMessage(backupRound4BroadcastMsg);\n\n    const round3Messages = await DklsComms.encryptAndAuthOutgoingMessages(\n      {\n        p2pMessages: [serializedUserToBitgoMsg3, serializedBackupToBitgoMsg3],\n        broadcastMessages: [serializedUserRound4BroadcastMsg, serializedBackupRound4BroadcastMsg],\n      },\n      [bitgoGpgPubKey],\n      [userGpgPrvKey, backupGpgPrvKey]\n    );\n\n    const {\n      sessionId: sessionIdRound3,\n      bitgoMsg4,\n      commonKeychain: bitgoCommonKeychain,\n    } = await this.sendKeyGenerationRound3(params.enterprise, sessionId, round3Messages);\n\n    // #endregion\n\n    // #region keychain creation\n    assert.equal(sessionId, sessionIdRound3, 'Round 1 and 3 Session IDs do not match');\n    const bitgoRound4BroadcastMessages = DklsTypes.deserializeMessages(\n      await DklsComms.decryptAndVerifyIncomingMessages(\n        { p2pMessages: [], broadcastMessages: [this.formatBitgoBroadcastMessage(bitgoMsg4)] },\n        [bitgoGpgPubKey],\n        []\n      )\n    ).broadcastMessages;\n    const bitgoRound4BroadcastMsg = bitgoRound4BroadcastMessages.find((m) => m.from === MPCv2PartiesEnum.BITGO);\n\n    assert(bitgoRound4BroadcastMsg, 'BitGo message 4 not found in broadcast messages');\n    userSession.handleIncomingMessages({\n      p2pMessages: [],\n      broadcastMessages: [bitgoRound4BroadcastMsg, backupRound4BroadcastMsg],\n    });\n\n    backupSession.handleIncomingMessages({\n      p2pMessages: [],\n      broadcastMessages: [bitgoRound4BroadcastMsg, userRound4BroadcastMsg],\n    });\n\n    const userPrivateMaterial = userSession.getKeyShare();\n    const backupPrivateMaterial = backupSession.getKeyShare();\n    const userReducedPrivateMaterial = userSession.getReducedKeyShare();\n    const backupReducedPrivateMaterial = backupSession.getReducedKeyShare();\n\n    const userCommonKeychain = DklsTypes.getCommonKeychain(userPrivateMaterial);\n    const backupCommonKeychain = DklsTypes.getCommonKeychain(backupPrivateMaterial);\n\n    assert.equal(bitgoCommonKeychain, userCommonKeychain, 'User and Bitgo Common keychains do not match');\n    assert.equal(bitgoCommonKeychain, backupCommonKeychain, 'Backup and Bitgo Common keychains do not match');\n\n    const encryptionSession =\n      params.encryptionVersion === 2 ? await this.bitgo.createEncryptionSession(params.passphrase) : undefined;\n    try {\n      const userKeychainPromise = this.addUserKeychain(\n        bitgoCommonKeychain,\n        userPrivateMaterial,\n        userReducedPrivateMaterial,\n        params.passphrase,\n        params.originalPasscodeEncryptionCode,\n        params.webauthnInfo,\n        encryptionSession,\n        params.encryptionVersion,\n        params.enterprise,\n        params.safeId\n      );\n      const backupKeychainPromise = this.addBackupKeychain(\n        bitgoCommonKeychain,\n        backupPrivateMaterial,\n        backupReducedPrivateMaterial,\n        params.passphrase,\n        params.originalPasscodeEncryptionCode,\n        encryptionSession,\n        params.encryptionVersion,\n        params.safeId\n      );\n      const bitgoKeychainPromise = this.addBitgoKeychain(bitgoCommonKeychain, params.safeId);\n\n      const [userKeychain, backupKeychain, bitgoKeychain] = await Promise.all([\n        userKeychainPromise,\n        backupKeychainPromise,\n        bitgoKeychainPromise,\n      ]);\n      // #endregion\n\n      return {\n        userKeychain,\n        backupKeychain,\n        bitgoKeychain,\n      };\n    } finally {\n      encryptionSession?.destroy();\n    }\n  }\n\n  // #region keychain utils\n  async createParticipantKeychain(\n    participantIndex: MPCv2PartyFromStringOrNumber,\n    commonKeychain: string,\n    privateMaterial?: Buffer,\n    reducedPrivateMaterial?: Buffer,\n    passphrase?: string,\n    originalPasscodeEncryptionCode?: string,\n    webauthnInfo?: WebauthnKeyEncryptionInfo,\n    encryptionSession?: {\n      encrypt(plaintext: string): Promise<string>;\n      decrypt(ciphertext: string): Promise<string>;\n      destroy(): void;\n    },\n    encryptionVersion?: EncryptionVersion,\n    enterprise?: string,\n    safeId?: string\n  ): Promise<Keychain> {\n    let source: string;\n    let encryptedPrv: string | undefined = undefined;\n    let reducedEncryptedPrv: string | undefined = undefined;\n    let privateMaterialBase64: string | undefined = undefined;\n    switch (participantIndex) {\n      case MPCv2PartiesEnum.USER:\n      case MPCv2PartiesEnum.BACKUP:\n        source = participantIndex === MPCv2PartiesEnum.USER ? 'user' : 'backup';\n        assert(privateMaterial, `Private material is required for ${source} keychain`);\n        assert(reducedPrivateMaterial, `Reduced private material is required for ${source} keychain`);\n        assert(passphrase, `Passphrase is required for ${source} keychain`);\n        privateMaterialBase64 = privateMaterial.toString('base64');\n        if (encryptionSession) {\n          encryptedPrv = await encryptionSession.encrypt(privateMaterialBase64);\n          reducedEncryptedPrv = await encryptionSession.encrypt(\n            btoa(String.fromCharCode.apply(null, Array.from(new Uint8Array(reducedPrivateMaterial))))\n          );\n        } else {\n          encryptedPrv = await this.bitgo.encrypt({\n            input: privateMaterialBase64,\n            password: passphrase,\n            encryptionVersion,\n          });\n          // Encrypts the CBOR-encoded ReducedKeyShare (which contains the party's private\n          // scalar s_i) with the wallet passphrase. The result is stored as reducedEncryptedPrv\n          // on the key card QR code and represents a second copy of private key material\n          // beyond the server-stored encryptedPrv.\n          reducedEncryptedPrv = await this.bitgo.encrypt({\n            // Buffer.toString('base64') can not be used here as it does not work on the browser.\n            // The browser deals with a Buffer as Uint8Array, therefore in the browser .toString('base64') just creates a comma seperated string of the array values.\n            input: btoa(String.fromCharCode.apply(null, Array.from(new Uint8Array(reducedPrivateMaterial)))),\n            password: passphrase,\n            encryptionVersion,\n          });\n        }\n        break;\n      case MPCv2PartiesEnum.BITGO:\n        source = 'bitgo';\n        break;\n      default:\n        throw new Error('Invalid participant index');\n    }\n\n    const recipientKeychainParams: AddKeychainOptions = {\n      source,\n      keyType: 'tss' as KeyType,\n      commonKeychain,\n      encryptedPrv,\n      originalPasscodeEncryptionCode,\n      isMPCv2: true,\n      safeId,\n    };\n\n    if (webauthnInfo && participantIndex === MPCv2PartiesEnum.USER && privateMaterialBase64) {\n      // Send the passkey as `webauthnInfo`; the deprecated `webauthnDevices` array is ignored by POST /key.\n      assert(enterprise, 'enterprise is required to attach a webauthn device to the user keychain');\n      recipientKeychainParams.webauthnInfo = {\n        otpDeviceId: webauthnInfo.otpDeviceId,\n        prfSalt: webauthnInfo.prfSalt,\n        encryptedPrv: await this.bitgo.encrypt({\n          input: privateMaterialBase64,\n          password: webauthnInfo.passphrase,\n          encryptionVersion,\n        }),\n        enterpriseId: enterprise,\n      };\n    }\n\n    const keychains = this.baseCoin.keychains();\n    return { ...(await keychains.add(recipientKeychainParams)), reducedEncryptedPrv: reducedEncryptedPrv };\n  }\n\n  /**\n   * Converts a User or Backup MPCv1 SigningMaterial to RetrofitData needed by MPCv2 DKG.\n   *\n   * @param decryptedKeyshare - MPCv1 decrypted signing material for user or backup as a json.stringify string and bitgo's Big Si.\n   * @param partyId - The party ID of the MPCv1 keyshare.\n   * @returns The retrofit data needed to start an MPCv2 DKG session.\n   * @deprecated\n   */\n  static getKeyDataForRetrofit(\n    decryptedKeyshare: string,\n    partyId: MPCv2PartiesEnum.BACKUP | MPCv2PartiesEnum.USER\n  ): DklsTypes.RetrofitData {\n    const mpc = new Ecdsa();\n    const xiList = [\n      Array.from(bigIntToBufferBE(BigInt(1), 32)),\n      Array.from(bigIntToBufferBE(BigInt(2), 32)),\n      Array.from(bigIntToBufferBE(BigInt(3), 32)),\n    ];\n    return EcdsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key({\n      mpcv1PartyKeyShare: decryptedKeyshare,\n      mpcv1PartyIndex: partyId === MPCv2PartiesEnum.USER ? 1 : 2,\n      xiList,\n      mpc,\n    });\n  }\n\n  /**\n   * Converts user and backup MPCv1 SigningMaterial to RetrofitData needed by MPCv2 DKG.\n   *\n   * @param {Object} params - MPCv1 decrypted signing material for user and backup as a json.stringify string and bitgo's Big Si.\n   * @returns {{ mpcv2UserKeyShare: DklsTypes.RetrofitData; mpcv2BakcupKeyShare: DklsTypes.RetrofitData }} - the retrofit data needed to start an MPCv2 DKG session.\n   */\n  getMpcV2RetrofitDataFromMpcV1Keys(params: { mpcv1UserKeyShare: string; mpcv1BackupKeyShare: string }): {\n    mpcv2UserKeyShare: DklsTypes.RetrofitData;\n    mpcv2BackupKeyShare: DklsTypes.RetrofitData;\n  } {\n    const mpc = new Ecdsa();\n    const xiList = [\n      Array.from(bigIntToBufferBE(BigInt(1), 32)),\n      Array.from(bigIntToBufferBE(BigInt(2), 32)),\n      Array.from(bigIntToBufferBE(BigInt(3), 32)),\n    ];\n    return {\n      mpcv2UserKeyShare: EcdsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key({\n        mpcv1PartyKeyShare: params.mpcv1UserKeyShare,\n        mpcv1PartyIndex: 1,\n        xiList,\n        mpc,\n      }),\n      mpcv2BackupKeyShare: EcdsaMPCv2Utils.getMpcV2RetrofitDataFromMpcV1Key({\n        mpcv1PartyKeyShare: params.mpcv1BackupKeyShare,\n        mpcv1PartyIndex: 2,\n        xiList,\n        mpc,\n      }),\n    };\n  }\n\n  /**\n   * Get retrofit data from MPCv1 key share.\n   * @param mpcv1PartyKeyShare\n   * @param mpcv1PartyIndex\n   * @param xiList\n   * @param mpc\n   * @deprecated\n   */\n  static getMpcV2RetrofitDataFromMpcV1Key({\n    mpcv1PartyKeyShare,\n    mpcv1PartyIndex,\n    xiList,\n    mpc,\n  }: {\n    mpcv1PartyKeyShare: string;\n    mpcv1PartyIndex: number;\n    xiList: number[][];\n    mpc: Ecdsa;\n  }): DklsTypes.RetrofitData {\n    const signingMaterial: ECDSAMethodTypes.SigningMaterial = JSON.parse(mpcv1PartyKeyShare);\n    let keyCombined: KeyCombined | undefined = undefined;\n    switch (mpcv1PartyIndex) {\n      case 1:\n        assert(signingMaterial.backupNShare, 'User MPCv1 key material should have backup NShare.');\n        assert(signingMaterial.bitgoNShare, 'BitGo MPCv1 key material should have user NShare.');\n        keyCombined = mpc.keyCombine(signingMaterial.pShare, [\n          signingMaterial.backupNShare,\n          signingMaterial.bitgoNShare,\n        ]);\n        break;\n      case 2:\n        assert(signingMaterial.userNShare, 'User MPCv1 key material should have backup NShare.');\n        assert(signingMaterial.bitgoNShare, 'BitGo MPCv1 key material should have user NShare.');\n        keyCombined = mpc.keyCombine(signingMaterial.pShare, [signingMaterial.userNShare, signingMaterial.bitgoNShare]);\n        break;\n      case 3:\n        assert(signingMaterial.userNShare, 'User MPCv1 key material should have backup NShare.');\n        assert(signingMaterial.backupNShare, 'Backup MPCv1 key material should have user NShare.');\n        keyCombined = mpc.keyCombine(signingMaterial.pShare, [\n          signingMaterial.userNShare,\n          signingMaterial.backupNShare,\n        ]);\n        break;\n      default:\n        throw new Error('Invalid participant index');\n    }\n    return {\n      xShare: keyCombined.xShare,\n      xiList: xiList,\n    };\n  }\n\n  private async addUserKeychain(\n    commonKeychain: string,\n    privateMaterial: Buffer,\n    reducedPrivateMaterial: Buffer,\n    passphrase: string,\n    originalPasscodeEncryptionCode?: string,\n    webauthnInfo?: WebauthnKeyEncryptionInfo,\n    encryptionSession?: {\n      encrypt(plaintext: string): Promise<string>;\n      decrypt(ciphertext: string): Promise<string>;\n      destroy(): void;\n    },\n    encryptionVersion?: EncryptionVersion,\n    enterprise?: string,\n    safeId?: string\n  ): Promise<Keychain> {\n    return this.createParticipantKeychain(\n      MPCv2PartiesEnum.USER,\n      commonKeychain,\n      privateMaterial,\n      reducedPrivateMaterial,\n      passphrase,\n      originalPasscodeEncryptionCode,\n      webauthnInfo,\n      encryptionSession,\n      encryptionVersion,\n      enterprise,\n      safeId\n    );\n  }\n\n  private async addBackupKeychain(\n    commonKeychain: string,\n    privateMaterial: Buffer,\n    reducedPrivateMaterial: Buffer,\n    passphrase: string,\n    originalPasscodeEncryptionCode?: string,\n    encryptionSession?: {\n      encrypt(plaintext: string): Promise<string>;\n      decrypt(ciphertext: string): Promise<string>;\n      destroy(): void;\n    },\n    encryptionVersion?: EncryptionVersion,\n    safeId?: string\n  ): Promise<Keychain> {\n    return this.createParticipantKeychain(\n      MPCv2PartiesEnum.BACKUP,\n      commonKeychain,\n      privateMaterial,\n      reducedPrivateMaterial,\n      passphrase,\n      originalPasscodeEncryptionCode,\n      undefined,\n      encryptionSession,\n      encryptionVersion,\n      undefined,\n      safeId\n    );\n  }\n\n  private getUserAndBackupSession(m: number, n: number, retrofit?: DecryptedRetrofitPayload) {\n    if (retrofit) {\n      const retrofitData = this.getMpcV2RetrofitDataFromMpcV1Keys({\n        mpcv1UserKeyShare: retrofit.decryptedUserKey,\n        mpcv1BackupKeyShare: retrofit.decryptedBackupKey,\n      });\n\n      const userSession = new DklsDkg.Dkg(n, m, MPCv2PartiesEnum.USER, undefined, retrofitData.mpcv2UserKeyShare);\n      const backupSession = new DklsDkg.Dkg(n, m, MPCv2PartiesEnum.BACKUP, undefined, retrofitData.mpcv2BackupKeyShare);\n\n      return { userSession, backupSession };\n    }\n\n    const userSession = new DklsDkg.Dkg(n, m, MPCv2PartiesEnum.USER);\n    const backupSession = new DklsDkg.Dkg(n, m, MPCv2PartiesEnum.BACKUP);\n\n    return { userSession, backupSession };\n  }\n\n  private async addBitgoKeychain(commonKeychain: string, safeId?: string): Promise<Keychain> {\n    return this.createParticipantKeychain(\n      MPCv2PartiesEnum.BITGO,\n      commonKeychain,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      safeId\n    );\n  }\n  // #endregion\n\n  /**\n   * Creates ECDSA MPCv2 keychains using external signer callbacks instead of a passphrase.\n   * The external signer holds all private key material; the SDK only coordinates the DKG protocol.\n   */\n  async createKeychainsWithExternalSigner(params: {\n    enterprise: string;\n    callbacks: EcdsaMPCv2KeyGenCallbacks;\n  }): Promise<KeychainsTriplet> {\n    const { enterprise, callbacks } = params;\n    const { mpcv2PublicKey } = await this.getBitgoGpgPubkeyBasedOnFeatureFlags(enterprise, true);\n    const mpcv2Key = mpcv2PublicKey ?? this.bitgoMPCv2PublicGpgKey;\n    assert(mpcv2Key, 'Failed to get BitGo MPCv2 GPG public key');\n    const bitgoPublicGpgKey = mpcv2Key.armor();\n\n    if (envRequiresBitgoPubGpgKeyConfig(this.bitgo.getEnv())) {\n      assert(isBitgoMpcPubKey(bitgoPublicGpgKey, 'mpcv2'), 'Invalid BitGo GPG public key');\n    }\n\n    // Round 1: external signer generates GPG keys and initial DKG messages\n    const { userGpgPublicKey, backupGpgPublicKey, round1Messages, userState, backupState } =\n      await callbacks.initializeCallback({\n        enterprise,\n        bitgoPublicGpgKey,\n      });\n\n    const { sessionId, bitgoMsg1, bitgoToUserMsg2, bitgoToBackupMsg2 } = await this.sendKeyGenerationRound1(\n      enterprise,\n      userGpgPublicKey,\n      backupGpgPublicKey,\n      round1Messages\n    );\n\n    // Round 2: external signer processes BitGo's round 1 response\n    const {\n      round2Messages,\n      userState: userStateAfter2,\n      backupState: backupStateAfter2,\n    } = await callbacks.round2Callback({\n      sessionId,\n      bitgoMsg1,\n      bitgoToUserMsg2,\n      bitgoToBackupMsg2,\n      userState,\n      backupState,\n    });\n\n    const round2Response = await this.sendKeyGenerationRound2(enterprise, sessionId, round2Messages);\n    assert.strictEqual(round2Response.sessionId, sessionId, 'Session ID mismatch after round 2');\n\n    // Round 3: external signer processes BitGo's round 2 response\n    const {\n      round3Messages,\n      userState: userStateAfter3,\n      backupState: backupStateAfter3,\n    } = await callbacks.round3Callback({\n      sessionId,\n      bitgoCommitment2: round2Response.bitgoCommitment2,\n      bitgoToUserMsg3: round2Response.bitgoToUserMsg3,\n      bitgoToBackupMsg3: round2Response.bitgoToBackupMsg3,\n      userState: userStateAfter2,\n      backupState: backupStateAfter2,\n    });\n\n    const round3Response = await this.sendKeyGenerationRound3(enterprise, sessionId, round3Messages);\n    assert.strictEqual(round3Response.sessionId, sessionId, 'Session ID mismatch after round 3');\n\n    // Finalize: external signer verifies BitGo's final message against the derived common keychain\n    const { commonKeychain } = await callbacks.finalizeCallback({\n      sessionId,\n      bitgoMsg4: round3Response.bitgoMsg4,\n      bitgoCommonKeychain: round3Response.commonKeychain,\n      userState: userStateAfter3,\n      backupState: backupStateAfter3,\n    });\n    assert.strictEqual(commonKeychain, round3Response.commonKeychain, 'Common keychains do not match');\n\n    const keychains = this.baseCoin.keychains();\n    const [userKeychain, backupKeychain, bitgoKeychain] = await Promise.all([\n      keychains.add({ source: 'user', keyType: 'tss', commonKeychain, isMPCv2: true }),\n      keychains.add({ source: 'backup', keyType: 'tss', commonKeychain, isMPCv2: true }),\n      this.addBitgoKeychain(commonKeychain),\n    ]);\n\n    return { userKeychain, backupKeychain, bitgoKeychain };\n  }\n\n  async sendKeyGenerationRound1(\n    enterprise: string,\n    userGpgPublicKey: string,\n    backupGpgPublicKey: string,\n    payload: DklsTypes.AuthEncMessages & { walletId?: string },\n    safeId?: string\n  ): Promise<MPCv2KeyGenRound1Response> {\n    return this.sendKeyGenerationRound1BySender(\n      KeyGenSenderForEnterprise(this.bitgo, enterprise, safeId),\n      userGpgPublicKey,\n      backupGpgPublicKey,\n      payload\n    );\n  }\n\n  async sendKeyGenerationRound2(\n    enterprise: string,\n    sessionId: string,\n    payload: DklsTypes.AuthEncMessages\n  ): Promise<MPCv2KeyGenRound2Response> {\n    return this.sendKeyGenerationRound2BySender(KeyGenSenderForEnterprise(this.bitgo, enterprise), sessionId, payload);\n  }\n\n  async sendKeyGenerationRound3(\n    enterprise: string,\n    sessionId: string,\n    payload: DklsTypes.AuthEncMessages\n  ): Promise<MPCv2KeyGenRound3Response> {\n    return this.sendKeyGenerationRound3BySender(KeyGenSenderForEnterprise(this.bitgo, enterprise), sessionId, payload);\n  }\n\n  async sendKeyGenerationRound1BySender(\n    senderFn: EcdsaMPCv2KeyGenSendFn<MPCv2KeyGenRound1Response>,\n    userGpgPublicKey: string,\n    backupGpgPublicKey: string,\n    payload: DklsTypes.AuthEncMessages & { walletId?: string }\n  ): Promise<MPCv2KeyGenRound1Response> {\n    assert(NonEmptyString.is(userGpgPublicKey), 'User GPG public key is required');\n    assert(NonEmptyString.is(backupGpgPublicKey), 'Backup GPG public key is required');\n    const userMsg1 = payload.broadcastMessages.find((m) => m.from === MPCv2PartiesEnum.USER)?.payload;\n    assert(userMsg1, 'User message 1 not found in broadcast messages');\n    const backupMsg1 = payload.broadcastMessages.find((m) => m.from === MPCv2PartiesEnum.BACKUP)?.payload;\n    assert(backupMsg1, 'Backup message 1 not found in broadcast messages');\n\n    return senderFn(MPCv2KeyGenStateEnum['MPCv2-R1'], {\n      userGpgPublicKey,\n      backupGpgPublicKey,\n      userMsg1: { from: 0, ...userMsg1 },\n      backupMsg1: { from: 1, ...backupMsg1 },\n      walletId: payload.walletId,\n    });\n  }\n\n  async sendKeyGenerationRound2BySender(\n    senderFn: EcdsaMPCv2KeyGenSendFn<MPCv2KeyGenRound2Response>,\n    sessionId: string,\n    payload: DklsTypes.AuthEncMessages\n  ): Promise<MPCv2KeyGenRound2Response> {\n    assert(NonEmptyString.is(sessionId), 'Session ID is required');\n    const userMsg2 = payload.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.USER && m.to === MPCv2PartiesEnum.BITGO\n    );\n    assert(userMsg2, 'User to Bitgo message 2 not found in P2P messages');\n    assert(userMsg2.commitment, 'User to Bitgo commitment not found in P2P messages');\n    assert(NonEmptyString.is(userMsg2.commitment), 'User to Bitgo commitment is required');\n    const backupMsg2 = payload.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BACKUP && m.to === MPCv2PartiesEnum.BITGO\n    );\n    assert(backupMsg2, 'Backup to Bitgo message 2 not found in P2P messages');\n    assert(backupMsg2.commitment, 'Backup to Bitgo commitment not found in P2P messages');\n    assert(NonEmptyString.is(backupMsg2.commitment), 'Backup to Bitgo commitment is required');\n\n    return senderFn(MPCv2KeyGenStateEnum['MPCv2-R2'], {\n      sessionId,\n      userMsg2: {\n        from: MPCv2PartiesEnum.USER,\n        to: MPCv2PartiesEnum.BITGO,\n        signature: userMsg2.payload.signature,\n        encryptedMessage: userMsg2.payload.encryptedMessage,\n      },\n      userCommitment2: userMsg2.commitment,\n      backupMsg2: {\n        from: MPCv2PartiesEnum.BACKUP,\n        to: MPCv2PartiesEnum.BITGO,\n        signature: backupMsg2.payload.signature,\n        encryptedMessage: backupMsg2.payload.encryptedMessage,\n      },\n      backupCommitment2: backupMsg2.commitment,\n    });\n  }\n\n  async sendKeyGenerationRound3BySender(\n    senderFn: EcdsaMPCv2KeyGenSendFn<MPCv2KeyGenRound3Response>,\n    sessionId: string,\n    payload: DklsTypes.AuthEncMessages\n  ): Promise<MPCv2KeyGenRound3Response> {\n    assert(NonEmptyString.is(sessionId), 'Session ID is required');\n    const userMsg3 = payload.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.USER && m.to === MPCv2PartiesEnum.BITGO\n    )?.payload;\n    assert(userMsg3, 'User to Bitgo message 3 not found in P2P messages');\n    const backupMsg3 = payload.p2pMessages.find(\n      (m) => m.from === MPCv2PartiesEnum.BACKUP && m.to === MPCv2PartiesEnum.BITGO\n    )?.payload;\n    assert(backupMsg3, 'Backup to Bitgo message 3 not found in P2P messages');\n    const userMsg4 = payload.broadcastMessages.find((m) => m.from === MPCv2PartiesEnum.USER)?.payload;\n    assert(userMsg4, 'User message 1 not found in broadcast messages');\n    const backupMsg4 = payload.broadcastMessages.find((m) => m.from === MPCv2PartiesEnum.BACKUP)?.payload;\n    assert(backupMsg4, 'Backup message 1 not found in broadcast messages');\n\n    return senderFn(MPCv2KeyGenStateEnum['MPCv2-R3'], {\n      sessionId,\n      userMsg3: { from: 0, to: 2, ...userMsg3 },\n      backupMsg3: { from: 1, to: 2, ...backupMsg3 },\n      userMsg4: { from: 0, ...userMsg4 },\n      backupMsg4: { from: 1, ...backupMsg4 },\n    });\n  }\n\n  // #endregion\n\n  // #region sign tx request\n\n  /**\n   * Signs the transaction associated to the transaction request.\n   * @param {string | TxRequest} params.txRequest - transaction request object or id\n   * @param {string} params.prv - decrypted private key\n   * @param {string} params.reqId - request id\n   * @param {string} params.mpcv2PartyId - party id for the signer involved in this mpcv2 request (either 0 for user or 1 for backup)\n   * @param params.recipientSource - optional; use TssTxRecipientSource.Explicit with a non-empty txParams.recipients\n   *   list when you want TypeScript to enforce passing recipient details at compile time.\n   * @returns {Promise<TxRequest>} fully signed TxRequest object\n   */\n\n  async signTxRequest(params: TssSignTxRequestParamsWithPrv): Promise<TxRequest> {\n    this.bitgo.setRequestTracer(params.reqId);\n    return this.signRequestBase(params, RequestType.tx);\n  }\n\n  /**\n   * Signs the message associated to the transaction request.\n   * @param {string | TxRequest} params.txRequest - transaction request object or id\n   * @param {string} params.prv - decrypted private key\n   * @param {string} params.reqId - request id\n   * @returns {Promise<TxRequest>} fully signed TxRequest object\n   */\n  async signTxRequestForMessage(params: TSSParamsForMessageWithPrv): Promise<TxRequest> {\n    this.bitgo.setRequestTracer(params.reqId);\n    return this.signRequestBase(params, RequestType.message);\n  }\n\n  private async signRequestBase(\n    params: TSSParamsWithPrv | TSSParamsForMessageWithPrv,\n    requestType: RequestType\n  ): Promise<TxRequest> {\n    const userKeyShare = Buffer.from(params.prv, 'base64');\n    const txRequest: TxRequest =\n      typeof params.txRequest === 'string'\n        ? await getTxRequest(this.bitgo, this.wallet.id(), params.txRequest, params.reqId)\n        : params.txRequest;\n    let txOrMessageToSign;\n    let derivationPath;\n    let bufferContent;\n    let serializedTxHex: string | undefined;\n    const userGpgKey = await generateGPGKeyPair('secp256k1');\n    const bitgoGpgPubKey = await this.pickBitgoPubGpgKeyForSigning(true, params.reqId, txRequest.enterpriseId);\n\n    if (!bitgoGpgPubKey) {\n      throw new Error('Missing BitGo GPG key for MPCv2');\n    }\n\n    if (requestType === RequestType.tx) {\n      assert(txRequest.transactions || txRequest.unsignedTxs, 'Unable to find transactions in txRequest');\n      const unsignedTx =\n        txRequest.apiVersion === 'full' ? txRequest.transactions![0].unsignedTx : txRequest.unsignedTxs[0];\n\n      if (\n        'recipientSource' in params &&\n        params.recipientSource === TssTxRecipientSource.Explicit &&\n        !params.txParams?.recipients?.length\n      ) {\n        throw new InvalidTransactionError(\n          'recipientSource \"explicit\" requires txParams.recipients with at least one recipient.'\n        );\n      }\n\n      // For some coins, signableHex is not a parseable transaction. Pass\n      // serializedTxHex so verifyTransaction can decode the full tx bytes.\n      // - CoinFeature.TSS_VERIFY_USE_SERIALIZED_TX_HEX: ICP hash digests,\n      //   BSC/XDC legacy EIP-155 RLP with v=chainId, etc.\n      // - Avalanche atomic (FLRP/FLR cross-chain): signableHex is SHA-256(txBody);\n      //   serializedTxHex is the PVM/EVM atomic tx (codec prefix 0x0000).\n      // For other coins, signableHex IS the unsigned transaction (e.g. EIP-1559 RLP).\n      if (shouldVerifyWithSerializedTxHex(this.baseCoin) || shouldUsePreHashedSignable(this.baseCoin, unsignedTx)) {\n        await this.baseCoin.verifyTransaction({\n          txPrebuild: { txHex: unsignedTx.serializedTxHex, txInfo: unsignedTx.signableHex },\n          txParams: resolveEffectiveTxParams(txRequest, params.txParams),\n          wallet: this.wallet,\n          walletType: this.wallet.multisigType(),\n        });\n      } else {\n        await this.baseCoin.verifyTransaction({\n          txPrebuild: { txHex: unsignedTx.signableHex },\n          txParams: resolveEffectiveTxParams(txRequest, params.txParams),\n          wallet: this.wallet,\n          walletType: this.wallet.multisigType(),\n        });\n      }\n      txOrMessageToSign = unsignedTx.signableHex;\n      derivationPath = unsignedTx.derivationPath;\n      serializedTxHex = unsignedTx.serializedTxHex;\n      bufferContent = Buffer.from(txOrMessageToSign, 'hex');\n    } else if (requestType === RequestType.message) {\n      txOrMessageToSign = txRequest.messages![0].messageEncoded;\n      derivationPath = txRequest.messages![0].derivationPath || 'm/0';\n      bufferContent = Buffer.from(txOrMessageToSign, 'hex');\n    } else {\n      throw new Error('Invalid request type');\n    }\n\n    // For Avalanche atomic transactions (cross-chain export/import between\n    // C-chain and P-chain), signableHex is already SHA-256(txBody) — a 32-byte\n    // pre-hashed digest.  Use it directly as the DKLS message hash instead of\n    // applying the coin's hash function (keccak256 for EVM coins).\n    // Same logic as getHashStringAndDerivationPath (external signer path).\n    const hashBuffer = this.getMpcv2HashBuffer(serializedTxHex, txOrMessageToSign, bufferContent);\n    const otherSigner = new DklsDsg.Dsg(\n      userKeyShare,\n      params.mpcv2PartyId !== undefined ? params.mpcv2PartyId : 0,\n      derivationPath,\n      hashBuffer\n    );\n    const userSignerBroadcastMsg1 = await otherSigner.init();\n    const signatureShareRound1 = await getSignatureShareRoundOne(\n      userSignerBroadcastMsg1,\n      userGpgKey,\n      params.mpcv2PartyId\n    );\n\n    let latestTxRequest = await sendSignatureShareV2(\n      this.bitgo,\n      txRequest.walletId,\n      txRequest.txRequestId,\n      [signatureShareRound1],\n      requestType,\n      this.baseCoin.getMPCAlgorithm(),\n      userGpgKey.publicKey,\n      undefined,\n      this.wallet.multisigTypeVersion(),\n      params.reqId\n    );\n\n    assert(latestTxRequest.transactions || latestTxRequest.messages, 'Invalid txRequest Object');\n\n    let bitgoToUserMessages1And2: any;\n    if (requestType === RequestType.tx) {\n      bitgoToUserMessages1And2 = latestTxRequest.transactions![0].signatureShares;\n    } else {\n      bitgoToUserMessages1And2 = latestTxRequest.messages![0].signatureShares;\n    }\n    // TODO: Use codec for parsing\n    const parsedBitGoToUserSigShareRoundOne = JSON.parse(\n      bitgoToUserMessages1And2[bitgoToUserMessages1And2.length - 1].share\n    ) as MPCv2SignatureShareRound1Output;\n    if (parsedBitGoToUserSigShareRoundOne.type !== 'round1Output') {\n      throw new Error('Unexpected signature share response. Unable to parse data.');\n    }\n    const serializedBitGoToUserMessagesRound1And2 = await verifyBitGoMessagesAndSignaturesRoundOne(\n      parsedBitGoToUserSigShareRoundOne,\n      userGpgKey,\n      bitgoGpgPubKey,\n      params.mpcv2PartyId\n    );\n\n    /** Round 2 **/\n    const deserializedMessages = DklsTypes.deserializeMessages(serializedBitGoToUserMessagesRound1And2);\n    const userToBitGoMessagesRound2 = otherSigner.handleIncomingMessages({\n      p2pMessages: [],\n      broadcastMessages: deserializedMessages.broadcastMessages,\n    });\n    const userToBitGoMessagesRound3 = otherSigner.handleIncomingMessages({\n      p2pMessages: deserializedMessages.p2pMessages,\n      broadcastMessages: [],\n    });\n    const signatureShareRoundTwo = await getSignatureShareRoundTwo(\n      userToBitGoMessagesRound2,\n      userToBitGoMessagesRound3,\n      userGpgKey,\n      bitgoGpgPubKey,\n      params.mpcv2PartyId\n    );\n    latestTxRequest = await sendSignatureShareV2(\n      this.bitgo,\n      txRequest.walletId,\n      txRequest.txRequestId,\n      [signatureShareRoundTwo],\n      requestType,\n      this.baseCoin.getMPCAlgorithm(),\n      userGpgKey.publicKey,\n      undefined,\n      this.wallet.multisigTypeVersion(),\n      params.reqId\n    );\n    assert(latestTxRequest.transactions || latestTxRequest.messages, 'Invalid txRequest Object');\n\n    const txRequestSignatureShares =\n      requestType === RequestType.tx\n        ? latestTxRequest.transactions![0].signatureShares\n        : latestTxRequest.messages![0].signatureShares;\n    // TODO: Use codec for parsing\n    const parsedBitGoToUserSigShareRoundTwo = JSON.parse(\n      txRequestSignatureShares[txRequestSignatureShares.length - 1].share\n    ) as MPCv2SignatureShareRound2Output;\n    if (parsedBitGoToUserSigShareRoundTwo.type !== 'round2Output') {\n      throw new Error('Unexpected signature share response. Unable to parse data.');\n    }\n    const serializedBitGoToUserMessagesRound3 = await verifyBitGoMessagesAndSignaturesRoundTwo(\n      parsedBitGoToUserSigShareRoundTwo,\n      userGpgKey,\n      bitgoGpgPubKey,\n      params.mpcv2PartyId\n    );\n\n    /** Round 3 **/\n    const deserializedBitGoToUserMessagesRound3 = DklsTypes.deserializeMessages({\n      p2pMessages: serializedBitGoToUserMessagesRound3.p2pMessages,\n      broadcastMessages: [],\n    });\n    const userToBitGoMessagesRound4 = otherSigner.handleIncomingMessages({\n      p2pMessages: deserializedBitGoToUserMessagesRound3.p2pMessages,\n      broadcastMessages: [],\n    });\n\n    const signatureShareRoundThree = await getSignatureShareRoundThree(\n      userToBitGoMessagesRound4,\n      userGpgKey,\n      bitgoGpgPubKey,\n      params.mpcv2PartyId\n    );\n    // Submit for final signature share combine\n    await sendSignatureShareV2(\n      this.bitgo,\n      txRequest.walletId,\n      txRequest.txRequestId,\n      [signatureShareRoundThree],\n      requestType,\n      this.baseCoin.getMPCAlgorithm(),\n      userGpgKey.publicKey,\n      undefined,\n      this.wallet.multisigTypeVersion(),\n      params.reqId\n    );\n\n    return sendTxRequest(this.bitgo, txRequest.walletId, txRequest.txRequestId, requestType, params.reqId);\n  }\n\n  // #endregion\n\n  // #region formatting utils\n  formatBitgoBroadcastMessage(broadcastMessage: MPCv2BroadcastMessage) {\n    return {\n      from: broadcastMessage.from,\n      payload: { message: broadcastMessage.message, signature: broadcastMessage.signature },\n    };\n  }\n\n  formatP2PMessage(p2pMessage: MPCv2P2PMessage, commitment?: string) {\n    return {\n      payload: { encryptedMessage: p2pMessage.encryptedMessage, signature: p2pMessage.signature },\n      from: p2pMessage.from,\n      to: p2pMessage.to,\n      commitment,\n    };\n  }\n  // #endregion\n\n  // #region private utils\n  /**\n   * Get the hash string and derivation path from the transaction request.\n   * @param {TxRequest} txRequest - the transaction request object\n   * @param {RequestType} requestType - the request type\n   * @returns {{ hashBuffer: Buffer; derivationPath: string }} - the hash string and derivation path\n   */\n  private getHashStringAndDerivationPath(\n    txRequest: TxRequest,\n    requestType: RequestType = RequestType.tx\n  ): { hashBuffer: Buffer; derivationPath: string } {\n    let txToSign: string;\n    let derivationPath: string;\n    let serializedTxHex: string | undefined;\n    if (requestType === RequestType.tx) {\n      const signableTx = this.getSignableHexAndDerivationPath(txRequest, 'Unable to find transactions in txRequest');\n      txToSign = signableTx.signableHex;\n      derivationPath = signableTx.derivationPath;\n      serializedTxHex = signableTx.serializedTxHex;\n    } else if (requestType === RequestType.message) {\n      // TODO(WP-2176): Add support for message signing\n      throw new Error('MPCv2 message signing not supported yet.');\n    } else {\n      throw new Error('Invalid request type, got: ' + requestType);\n    }\n\n    const hashBuffer = this.getMpcv2HashBuffer(serializedTxHex, txToSign, Buffer.from(txToSign, 'hex'));\n    return { hashBuffer, derivationPath };\n  }\n\n  /**\n   * Build the DKLS message hash for MPCv2 signing.\n   * For pre-hashed signable material (Avalanche atomic txs), signableHex is\n   * already SHA-256(txBody) and is used directly. Otherwise the coin hash\n   * function is applied (keccak256 for EVM coins by default).\n   */\n  private getMpcv2HashBuffer(serializedTxHex: string | undefined, signableHex: string, bufferContent: Buffer): Buffer {\n    const unsignedTx: SignableTransaction = {\n      serializedTxHex: serializedTxHex ?? '',\n      signableHex,\n    };\n    if (serializedTxHex && shouldUsePreHashedSignable(this.baseCoin, unsignedTx)) {\n      assert(\n        bufferContent.length === 32,\n        `Avalanche pre-hashed signableHex must be 32 bytes, got ${bufferContent.length}`\n      );\n      return bufferContent;\n    }\n\n    let hash: Hash;\n    try {\n      hash = this.baseCoin.getHashFunction();\n    } catch (err) {\n      hash = createKeccakHash('keccak256') as Hash;\n    }\n    return hash.update(bufferContent).digest();\n  }\n\n  // #endregion\n\n  // #region external signer\n  /** @inheritdoc */\n  async signEcdsaMPCv2TssUsingExternalSigner(\n    params: TSSParams | TSSParamsForMessage,\n    externalSignerMPCv2SigningRound1Generator: CustomMPCv2SigningRound1GeneratingFunction,\n    externalSignerMPCv2SigningRound2Generator: CustomMPCv2SigningRound2GeneratingFunction,\n    externalSignerMPCv2SigningRound3Generator: CustomMPCv2SigningRound3GeneratingFunction,\n    requestType: RequestType = RequestType.tx\n  ): Promise<TxRequest> {\n    const { txRequest, reqId } = params;\n    let txRequestResolved: TxRequest;\n\n    // TODO(WP-2176): Add support for message signing\n    assert(\n      requestType === RequestType.tx,\n      'Only transaction signing is supported for external signer, got: ' + requestType\n    );\n\n    if (typeof txRequest === 'string') {\n      txRequestResolved = await getTxRequest(this.bitgo, this.wallet.id(), txRequest, reqId);\n    } else {\n      txRequestResolved = txRequest;\n    }\n\n    const bitgoPublicGpgKey = await this.pickBitgoPubGpgKeyForSigning(\n      true,\n      params.reqId,\n      txRequestResolved.enterpriseId\n    );\n\n    if (!bitgoPublicGpgKey) {\n      throw new Error('Missing BitGo GPG key for MPCv2');\n    }\n\n    // round 1\n    const { signatureShareRound1, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey } =\n      await externalSignerMPCv2SigningRound1Generator({ txRequest: txRequestResolved });\n    const round1TxRequest = await sendSignatureShareV2(\n      this.bitgo,\n      txRequestResolved.walletId,\n      txRequestResolved.txRequestId,\n      [signatureShareRound1],\n      requestType,\n      this.baseCoin.getMPCAlgorithm(),\n      userGpgPubKey,\n      undefined,\n      this.wallet.multisigTypeVersion(),\n      reqId\n    );\n\n    // round 2\n    const { signatureShareRound2, encryptedRound2Session } = await externalSignerMPCv2SigningRound2Generator({\n      txRequest: round1TxRequest,\n      encryptedRound1Session,\n      encryptedUserGpgPrvKey,\n      bitgoPublicGpgKey: bitgoPublicGpgKey.armor(),\n    });\n    const round2TxRequest = await sendSignatureShareV2(\n      this.bitgo,\n      txRequestResolved.walletId,\n      txRequestResolved.txRequestId,\n      [signatureShareRound2],\n      requestType,\n      this.baseCoin.getMPCAlgorithm(),\n      userGpgPubKey,\n      undefined,\n      this.wallet.multisigTypeVersion(),\n      reqId\n    );\n    assert(\n      round2TxRequest.transactions && round2TxRequest.transactions[0].signatureShares,\n      'Missing signature shares in round 2 txRequest'\n    );\n\n    // round 3\n    const { signatureShareRound3 } = await externalSignerMPCv2SigningRound3Generator({\n      txRequest: round2TxRequest,\n      encryptedRound2Session,\n      encryptedUserGpgPrvKey,\n      bitgoPublicGpgKey: bitgoPublicGpgKey.armor(),\n    });\n    await sendSignatureShareV2(\n      this.bitgo,\n      txRequestResolved.walletId,\n      txRequestResolved.txRequestId,\n      [signatureShareRound3],\n      requestType,\n      this.baseCoin.getMPCAlgorithm(),\n      userGpgPubKey,\n      undefined,\n      this.wallet.multisigTypeVersion(),\n      reqId\n    );\n\n    return sendTxRequest(this.bitgo, txRequestResolved.walletId, txRequestResolved.txRequestId, requestType, reqId);\n  }\n\n  async createOfflineRound1Share(params: {\n    txRequest: TxRequest;\n    prv: string;\n    walletPassphrase: string;\n    encryptedPrv?: string;\n  }): Promise<{\n    signatureShareRound1: SignatureShareRecord;\n    userGpgPubKey: string;\n    encryptedRound1Session: string;\n    encryptedUserGpgPrvKey: string;\n  }> {\n    const { prv, walletPassphrase, txRequest, encryptedPrv } = params;\n    const { hashBuffer, derivationPath } = this.getHashStringAndDerivationPath(txRequest);\n    const adata = `${hashBuffer.toString('hex')}:${derivationPath}`;\n\n    const userKeyShare = Buffer.from(prv, 'base64');\n    const userGpgKey = await generateGPGKeyPair('secp256k1');\n\n    const userSigner = new DklsDsg.Dsg(userKeyShare, 0, derivationPath, hashBuffer);\n    const userSignerBroadcastMsg1 = await userSigner.init();\n    const signatureShareRound1 = await getSignatureShareRoundOne(userSignerBroadcastMsg1, userGpgKey);\n    const sessionData = userSigner.getSession();\n    const userGpgPubKey = userGpgKey.publicKey;\n\n    const useV2 = encryptedPrv !== undefined && isV2Envelope(encryptedPrv);\n    if (useV2) {\n      const session = await this.bitgo.createEncryptionSession(walletPassphrase);\n      try {\n        const encryptedRound1Session = await session.encrypt(\n          sessionData,\n          `${EcdsaMPCv2Utils.DKLS23_SIGNING_ROUND1_STATE}:${adata}`\n        );\n        const encryptedUserGpgPrvKey = await session.encrypt(\n          userGpgKey.privateKey,\n          `${EcdsaMPCv2Utils.DKLS23_SIGNING_USER_GPG_KEY}:${adata}`\n        );\n        return { signatureShareRound1, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey };\n      } finally {\n        session.destroy();\n      }\n    }\n\n    const encryptedRound1Session = await this.bitgo.encrypt({\n      input: sessionData,\n      password: walletPassphrase,\n      adata: `${EcdsaMPCv2Utils.DKLS23_SIGNING_ROUND1_STATE}:${adata}`,\n      encryptionVersion: 1,\n    });\n    const encryptedUserGpgPrvKey = await this.bitgo.encrypt({\n      input: userGpgKey.privateKey,\n      password: walletPassphrase,\n      adata: `${EcdsaMPCv2Utils.DKLS23_SIGNING_USER_GPG_KEY}:${adata}`,\n      encryptionVersion: 1,\n    });\n\n    return { signatureShareRound1, userGpgPubKey, encryptedRound1Session, encryptedUserGpgPrvKey };\n  }\n\n  async createOfflineRound2Share(params: {\n    txRequest: TxRequest;\n    prv: string;\n    walletPassphrase: string;\n    bitgoPublicGpgKey: string;\n    encryptedUserGpgPrvKey: string;\n    encryptedRound1Session: string;\n  }): Promise<{\n    signatureShareRound2: SignatureShareRecord;\n    encryptedRound2Session: string;\n  }> {\n    const { prv, walletPassphrase, encryptedUserGpgPrvKey, encryptedRound1Session, bitgoPublicGpgKey, txRequest } =\n      params;\n\n    const { hashBuffer, derivationPath } = this.getHashStringAndDerivationPath(txRequest);\n    const adata = `${hashBuffer.toString('hex')}:${derivationPath}`;\n\n    const useV2 = isV2Envelope(encryptedRound1Session);\n\n    const { bitgoGpgKey, userGpgPrvKey } = await this.getBitgoAndUserGpgKeys(\n      bitgoPublicGpgKey,\n      encryptedUserGpgPrvKey,\n      walletPassphrase,\n      adata,\n      EcdsaMPCv2Utils.DKLS23_SIGNING_USER_GPG_KEY\n    );\n    const userGpgKey: pgp.SerializedKeyPair<string> = {\n      privateKey: userGpgPrvKey.armor(),\n      publicKey: userGpgPrvKey.toPublic().armor(),\n    };\n\n    const signatureShares = txRequest.transactions?.[0].signatureShares;\n    assert(signatureShares, 'Missing signature shares in round 1 txRequest');\n    const parsedBitGoToUserSigShareRoundOne = JSON.parse(\n      signatureShares[signatureShares.length - 1].share\n    ) as MPCv2SignatureShareRound1Output;\n    if (parsedBitGoToUserSigShareRoundOne.type !== 'round1Output') {\n      throw new Error('Unexpected signature share response. Unable to parse data.');\n    }\n    const serializedBitGoToUserMessagesRound1 = await verifyBitGoMessagesAndSignaturesRoundOne(\n      parsedBitGoToUserSigShareRoundOne,\n      userGpgKey,\n      bitgoGpgKey\n    );\n\n    const round1Session = await this.bitgo.decrypt({ input: encryptedRound1Session, password: walletPassphrase });\n    this.validateAdata(adata, encryptedRound1Session, EcdsaMPCv2Utils.DKLS23_SIGNING_ROUND1_STATE);\n\n    const userKeyShare = Buffer.from(prv, 'base64');\n    const userSigner = new DklsDsg.Dsg(userKeyShare, 0, derivationPath, hashBuffer);\n    await userSigner.setSession(round1Session);\n\n    const deserializedMessages = DklsTypes.deserializeMessages(serializedBitGoToUserMessagesRound1);\n    const userToBitGoMessagesRound2 = userSigner.handleIncomingMessages({\n      p2pMessages: [],\n      broadcastMessages: deserializedMessages.broadcastMessages,\n    });\n    const userToBitGoMessagesRound3 = userSigner.handleIncomingMessages({\n      p2pMessages: deserializedMessages.p2pMessages,\n      broadcastMessages: [],\n    });\n    const signatureShareRound2 = await getSignatureShareRoundTwo(\n      userToBitGoMessagesRound2,\n      userToBitGoMessagesRound3,\n      userGpgKey,\n      bitgoGpgKey\n    );\n    const sessionData = userSigner.getSession();\n\n    if (useV2) {\n      const encSession = await this.bitgo.createEncryptionSession(walletPassphrase);\n      try {\n        const encryptedRound2Session = await encSession.encrypt(\n          sessionData,\n          `${EcdsaMPCv2Utils.DKLS23_SIGNING_ROUND2_STATE}:${adata}`\n        );\n        return { signatureShareRound2, encryptedRound2Session };\n      } finally {\n        encSession.destroy();\n      }\n    }\n\n    const encryptedRound2Session = await this.bitgo.encrypt({\n      input: sessionData,\n      password: walletPassphrase,\n      adata: `${EcdsaMPCv2Utils.DKLS23_SIGNING_ROUND2_STATE}:${adata}`,\n      encryptionVersion: 1,\n    });\n\n    return {\n      signatureShareRound2,\n      encryptedRound2Session,\n    };\n  }\n\n  async createOfflineRound3Share(params: {\n    txRequest: TxRequest;\n    prv: string;\n    walletPassphrase: string;\n    bitgoPublicGpgKey: string;\n    encryptedUserGpgPrvKey: string;\n    encryptedRound2Session: string;\n  }): Promise<{\n    signatureShareRound3: SignatureShareRecord;\n  }> {\n    const { prv, walletPassphrase, encryptedUserGpgPrvKey, encryptedRound2Session, bitgoPublicGpgKey, txRequest } =\n      params;\n\n    assert(txRequest.transactions && txRequest.transactions.length === 1, 'Unable to find transactions in txRequest');\n    const { hashBuffer, derivationPath } = this.getHashStringAndDerivationPath(txRequest);\n    const adata = `${hashBuffer.toString('hex')}:${derivationPath}`;\n\n    const { bitgoGpgKey, userGpgPrvKey } = await this.getBitgoAndUserGpgKeys(\n      bitgoPublicGpgKey,\n      encryptedUserGpgPrvKey,\n      walletPassphrase,\n      adata,\n      EcdsaMPCv2Utils.DKLS23_SIGNING_USER_GPG_KEY\n    );\n    const userGpgKey: pgp.SerializedKeyPair<string> = {\n      privateKey: userGpgPrvKey.armor(),\n      publicKey: userGpgPrvKey.toPublic().armor(),\n    };\n\n    const signatureShares = txRequest.transactions?.[0].signatureShares;\n    assert(signatureShares, 'Missing signature shares in round 2 txRequest');\n    const parsedBitGoToUserSigShareRoundTwo = JSON.parse(\n      signatureShares[signatureShares.length - 1].share\n    ) as MPCv2SignatureShareRound2Output;\n    if (parsedBitGoToUserSigShareRoundTwo.type !== 'round2Output') {\n      throw new Error('Unexpected signature share response. Unable to parse data.');\n    }\n    const serializedBitGoToUserMessagesRound3 = await verifyBitGoMessagesAndSignaturesRoundTwo(\n      parsedBitGoToUserSigShareRoundTwo,\n      userGpgKey,\n      bitgoGpgKey\n    );\n\n    const deserializedBitGoToUserMessagesRound3 = DklsTypes.deserializeMessages({\n      p2pMessages: serializedBitGoToUserMessagesRound3.p2pMessages,\n      broadcastMessages: [],\n    });\n\n    const round2Session = await this.bitgo.decrypt({ input: encryptedRound2Session, password: walletPassphrase });\n    this.validateAdata(adata, encryptedRound2Session, EcdsaMPCv2Utils.DKLS23_SIGNING_ROUND2_STATE);\n\n    const userKeyShare = Buffer.from(prv, 'base64');\n    const userSigner = new DklsDsg.Dsg(userKeyShare, 0, derivationPath, hashBuffer);\n    await userSigner.setSession(round2Session);\n\n    const userToBitGoMessagesRound4 = userSigner.handleIncomingMessages({\n      p2pMessages: deserializedBitGoToUserMessagesRound3.p2pMessages,\n      broadcastMessages: [],\n    });\n\n    const signatureShareRound3 = await getSignatureShareRoundThree(userToBitGoMessagesRound4, userGpgKey, bitgoGpgKey);\n\n    return { signatureShareRound3 };\n  }\n  // #endregion\n}\n\n/**\n * Checks if the given key share, when decrypted, contains valid GG18 signing material.\n *\n * @param {string} keyShare - The encrypted key share string.\n * @param {string|undefined} walletPassphrase - The passphrase used to decrypt the key share\n * @param {BitGoBase} bitgo - BitGo instance for v1/v2 auto-detect decrypt\n * @returns {Promise<boolean>} - Resolves `true` if the decrypted data contains valid signing material, otherwise `false`.\n */\nexport async function isGG18SigningMaterial(\n  keyShare: string,\n  walletPassphrase: string | undefined,\n  bitgo: BitGoBase\n): Promise<boolean> {\n  try {\n    const prv = await bitgo.decrypt({ password: walletPassphrase, input: keyShare });\n    const signingMaterial = JSON.parse(prv);\n    return (\n      signingMaterial.pShare &&\n      signingMaterial.bitgoNShare &&\n      (signingMaterial.userNShare || signingMaterial.backupNShare)\n    );\n  } catch (error) {\n    return false;\n  }\n}\n\n/**\n * Get the MPC v2 recovery key shares from the provided user and backup key shares.\n * @param encryptedUserKey encrypted gg18 or MPCv2 user key\n * @param encryptedBackupKey encrypted gg18 or MPCv2 backup key\n * @param walletPassphrase password for user and backup key\n * @param bitgo BitGo instance for v1/v2 auto-detect decrypt\n * @returns MPC v2 recovery key shares\n */\nexport async function getMpcV2RecoveryKeyShares(\n  encryptedUserKey: string,\n  encryptedBackupKey: string,\n  walletPassphrase: string | undefined,\n  bitgo: BitGoBase\n): Promise<{\n  userKeyShare: Buffer;\n  backupKeyShare: Buffer;\n  commonKeyChain: string;\n}> {\n  if (await isGG18SigningMaterial(encryptedUserKey, walletPassphrase, bitgo)) {\n    return getMpcV2RecoveryKeySharesFromGG18(encryptedUserKey, encryptedBackupKey, walletPassphrase, bitgo);\n  }\n  return getMpcV2RecoveryKeySharesFromReducedKey(encryptedUserKey, encryptedBackupKey, walletPassphrase, bitgo);\n}\n\n/**\n * Signs a message hash using MPC v2 recovery key shares.\n *\n * @param {Buffer} messageHash\n * @param {Buffer} userKeyShare\n * @param {Buffer} backupKeyShare\n * @param {string} commonKeyChain\n * @returns {Promise<{ recid: number, r: string, s: string, y: string }>}\n *\n * @async\n */\nexport async function signRecoveryMpcV2(\n  messageHash: Buffer,\n  userKeyShare: Buffer,\n  backupKeyShare: Buffer,\n  commonKeyChain: string\n): Promise<{\n  recid: number;\n  r: string;\n  s: string;\n  y: string;\n}> {\n  const userDsg = new DklsDsg.Dsg(userKeyShare, 0, 'm/0', messageHash);\n  const backupDsg = new DklsDsg.Dsg(backupKeyShare, 1, 'm/0', messageHash);\n\n  const signatureString = DklsUtils.verifyAndConvertDklsSignature(\n    messageHash,\n    (await DklsUtils.executeTillRound(5, userDsg, backupDsg)) as DklsTypes.DeserializedDklsSignature,\n    commonKeyChain,\n    'm/0',\n    undefined,\n    false\n  );\n  const sigParts = signatureString.split(':');\n\n  return {\n    recid: parseInt(sigParts[0], 10),\n    r: sigParts[1],\n    s: sigParts[2],\n    y: sigParts[3],\n  };\n}\n\n// #region private utils\n\n/**\n * Get the MPC v2 recovery key shares from the provided user and backup key shares.\n * @param encryptedGG18UserKey encrypted gg18 user key\n * @param encryptedGG18BackupKey encrypted gg18 backup key\n * @param walletPassphrase password for user and backup key\n * @returns MPC v2 recovery key shares\n */\nasync function getMpcV2RecoveryKeySharesFromGG18(\n  encryptedGG18UserKey: string,\n  encryptedGG18BackupKey: string,\n  walletPassphrase: string | undefined,\n  bitgo: BitGoBase\n): Promise<{\n  userKeyShare: Buffer;\n  backupKeyShare: Buffer;\n  commonKeyChain: string;\n}> {\n  const [userKeyCombined, backupKeyCombined] = await getKeyCombinedFromTssKeyShares(\n    encryptedGG18UserKey,\n    encryptedGG18BackupKey,\n    walletPassphrase,\n    bitgo\n  );\n  const retrofitDataA: DklsTypes.RetrofitData = {\n    xShare: userKeyCombined.xShare,\n  };\n  const retrofitDataB: DklsTypes.RetrofitData = {\n    xShare: backupKeyCombined.xShare,\n  };\n  const [user, backup] = await DklsUtils.generate2of2KeyShares(retrofitDataA, retrofitDataB);\n\n  const userKeyShare = user.getKeyShare();\n  const backupKeyShare = backup.getKeyShare();\n  return {\n    userKeyShare,\n    backupKeyShare,\n    commonKeyChain: DklsTypes.getCommonKeychain(backupKeyShare),\n  };\n}\n\n/**\n * Retrieves the MPC v2 recovery key shares from the provided user and backup key shares.\n *\n * @param {string} encryptedMPCv2UserKey\n * @param {string} encryptedMPCv2BackupKey\n * @param {string} [walletPassphrase] - The passphrase used to decrypt the key shares\n * @returns {Promise<{ userKeyShare: KeyShare, backupKeyShare: KeyShare, commonKeyChain: string }>}\n *\n * @async\n */\nasync function getMpcV2RecoveryKeySharesFromReducedKey(\n  encryptedMPCv2UserKey: string,\n  encryptedMPCv2BackupKey: string,\n  walletPassphrase: string | undefined,\n  bitgo: BitGoBase\n): Promise<{\n  userKeyShare: Buffer;\n  backupKeyShare: Buffer;\n  commonKeyChain: string;\n}> {\n  const userCompressedPrv = Buffer.from(\n    await bitgo.decrypt({ password: walletPassphrase, input: encryptedMPCv2UserKey }),\n    'base64'\n  );\n  const bakcupCompressedPrv = Buffer.from(\n    await bitgo.decrypt({ password: walletPassphrase, input: encryptedMPCv2BackupKey }),\n    'base64'\n  );\n\n  const userPrvJSON: DklsTypes.ReducedKeyShare = DklsTypes.getDecodedReducedKeyShare(userCompressedPrv);\n  const backupPrvJSON: DklsTypes.ReducedKeyShare = DklsTypes.getDecodedReducedKeyShare(bakcupCompressedPrv);\n  const userKeyRetrofit: DklsTypes.RetrofitData = {\n    xShare: {\n      x: Buffer.from(userPrvJSON.prv).toString('hex'),\n      y: Buffer.from(userPrvJSON.pub).toString('hex'),\n      chaincode: Buffer.from(userPrvJSON.rootChainCode).toString('hex'),\n    },\n    xiList: userPrvJSON.xList.slice(0, 2),\n  };\n  const backupKeyRetrofit: DklsTypes.RetrofitData = {\n    xShare: {\n      x: Buffer.from(backupPrvJSON.prv).toString('hex'),\n      y: Buffer.from(backupPrvJSON.pub).toString('hex'),\n      chaincode: Buffer.from(backupPrvJSON.rootChainCode).toString('hex'),\n    },\n    xiList: backupPrvJSON.xList.slice(0, 2),\n  };\n  const [user, backup] = await DklsUtils.generate2of2KeyShares(userKeyRetrofit, backupKeyRetrofit);\n  const userKeyShare = user.getKeyShare();\n  const backupKeyShare = backup.getKeyShare();\n  const commonKeyChain = DklsTypes.getCommonKeychain(userKeyShare);\n  return { userKeyShare, backupKeyShare, commonKeyChain };\n}\n\n/**\n * Gets the combined key for GG18\n * @param encryptedGG18UserKey encrypted GG18 user key\n * @param encryptedGG18BackupKey encrypted GG18 backup key\n * @param walletPassphrase wallet passphrase\n * @returns key shares\n */\nasync function getKeyCombinedFromTssKeyShares(\n  encryptedGG18UserKey: string,\n  encryptedGG18BackupKey: string,\n  walletPassphrase: string | undefined,\n  bitgo: BitGoBase\n): Promise<[ECDSAMethodTypes.KeyCombined, ECDSAMethodTypes.KeyCombined]> {\n  let backupPrv;\n  let userPrv;\n  try {\n    backupPrv = await bitgo.decrypt({ password: walletPassphrase, input: encryptedGG18BackupKey });\n    userPrv = await bitgo.decrypt({ password: walletPassphrase, input: encryptedGG18UserKey });\n  } catch (e) {\n    throw new Error(`Error decrypting backup keychain: ${e.message}`);\n  }\n\n  const userSigningMaterial = JSON.parse(userPrv) as ECDSAMethodTypes.SigningMaterial;\n  const backupSigningMaterial = JSON.parse(backupPrv) as ECDSAMethodTypes.SigningMaterial;\n\n  if (!userSigningMaterial.backupNShare) {\n    throw new Error('Invalid user key - missing backupNShare');\n  }\n\n  if (!backupSigningMaterial.userNShare) {\n    throw new Error('Invalid backup key - missing userNShare');\n  }\n\n  const MPC = new Ecdsa();\n\n  const userKeyCombined = MPC.keyCombine(userSigningMaterial.pShare, [\n    userSigningMaterial.bitgoNShare,\n    userSigningMaterial.backupNShare,\n  ]);\n  const backupKeyCombined = MPC.keyCombine(backupSigningMaterial.pShare, [\n    backupSigningMaterial.userNShare,\n    backupSigningMaterial.bitgoNShare,\n  ]);\n  if (\n    userKeyCombined.xShare.y !== backupKeyCombined.xShare.y ||\n    userKeyCombined.xShare.chaincode !== backupKeyCombined.xShare.chaincode\n  ) {\n    throw new Error('Common keychains do not match');\n  }\n  return [userKeyCombined, backupKeyCombined];\n}\n\n// #endregion\n"]}