@bitgo-beta/sdk-core 8.2.1-beta.208 → 8.2.1-beta.2080

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

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_RECIPIENT_TX_TYPES = void 0;
+exports.resolveEffectiveTxParams = resolveEffectiveTxParams;
+const errors_1 = require("../../errors");
+/**
+ * Transaction types that legitimately carry no explicit recipients.
+ * These are the intentType strings as stored in TxRequest.intent.intentType by WP.
+ * verifyTransaction handles no-recipient validation for these internally.
+ * Mirrors the bypass list in abstractEthLikeNewCoins.ts verifyTssTransaction.
+ *
+ * ECDSA types: acceleration, fillNonce, transferToken, tokenApproval, consolidate,
+ *              bridgeFunds, enableToken, customTx, wrapApprove, wrap, unwrap,
+ *              finalizeUnwrap, contractCall
+ * BSC/BNB delegation-based staking: delegate, undelegate, switchValidator
+ * CELO/ETH lock-based staking: stake, unstake, stakeWithCallData, unstakeWithCallData,
+ *              transferStake, increaseStake, goUnstake
+ * Claim rewards (BSC, CELO — TRX/SOL use EdDSA and are unaffected): claim, stakeClaimRewards
+ */
+exports.NO_RECIPIENT_TX_TYPES = new Set([
+    // ECDSA types
+    'acceleration',
+    'fillNonce',
+    'transferToken',
+    'tokenApproval',
+    'consolidate',
+    'bridgeFunds',
+    'enableToken',
+    'enabletoken',
+    'disableToken',
+    'disabletoken',
+    'customTx',
+    // DeFi vault operations — recipients/calldata built server-side from defiParams
+    'defiApprove',
+    'defiDeposit',
+    'defiWithdraw',
+    // Native wrap/unwrap (WETH9 deposit()/withdraw()) — calldata and the WETH9
+    // address are resolved server-side from the vault binding, so no recipients.
+    // Registered in BOTH spellings on purpose: this set is matched against
+    // txParams.type, which is buildParams.type (camelCase, from wallet.sendMany),
+    // AND against intent.intentType (kebab-case, as WP persists it). Signing paths
+    // that carry no txParams — notably pendingApproval.approve() →
+    // recreateTxRequest() → signTxRequest() with no txParams — only ever see the
+    // kebab-case spelling.
+    'wrapNative',
+    'wrap-native',
+    'unwrapNative',
+    'unwrap-native',
+    // ERC-7984 shield/unshield: approve/wrap/unwrap calldata is built server-side from the
+    // intent, and finalizeUnwrap txnReqs are WP-created at READY_TO_FINALIZE (client signs
+    // only) — none carry SDK-level recipients.
+    'wrapApprove',
+    'wrap',
+    'unwrap',
+    'finalizeUnwrap',
+    // Smart contract invocations with no explicit SDK-level recipients
+    'contractCall',
+    // BSC/BNB delegation-based staking — intentType strings from TxRequest.intent.intentType.
+    // Note: SOL solDelegateIntent also uses intentType "delegate".
+    'delegate',
+    'undelegate',
+    'switchValidator',
+    // CELO/ETH lock-based staking
+    'stake',
+    'unstake',
+    'stakeWithCallData',
+    'unstakeWithCallData',
+    'transferStake',
+    'increaseStake',
+    'goUnstake',
+    // Claim rewards — BSC and CELO (TRX/SOL/Cosmos use EdDSA, not affected by this guard)
+    'claim',
+    'stakeClaimRewards',
+    'createAccount',
+    // Canton operations with no SDK-level recipients. Canton.verifyTransaction validates these from the transaction itself.
+    'transferAccept',
+    'transferReject',
+    'transferOfferWithdrawn',
+    'cosignDelegationAccept',
+    'allocationAllocate',
+    'allocationOfferWithdrawn',
+    'cantonCommand',
+    'cantonEndInvestorOnboardingOffer',
+    'cantonEndInvestorOnboardingAccept',
+    'cantonEndInvestorOnboardingReject',
+    'cantonParticipantOnboardingRequest',
+    'pledge',
+    // Avalanche / Flare cross-chain atomic imports — recipients are not supplied
+    // by the client because the import consumes UTXOs already owned by the
+    // wallet; the destination address is the wallet itself. WP issues these
+    // with intentType 'import' (P-chain) or 'importtoc' (C-chain).
+    'import',
+    'importtoc',
+    // SOL: deactivate stake account — no on-chain transfer recipient.
+    'deactivate',
+    // SOL: authorize stake account — no transfer recipient.
+    'authorize',
+]);
+/**
+ * Resolves the effective txParams for TSS signing recipient verification.
+ *
+ * For smart contract interactions, recipients live in txRequest.intent.recipients
+ * (native amount = 0, so buildParams is empty). Falls back to intent recipients
+ * mapped to ITransactionRecipient shape when txParams.recipients is absent.
+ *
+ * tokenName is derived from tokenData.tokenName when present, otherwise from
+ * amount.symbol when chainName is provided and symbol differs from it.
+ *
+ * Staking intents (BSC delegate/undelegate, CELO stake/unstake, etc.) are
+ * identified generically by the presence of `stakingRequestId` on the intent —
+ * a required field on BaseStakeIntent in @bitgo/public-types. These intents
+ * have no txParams recipients by design; validation is done at the coin layer.
+ *
+ * Throws InvalidTransactionError if no recipients can be resolved and the
+ * transaction is not a known no-recipient type.
+ *
+ * @param txRequest - the transaction request containing the persisted intent
+ * @param txParams - the caller-supplied transaction parameters (may be undefined)
+ * @param chainName - the base chain name (e.g. 'sol', 'tsol') used to exclude
+ *   native-coin transfers from tokenName; pass baseCoin.getChain()
+ */
+function resolveEffectiveTxParams(txRequest, txParams, chainName) {
+    const intentRecipients = txRequest.intent?.recipients?.map((intentRecipient) => {
+        // Prefer tokenData.tokenName; fall back to amount.symbol when chainName is
+        // provided and differs from it. When absent, skip the symbol fallback.
+        const { symbol } = intentRecipient.amount;
+        const tokenName = intentRecipient.tokenData?.tokenName ||
+            (chainName !== undefined && symbol && symbol !== chainName ? symbol : undefined);
+        return {
+            address: intentRecipient.address.address,
+            amount: intentRecipient.amount.value,
+            data: intentRecipient.data,
+            ...(tokenName && { tokenName }),
+        };
+    });
+    const effectiveTxParams = {
+        ...txParams,
+        recipients: txParams?.recipients?.length ? txParams.recipients : intentRecipients,
+    };
+    // Fall back to intent.intentType when txParams.type is not explicitly set.
+    // Staking wallets call signTransaction without txParams, so the type lives only in the intent.
+    const txType = effectiveTxParams.type ?? txRequest.intent?.intentType ?? '';
+    // Propagate the resolved type so downstream callers
+    if (!effectiveTxParams.type && txType) {
+        effectiveTxParams.type = txType;
+    }
+    // Propagate stakingRequestId from intent into effectiveTxParams so verifyTssTransaction
+    // overrides can bypass the no-recipient guard without needing access to txRequest directly.
+    const intentStakingRequestId = txRequest.intent?.stakingRequestId;
+    if (intentStakingRequestId && !effectiveTxParams.stakingRequestId) {
+        effectiveTxParams.stakingRequestId = intentStakingRequestId;
+    }
+    // All staking intents (BSC delegate/undelegate, CELO stake/unstake, etc.) carry
+    // stakingRequestId as a required field on BaseStakeIntent (@bitgo/public-types).
+    // Use its presence as a generic staking signal — no need to enumerate every intentType.
+    const isStakingIntent = !!txRequest.intent?.stakingRequestId;
+    // buildParams.type from the wallet UI is PascalCase ('Import'); intent.intentType from WP
+    // is lowercase ('import'). Either may be the source of truth depending on the signing path.
+    const intentType = txRequest.intent?.intentType ?? '';
+    if (!effectiveTxParams.recipients?.length &&
+        !isStakingIntent &&
+        !exports.NO_RECIPIENT_TX_TYPES.has(txType) &&
+        !exports.NO_RECIPIENT_TX_TYPES.has(intentType)) {
+        throw new errors_1.InvalidTransactionError('Recipient details are required to verify this transaction before signing. Pass txParams with at least one recipient.');
+    }
+    return effectiveTxParams;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recipientUtils.js","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/recipientUtils.ts"],"names":[],"mappings":";;;AAiIA,4DA8DC;AA9LD,yCAAuD;AAGvD;;;;;;;;;;;;;GAaG;AACU,QAAA,qBAAqB,GAAG,IAAI,GAAG,CAAC;IAC3C,cAAc;IACd,cAAc;IACd,WAAW;IACX,eAAe;IACf,eAAe;IACf,aAAa;IACb,aAAa;IACb,aAAa;IACb,aAAa;IACb,cAAc;IACd,cAAc;IACd,UAAU;IACV,gFAAgF;IAChF,aAAa;IACb,aAAa;IACb,cAAc;IACd,2EAA2E;IAC3E,6EAA6E;IAC7E,uEAAuE;IACvE,8EAA8E;IAC9E,+EAA+E;IAC/E,+DAA+D;IAC/D,6EAA6E;IAC7E,uBAAuB;IACvB,YAAY;IACZ,aAAa;IACb,cAAc;IACd,eAAe;IACf,uFAAuF;IACvF,uFAAuF;IACvF,2CAA2C;IAC3C,aAAa;IACb,MAAM;IACN,QAAQ;IACR,gBAAgB;IAChB,mEAAmE;IACnE,cAAc;IAEd,0FAA0F;IAC1F,+DAA+D;IAC/D,UAAU;IACV,YAAY;IACZ,iBAAiB;IAEjB,8BAA8B;IAC9B,OAAO;IACP,SAAS;IACT,mBAAmB;IACnB,qBAAqB;IACrB,eAAe;IACf,eAAe;IACf,WAAW;IAEX,sFAAsF;IACtF,OAAO;IACP,mBAAmB;IAEnB,eAAe;IACf,wHAAwH;IACxH,gBAAgB;IAChB,gBAAgB;IAChB,wBAAwB;IACxB,wBAAwB;IACxB,oBAAoB;IACpB,0BAA0B;IAC1B,eAAe;IACf,kCAAkC;IAClC,mCAAmC;IACnC,mCAAmC;IACnC,oCAAoC;IAEpC,QAAQ;IAER,6EAA6E;IAC7E,uEAAuE;IACvE,wEAAwE;IACxE,+DAA+D;IAC/D,QAAQ;IACR,WAAW;IAEX,kEAAkE;IAClE,YAAY;IAEZ,wDAAwD;IACxD,WAAW;CACZ,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,SAAgB,wBAAwB,CACtC,SAAoB,EACpB,QAAuC,EACvC,SAAkB;IAElB,MAAM,gBAAgB,GAAI,SAAS,CAAC,MAA0B,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC,eAAe,EAAE,EAAE;QAClG,2EAA2E;QAC3E,uEAAuE;QACvE,MAAM,EAAE,MAAM,EAAE,GAAG,eAAe,CAAC,MAAM,CAAC;QAC1C,MAAM,SAAS,GACb,eAAe,CAAC,SAAS,EAAE,SAAS;YACpC,CAAC,SAAS,KAAK,SAAS,IAAI,MAAM,IAAI,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QACnF,OAAO;YACL,OAAO,EAAE,eAAe,CAAC,OAAO,CAAC,OAAO;YACxC,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC,KAAK;YACpC,IAAI,EAAE,eAAe,CAAC,IAAI;YAC1B,GAAG,CAAC,SAAS,IAAI,EAAE,SAAS,EAAE,CAAC;SAChC,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,MAAM,iBAAiB,GAAsB;QAC3C,GAAG,QAAQ;QACX,UAAU,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,gBAAgB;KAClF,CAAC;IAEF,2EAA2E;IAC3E,+FAA+F;IAC/F,MAAM,MAAM,GAAG,iBAAiB,CAAC,IAAI,IAAK,SAAS,CAAC,MAA0B,EAAE,UAAU,IAAI,EAAE,CAAC;IAEjG,oDAAoD;IACpD,IAAI,CAAC,iBAAiB,CAAC,IAAI,IAAI,MAAM,EAAE,CAAC;QACtC,iBAAiB,CAAC,IAAI,GAAG,MAAM,CAAC;IAClC,CAAC;IAED,wFAAwF;IACxF,4FAA4F;IAC5F,MAAM,sBAAsB,GAAI,SAAS,CAAC,MAA0B,EAAE,gBAAgB,CAAC;IACvF,IAAI,sBAAsB,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,EAAE,CAAC;QAClE,iBAAiB,CAAC,gBAAgB,GAAG,sBAAsB,CAAC;IAC9D,CAAC;IAED,gFAAgF;IAChF,iFAAiF;IACjF,wFAAwF;IACxF,MAAM,eAAe,GAAG,CAAC,CAAE,SAAS,CAAC,MAA0B,EAAE,gBAAgB,CAAC;IAElF,0FAA0F;IAC1F,4FAA4F;IAC5F,MAAM,UAAU,GAAI,SAAS,CAAC,MAA0B,EAAE,UAAU,IAAI,EAAE,CAAC;IAE3E,IACE,CAAC,iBAAiB,CAAC,UAAU,EAAE,MAAM;QACrC,CAAC,eAAe;QAChB,CAAC,6BAAqB,CAAC,GAAG,CAAC,MAAM,CAAC;QAClC,CAAC,6BAAqB,CAAC,GAAG,CAAC,UAAU,CAAC,EACtC,CAAC;QACD,MAAM,IAAI,gCAAuB,CAC/B,sHAAsH,CACvH,CAAC;IACJ,CAAC;IAED,OAAO,iBAAiB,CAAC;AAC3B,CAAC","sourcesContent":["import { TransactionParams } from '../../baseCoin';\nimport { InvalidTransactionError } from '../../errors';\nimport { PopulatedIntent, TxRequest } from './baseTypes';\n\n/**\n * Transaction types that legitimately carry no explicit recipients.\n * These are the intentType strings as stored in TxRequest.intent.intentType by WP.\n * verifyTransaction handles no-recipient validation for these internally.\n * Mirrors the bypass list in abstractEthLikeNewCoins.ts verifyTssTransaction.\n *\n * ECDSA types: acceleration, fillNonce, transferToken, tokenApproval, consolidate,\n *              bridgeFunds, enableToken, customTx, wrapApprove, wrap, unwrap,\n *              finalizeUnwrap, contractCall\n * BSC/BNB delegation-based staking: delegate, undelegate, switchValidator\n * CELO/ETH lock-based staking: stake, unstake, stakeWithCallData, unstakeWithCallData,\n *              transferStake, increaseStake, goUnstake\n * Claim rewards (BSC, CELO — TRX/SOL use EdDSA and are unaffected): claim, stakeClaimRewards\n */\nexport const NO_RECIPIENT_TX_TYPES = new Set([\n  // ECDSA types\n  'acceleration',\n  'fillNonce',\n  'transferToken',\n  'tokenApproval',\n  'consolidate',\n  'bridgeFunds',\n  'enableToken',\n  'enabletoken',\n  'disableToken',\n  'disabletoken',\n  'customTx',\n  // DeFi vault operations — recipients/calldata built server-side from defiParams\n  'defiApprove',\n  'defiDeposit',\n  'defiWithdraw',\n  // Native wrap/unwrap (WETH9 deposit()/withdraw()) — calldata and the WETH9\n  // address are resolved server-side from the vault binding, so no recipients.\n  // Registered in BOTH spellings on purpose: this set is matched against\n  // txParams.type, which is buildParams.type (camelCase, from wallet.sendMany),\n  // AND against intent.intentType (kebab-case, as WP persists it). Signing paths\n  // that carry no txParams — notably pendingApproval.approve() →\n  // recreateTxRequest() → signTxRequest() with no txParams — only ever see the\n  // kebab-case spelling.\n  'wrapNative',\n  'wrap-native',\n  'unwrapNative',\n  'unwrap-native',\n  // ERC-7984 shield/unshield: approve/wrap/unwrap calldata is built server-side from the\n  // intent, and finalizeUnwrap txnReqs are WP-created at READY_TO_FINALIZE (client signs\n  // only) — none carry SDK-level recipients.\n  'wrapApprove',\n  'wrap',\n  'unwrap',\n  'finalizeUnwrap',\n  // Smart contract invocations with no explicit SDK-level recipients\n  'contractCall',\n\n  // BSC/BNB delegation-based staking — intentType strings from TxRequest.intent.intentType.\n  // Note: SOL solDelegateIntent also uses intentType \"delegate\".\n  'delegate',\n  'undelegate',\n  'switchValidator',\n\n  // CELO/ETH lock-based staking\n  'stake',\n  'unstake',\n  'stakeWithCallData',\n  'unstakeWithCallData',\n  'transferStake',\n  'increaseStake',\n  'goUnstake',\n\n  // Claim rewards — BSC and CELO (TRX/SOL/Cosmos use EdDSA, not affected by this guard)\n  'claim',\n  'stakeClaimRewards',\n\n  'createAccount',\n  // Canton operations with no SDK-level recipients. Canton.verifyTransaction validates these from the transaction itself.\n  'transferAccept',\n  'transferReject',\n  'transferOfferWithdrawn',\n  'cosignDelegationAccept',\n  'allocationAllocate',\n  'allocationOfferWithdrawn',\n  'cantonCommand',\n  'cantonEndInvestorOnboardingOffer',\n  'cantonEndInvestorOnboardingAccept',\n  'cantonEndInvestorOnboardingReject',\n  'cantonParticipantOnboardingRequest',\n\n  'pledge',\n\n  // Avalanche / Flare cross-chain atomic imports — recipients are not supplied\n  // by the client because the import consumes UTXOs already owned by the\n  // wallet; the destination address is the wallet itself. WP issues these\n  // with intentType 'import' (P-chain) or 'importtoc' (C-chain).\n  'import',\n  'importtoc',\n\n  // SOL: deactivate stake account — no on-chain transfer recipient.\n  'deactivate',\n\n  // SOL: authorize stake account — no transfer recipient.\n  'authorize',\n]);\n\n/**\n * Resolves the effective txParams for TSS signing recipient verification.\n *\n * For smart contract interactions, recipients live in txRequest.intent.recipients\n * (native amount = 0, so buildParams is empty). Falls back to intent recipients\n * mapped to ITransactionRecipient shape when txParams.recipients is absent.\n *\n * tokenName is derived from tokenData.tokenName when present, otherwise from\n * amount.symbol when chainName is provided and symbol differs from it.\n *\n * Staking intents (BSC delegate/undelegate, CELO stake/unstake, etc.) are\n * identified generically by the presence of `stakingRequestId` on the intent —\n * a required field on BaseStakeIntent in @bitgo/public-types. These intents\n * have no txParams recipients by design; validation is done at the coin layer.\n *\n * Throws InvalidTransactionError if no recipients can be resolved and the\n * transaction is not a known no-recipient type.\n *\n * @param txRequest - the transaction request containing the persisted intent\n * @param txParams - the caller-supplied transaction parameters (may be undefined)\n * @param chainName - the base chain name (e.g. 'sol', 'tsol') used to exclude\n *   native-coin transfers from tokenName; pass baseCoin.getChain()\n */\nexport function resolveEffectiveTxParams(\n  txRequest: TxRequest,\n  txParams: TransactionParams | undefined,\n  chainName?: string\n): TransactionParams {\n  const intentRecipients = (txRequest.intent as PopulatedIntent)?.recipients?.map((intentRecipient) => {\n    // Prefer tokenData.tokenName; fall back to amount.symbol when chainName is\n    // provided and differs from it. When absent, skip the symbol fallback.\n    const { symbol } = intentRecipient.amount;\n    const tokenName =\n      intentRecipient.tokenData?.tokenName ||\n      (chainName !== undefined && symbol && symbol !== chainName ? symbol : undefined);\n    return {\n      address: intentRecipient.address.address,\n      amount: intentRecipient.amount.value,\n      data: intentRecipient.data,\n      ...(tokenName && { tokenName }),\n    };\n  });\n\n  const effectiveTxParams: TransactionParams = {\n    ...txParams,\n    recipients: txParams?.recipients?.length ? txParams.recipients : intentRecipients,\n  };\n\n  // Fall back to intent.intentType when txParams.type is not explicitly set.\n  // Staking wallets call signTransaction without txParams, so the type lives only in the intent.\n  const txType = effectiveTxParams.type ?? (txRequest.intent as PopulatedIntent)?.intentType ?? '';\n\n  // Propagate the resolved type so downstream callers\n  if (!effectiveTxParams.type && txType) {\n    effectiveTxParams.type = txType;\n  }\n\n  // Propagate stakingRequestId from intent into effectiveTxParams so verifyTssTransaction\n  // overrides can bypass the no-recipient guard without needing access to txRequest directly.\n  const intentStakingRequestId = (txRequest.intent as PopulatedIntent)?.stakingRequestId;\n  if (intentStakingRequestId && !effectiveTxParams.stakingRequestId) {\n    effectiveTxParams.stakingRequestId = intentStakingRequestId;\n  }\n\n  // All staking intents (BSC delegate/undelegate, CELO stake/unstake, etc.) carry\n  // stakingRequestId as a required field on BaseStakeIntent (@bitgo/public-types).\n  // Use its presence as a generic staking signal — no need to enumerate every intentType.\n  const isStakingIntent = !!(txRequest.intent as PopulatedIntent)?.stakingRequestId;\n\n  // buildParams.type from the wallet UI is PascalCase ('Import'); intent.intentType from WP\n  // is lowercase ('import'). Either may be the source of truth depending on the signing path.\n  const intentType = (txRequest.intent as PopulatedIntent)?.intentType ?? '';\n\n  if (\n    !effectiveTxParams.recipients?.length &&\n    !isStakingIntent &&\n    !NO_RECIPIENT_TX_TYPES.has(txType) &&\n    !NO_RECIPIENT_TX_TYPES.has(intentType)\n  ) {\n    throw new InvalidTransactionError(\n      'Recipient details are required to verify this transaction before signing. Pass txParams with at least one recipient.'\n    );\n  }\n\n  return effectiveTxParams;\n}\n"]}

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

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

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

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

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

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedpallasMPCv2SMCUtils = void 0;
+const assert_1 = __importDefault(require("assert"));
+const public_types_1 = require("@bitgo/public-types");
+const __1 = require("../../../..");
+const redpallasMPCv2_1 = require("../redpallasMPCv2");
+const redpallasMPCv2KeyGenSender_1 = require("../redpallasMPCv2KeyGenSender");
+/**
+ * Custodial (SMC/OVC) DKG-only key generation for the Zcash Orchard shielded pool (RedPallas).
+ *
+ * Mirrors for both custodial and SMC wallet
+ * ceremonies driven by external OVC (offline vault console) clients: round1/round2 payloads are
+ * relayed from OVC1/OVC2 to BitGo and back. There is no round3 (no signing) - RedPallas MPS DKG
+ * completes key generation in 2 online rounds, same as EdDSA MPS DKG.
+ */
+class RedpallasMPCv2SMCUtils {
+    constructor(bitgo, baseCoin) {
+        this.bitgo = bitgo;
+        this.baseCoin = baseCoin;
+        this.MPCv2Utils = new redpallasMPCv2_1.RedpallasMPCv2Utils(bitgo, baseCoin);
+    }
+    async keyGenRound1(enterprise, payload) {
+        return this.keyGenRound1BySender((0, redpallasMPCv2KeyGenSender_1.RedpallasKeyGenSenderForEnterprise)(this.bitgo, enterprise), payload);
+    }
+    async keyGenRound2(enterprise, payload) {
+        return this.keyGenRound2BySender((0, redpallasMPCv2KeyGenSender_1.RedpallasKeyGenSenderForEnterprise)(this.bitgo, enterprise), payload);
+    }
+    async keyGenRound1BySender(senderFn, payload) {
+        (0, assert_1.default)(payload.state === public_types_1.RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data, `Invalid state for round 1, expected: ${public_types_1.RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data}, got: ${payload.state}`);
+        (0, __1.decodeOrElse)(public_types_1.RedpallasOVC1ToBitgoRound1Payload.name, public_types_1.RedpallasOVC1ToBitgoRound1Payload, payload, (errors) => {
+            throw new Error(`error(s) parsing payload: ${errors}`);
+        });
+        const ovc1 = payload.ovc[public_types_1.OVCIndexEnum.ONE];
+        const ovc2 = payload.ovc[public_types_1.OVCIndexEnum.TWO];
+        const result = await this.MPCv2Utils.sendKeyGenerationRound1BySender(senderFn, {
+            userGpgPublicKey: ovc1.gpgPubKey,
+            backupGpgPublicKey: ovc2.gpgPubKey,
+            userMsg1: ovc1.ovcMsg1,
+            backupMsg1: ovc2.ovcMsg1,
+        });
+        const response = {
+            state: public_types_1.RedpallasKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data,
+            tssVersion: payload.tssVersion,
+            walletType: payload.walletType,
+            coin: payload.coin,
+            ovc: payload.ovc,
+            platform: {
+                sessionId: result.sessionId,
+                bitgoMsg1: result.bitgoMsg1,
+            },
+        };
+        return (0, __1.decodeOrElse)(public_types_1.RedpallasBitgoToOVC1Round1Response.name, public_types_1.RedpallasBitgoToOVC1Round1Response, response, (errors) => {
+            throw new Error(`error(s) parsing response: ${errors}`);
+        });
+    }
+    async keyGenRound2BySender(senderFn, payload) {
+        (0, assert_1.default)(payload.state === public_types_1.RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data, `Invalid state for round 2, expected: ${public_types_1.RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data}, got: ${payload.state}`);
+        (0, __1.decodeOrElse)(public_types_1.RedpallasOVC2ToBitgoRound2Payload.name, public_types_1.RedpallasOVC2ToBitgoRound2Payload, payload, (errors) => {
+            throw new Error(`error(s) parsing payload: ${errors}`);
+        });
+        const ovc1 = payload.ovc[public_types_1.OVCIndexEnum.ONE];
+        const ovc2 = payload.ovc[public_types_1.OVCIndexEnum.TWO];
+        const sessionId = payload.platform.sessionId;
+        const result = await this.MPCv2Utils.sendKeyGenerationRound2BySender(senderFn, {
+            sessionId,
+            userMsg2: ovc1.ovcMsg2,
+            backupMsg2: ovc2.ovcMsg2,
+        });
+        assert_1.default.equal(sessionId, result.sessionId, 'Round 1 and round 2 session IDs do not match');
+        const keychains = this.baseCoin.keychains();
+        const bitgoKeychain = await keychains.add({
+            source: 'bitgo',
+            keyType: 'tss',
+            commonKeychain: result.commonPublicKeychain,
+            isMPCv2: true,
+        });
+        const response = {
+            state: public_types_1.RedpallasKeyCreationMPCv2StateEnum.WaitingForOVC1GenerateKey,
+            bitGoKeyId: bitgoKeychain.id,
+            tssVersion: payload.tssVersion,
+            walletType: payload.walletType,
+            coin: payload.coin,
+            ovc: payload.ovc,
+            platform: {
+                // sessionId/bitgoMsg1 carried over from payload.platform; safe because the assert
+                // above guarantees payload.platform.sessionId equals result.sessionId.
+                ...payload.platform,
+                commonPublicKeychain: result.commonPublicKeychain,
+                bitgoMsg2: result.bitgoMsg2,
+            },
+        };
+        return (0, __1.decodeOrElse)(public_types_1.RedpallasBitgoToOVC1Round2Response.name, public_types_1.RedpallasBitgoToOVC1Round2Response, response, (errors) => {
+            throw new Error(`error(s) parsing response: ${errors}`);
+        });
+    }
+    async uploadClientKeys(bitgoKeyId, userCommonKeychain, backupCommonKeychain) {
+        (0, assert_1.default)(userCommonKeychain === backupCommonKeychain, 'Common keychain mismatch between the user and backup keychains');
+        const keychains = this.baseCoin.keychains();
+        const bitgoKeychain = await keychains.get({ id: bitgoKeyId });
+        (0, assert_1.default)(bitgoKeychain, 'Keychain not found');
+        (0, assert_1.default)(bitgoKeychain.source === 'bitgo', 'The keychain is not a BitGo keychain');
+        (0, assert_1.default)(bitgoKeychain.type === 'tss', 'BitGo keychain is not a TSS keychain');
+        (0, assert_1.default)(bitgoKeychain.commonKeychain, 'BitGo keychain does not have a common keychain');
+        (0, assert_1.default)(bitgoKeychain.commonKeychain === userCommonKeychain, 'Common keychain mismatch between the OVCs and BitGo');
+        const userKeychainPromise = keychains.add({
+            source: 'user',
+            keyType: 'tss',
+            commonKeychain: userCommonKeychain,
+            isMPCv2: true,
+        });
+        const backupKeychainPromise = keychains.add({
+            source: 'backup',
+            keyType: 'tss',
+            commonKeychain: backupCommonKeychain,
+            isMPCv2: true,
+        });
+        const [userKeychain, backupKeychain] = await Promise.all([userKeychainPromise, backupKeychainPromise]);
+        return { userKeychain, backupKeychain, bitgoKeychain };
+    }
+}
+exports.RedpallasMPCv2SMCUtils = RedpallasMPCv2SMCUtils;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../src/bitgo/utils/tss/redpallas/SMC/utils.ts"],"names":[],"mappings":";;;;;;AAAA,oDAA4B;AAC5B,sDAS6B;AAG7B,mCAAqD;AACrD,sDAAwD;AACxD,8EAA+G;AAE/G;;;;;;;GAOG;AACH,MAAa,sBAAsB;IAGjC,YAAoB,KAAgB,EAAU,QAAmB;QAA7C,UAAK,GAAL,KAAK,CAAW;QAAU,aAAQ,GAAR,QAAQ,CAAW;QAC/D,IAAI,CAAC,UAAU,GAAG,IAAI,oCAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAC7D,CAAC;IAEM,KAAK,CAAC,YAAY,CACvB,UAAkB,EAClB,OAA0C;QAE1C,OAAO,IAAI,CAAC,oBAAoB,CAAC,IAAA,+DAAkC,EAAC,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,EAAE,OAAO,CAAC,CAAC;IACxG,CAAC;IAEM,KAAK,CAAC,YAAY,CACvB,UAAkB,EAClB,OAA0C;QAE1C,OAAO,IAAI,CAAC,oBAAoB,CAAC,IAAA,+DAAkC,EAAC,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,EAAE,OAAO,CAAC,CAAC;IACxG,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAC/B,QAAwE,EACxE,OAA0C;QAE1C,IAAA,gBAAM,EACJ,OAAO,CAAC,KAAK,KAAK,iDAAkC,CAAC,yBAAyB,EAC9E,wCAAwC,iDAAkC,CAAC,yBAAyB,UAAU,OAAO,CAAC,KAAK,EAAE,CAC9H,CAAC;QACF,IAAA,gBAAY,EAAC,gDAAiC,CAAC,IAAI,EAAE,gDAAiC,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE;YAC1G,MAAM,IAAI,KAAK,CAAC,6BAA6B,MAAM,EAAE,CAAC,CAAC;QACzD,CAAC,CAAC,CAAC;QAEH,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,2BAAY,CAAC,GAAG,CAAC,CAAC;QAC3C,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,2BAAY,CAAC,GAAG,CAAC,CAAC;QAC3C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,+BAA+B,CAAC,QAAQ,EAAE;YAC7E,gBAAgB,EAAE,IAAI,CAAC,SAAS;YAChC,kBAAkB,EAAE,IAAI,CAAC,SAAS;YAClC,QAAQ,EAAE,IAAI,CAAC,OAAO;YACtB,UAAU,EAAE,IAAI,CAAC,OAAO;SACzB,CAAC,CAAC;QAEH,MAAM,QAAQ,GAAG;YACf,KAAK,EAAE,iDAAkC,CAAC,wBAAwB;YAClE,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,GAAG,EAAE,OAAO,CAAC,GAAG;YAChB,QAAQ,EAAE;gBACR,SAAS,EAAE,MAAM,CAAC,SAAS;gBAC3B,SAAS,EAAE,MAAM,CAAC,SAAS;aAC5B;SACF,CAAC;QAEF,OAAO,IAAA,gBAAY,EACjB,iDAAkC,CAAC,IAAI,EACvC,iDAAkC,EAClC,QAAQ,EACR,CAAC,MAAM,EAAE,EAAE;YACT,MAAM,IAAI,KAAK,CAAC,8BAA8B,MAAM,EAAE,CAAC,CAAC;QAC1D,CAAC,CACF,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAC/B,QAAwE,EACxE,OAA0C;QAE1C,IAAA,gBAAM,EACJ,OAAO,CAAC,KAAK,KAAK,iDAAkC,CAAC,yBAAyB,EAC9E,wCAAwC,iDAAkC,CAAC,yBAAyB,UAAU,OAAO,CAAC,KAAK,EAAE,CAC9H,CAAC;QACF,IAAA,gBAAY,EAAC,gDAAiC,CAAC,IAAI,EAAE,gDAAiC,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE;YAC1G,MAAM,IAAI,KAAK,CAAC,6BAA6B,MAAM,EAAE,CAAC,CAAC;QACzD,CAAC,CAAC,CAAC;QAEH,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,2BAAY,CAAC,GAAG,CAAC,CAAC;QAC3C,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,2BAAY,CAAC,GAAG,CAAC,CAAC;QAC3C,MAAM,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC;QAC7C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,+BAA+B,CAAC,QAAQ,EAAE;YAC7E,SAAS;YACT,QAAQ,EAAE,IAAI,CAAC,OAAO;YACtB,UAAU,EAAE,IAAI,CAAC,OAAO;SACzB,CAAC,CAAC;QAEH,gBAAM,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,8CAA8C,CAAC,CAAC;QAE1F,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;QAC5C,MAAM,aAAa,GAAG,MAAM,SAAS,CAAC,GAAG,CAAC;YACxC,MAAM,EAAE,OAAO;YACf,OAAO,EAAE,KAAK;YACd,cAAc,EAAE,MAAM,CAAC,oBAAoB;YAC3C,OAAO,EAAE,IAAI;SACd,CAAC,CAAC;QAEH,MAAM,QAAQ,GAAG;YACf,KAAK,EAAE,iDAAkC,CAAC,yBAAyB;YACnE,UAAU,EAAE,aAAa,CAAC,EAAE;YAC5B,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,GAAG,EAAE,OAAO,CAAC,GAAG;YAChB,QAAQ,EAAE;gBACR,kFAAkF;gBAClF,uEAAuE;gBACvE,GAAG,OAAO,CAAC,QAAQ;gBACnB,oBAAoB,EAAE,MAAM,CAAC,oBAAoB;gBACjD,SAAS,EAAE,MAAM,CAAC,SAAS;aAC5B;SACF,CAAC;QAEF,OAAO,IAAA,gBAAY,EACjB,iDAAkC,CAAC,IAAI,EACvC,iDAAkC,EAClC,QAAQ,EACR,CAAC,MAAM,EAAE,EAAE;YACT,MAAM,IAAI,KAAK,CAAC,8BAA8B,MAAM,EAAE,CAAC,CAAC;QAC1D,CAAC,CACF,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,gBAAgB,CAC3B,UAAkB,EAClB,kBAA0B,EAC1B,oBAA4B;QAE5B,IAAA,gBAAM,EACJ,kBAAkB,KAAK,oBAAoB,EAC3C,gEAAgE,CACjE,CAAC;QAEF,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;QAC5C,MAAM,aAAa,GAAG,MAAM,SAAS,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;QAC9D,IAAA,gBAAM,EAAC,aAAa,EAAE,oBAAoB,CAAC,CAAC;QAC5C,IAAA,gBAAM,EAAC,aAAa,CAAC,MAAM,KAAK,OAAO,EAAE,sCAAsC,CAAC,CAAC;QACjF,IAAA,gBAAM,EAAC,aAAa,CAAC,IAAI,KAAK,KAAK,EAAE,sCAAsC,CAAC,CAAC;QAC7E,IAAA,gBAAM,EAAC,aAAa,CAAC,cAAc,EAAE,gDAAgD,CAAC,CAAC;QACvF,IAAA,gBAAM,EAAC,aAAa,CAAC,cAAc,KAAK,kBAAkB,EAAE,qDAAqD,CAAC,CAAC;QAEnH,MAAM,mBAAmB,GAAG,SAAS,CAAC,GAAG,CAAC;YACxC,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,KAAK;YACd,cAAc,EAAE,kBAAkB;YAClC,OAAO,EAAE,IAAI;SACd,CAAC,CAAC;QACH,MAAM,qBAAqB,GAAG,SAAS,CAAC,GAAG,CAAC;YAC1C,MAAM,EAAE,QAAQ;YAChB,OAAO,EAAE,KAAK;YACd,cAAc,EAAE,oBAAoB;YACpC,OAAO,EAAE,IAAI;SACd,CAAC,CAAC;QAEH,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,mBAAmB,EAAE,qBAAqB,CAAC,CAAC,CAAC;QACvG,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,CAAC;IACzD,CAAC;CACF;AA3JD,wDA2JC","sourcesContent":["import assert from 'assert';\nimport {\n  OVCIndexEnum,\n  RedpallasBitgoToOVC1Round1Response,\n  RedpallasBitgoToOVC1Round2Response,\n  RedpallasKeyCreationMPCv2StateEnum,\n  RedpallasMPCv2KeyGenRound1Response,\n  RedpallasMPCv2KeyGenRound2Response,\n  RedpallasOVC1ToBitgoRound1Payload,\n  RedpallasOVC2ToBitgoRound2Payload,\n} from '@bitgo/public-types';\nimport { IBaseCoin } from '../../../../baseCoin';\nimport { BitGoBase } from '../../../../bitgoBase';\nimport { decodeOrElse, Keychain } from '../../../..';\nimport { RedpallasMPCv2Utils } from '../redpallasMPCv2';\nimport { RedpallasMPCv2KeyGenSendFn, RedpallasKeyGenSenderForEnterprise } from '../redpallasMPCv2KeyGenSender';\n\n/**\n * Custodial (SMC/OVC) DKG-only key generation for the Zcash Orchard shielded pool (RedPallas).\n *\n * Mirrors for both custodial and SMC wallet\n * ceremonies driven by external OVC (offline vault console) clients: round1/round2 payloads are\n * relayed from OVC1/OVC2 to BitGo and back. There is no round3 (no signing) - RedPallas MPS DKG\n * completes key generation in 2 online rounds, same as EdDSA MPS DKG.\n */\nexport class RedpallasMPCv2SMCUtils {\n  private MPCv2Utils: RedpallasMPCv2Utils;\n\n  constructor(private bitgo: BitGoBase, private baseCoin: IBaseCoin) {\n    this.MPCv2Utils = new RedpallasMPCv2Utils(bitgo, baseCoin);\n  }\n\n  public async keyGenRound1(\n    enterprise: string,\n    payload: RedpallasOVC1ToBitgoRound1Payload\n  ): Promise<RedpallasBitgoToOVC1Round1Response> {\n    return this.keyGenRound1BySender(RedpallasKeyGenSenderForEnterprise(this.bitgo, enterprise), payload);\n  }\n\n  public async keyGenRound2(\n    enterprise: string,\n    payload: RedpallasOVC2ToBitgoRound2Payload\n  ): Promise<RedpallasBitgoToOVC1Round2Response> {\n    return this.keyGenRound2BySender(RedpallasKeyGenSenderForEnterprise(this.bitgo, enterprise), payload);\n  }\n\n  public async keyGenRound1BySender(\n    senderFn: RedpallasMPCv2KeyGenSendFn<RedpallasMPCv2KeyGenRound1Response>,\n    payload: RedpallasOVC1ToBitgoRound1Payload\n  ): Promise<RedpallasBitgoToOVC1Round1Response> {\n    assert(\n      payload.state === RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data,\n      `Invalid state for round 1, expected: ${RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data}, got: ${payload.state}`\n    );\n    decodeOrElse(RedpallasOVC1ToBitgoRound1Payload.name, RedpallasOVC1ToBitgoRound1Payload, payload, (errors) => {\n      throw new Error(`error(s) parsing payload: ${errors}`);\n    });\n\n    const ovc1 = payload.ovc[OVCIndexEnum.ONE];\n    const ovc2 = payload.ovc[OVCIndexEnum.TWO];\n    const result = await this.MPCv2Utils.sendKeyGenerationRound1BySender(senderFn, {\n      userGpgPublicKey: ovc1.gpgPubKey,\n      backupGpgPublicKey: ovc2.gpgPubKey,\n      userMsg1: ovc1.ovcMsg1,\n      backupMsg1: ovc2.ovcMsg1,\n    });\n\n    const response = {\n      state: RedpallasKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data,\n      tssVersion: payload.tssVersion,\n      walletType: payload.walletType,\n      coin: payload.coin,\n      ovc: payload.ovc,\n      platform: {\n        sessionId: result.sessionId,\n        bitgoMsg1: result.bitgoMsg1,\n      },\n    };\n\n    return decodeOrElse(\n      RedpallasBitgoToOVC1Round1Response.name,\n      RedpallasBitgoToOVC1Round1Response,\n      response,\n      (errors) => {\n        throw new Error(`error(s) parsing response: ${errors}`);\n      }\n    );\n  }\n\n  public async keyGenRound2BySender(\n    senderFn: RedpallasMPCv2KeyGenSendFn<RedpallasMPCv2KeyGenRound2Response>,\n    payload: RedpallasOVC2ToBitgoRound2Payload\n  ): Promise<RedpallasBitgoToOVC1Round2Response> {\n    assert(\n      payload.state === RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data,\n      `Invalid state for round 2, expected: ${RedpallasKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data}, got: ${payload.state}`\n    );\n    decodeOrElse(RedpallasOVC2ToBitgoRound2Payload.name, RedpallasOVC2ToBitgoRound2Payload, payload, (errors) => {\n      throw new Error(`error(s) parsing payload: ${errors}`);\n    });\n\n    const ovc1 = payload.ovc[OVCIndexEnum.ONE];\n    const ovc2 = payload.ovc[OVCIndexEnum.TWO];\n    const sessionId = payload.platform.sessionId;\n    const result = await this.MPCv2Utils.sendKeyGenerationRound2BySender(senderFn, {\n      sessionId,\n      userMsg2: ovc1.ovcMsg2,\n      backupMsg2: ovc2.ovcMsg2,\n    });\n\n    assert.equal(sessionId, result.sessionId, 'Round 1 and round 2 session IDs do not match');\n\n    const keychains = this.baseCoin.keychains();\n    const bitgoKeychain = await keychains.add({\n      source: 'bitgo',\n      keyType: 'tss',\n      commonKeychain: result.commonPublicKeychain,\n      isMPCv2: true,\n    });\n\n    const response = {\n      state: RedpallasKeyCreationMPCv2StateEnum.WaitingForOVC1GenerateKey,\n      bitGoKeyId: bitgoKeychain.id,\n      tssVersion: payload.tssVersion,\n      walletType: payload.walletType,\n      coin: payload.coin,\n      ovc: payload.ovc,\n      platform: {\n        // sessionId/bitgoMsg1 carried over from payload.platform; safe because the assert\n        // above guarantees payload.platform.sessionId equals result.sessionId.\n        ...payload.platform,\n        commonPublicKeychain: result.commonPublicKeychain,\n        bitgoMsg2: result.bitgoMsg2,\n      },\n    };\n\n    return decodeOrElse(\n      RedpallasBitgoToOVC1Round2Response.name,\n      RedpallasBitgoToOVC1Round2Response,\n      response,\n      (errors) => {\n        throw new Error(`error(s) parsing response: ${errors}`);\n      }\n    );\n  }\n\n  public async uploadClientKeys(\n    bitgoKeyId: string,\n    userCommonKeychain: string,\n    backupCommonKeychain: string\n  ): Promise<{ userKeychain: Keychain; backupKeychain: Keychain; bitgoKeychain: Keychain }> {\n    assert(\n      userCommonKeychain === backupCommonKeychain,\n      'Common keychain mismatch between the user and backup keychains'\n    );\n\n    const keychains = this.baseCoin.keychains();\n    const bitgoKeychain = await keychains.get({ id: bitgoKeyId });\n    assert(bitgoKeychain, 'Keychain not found');\n    assert(bitgoKeychain.source === 'bitgo', 'The keychain is not a BitGo keychain');\n    assert(bitgoKeychain.type === 'tss', 'BitGo keychain is not a TSS keychain');\n    assert(bitgoKeychain.commonKeychain, 'BitGo keychain does not have a common keychain');\n    assert(bitgoKeychain.commonKeychain === userCommonKeychain, 'Common keychain mismatch between the OVCs and BitGo');\n\n    const userKeychainPromise = keychains.add({\n      source: 'user',\n      keyType: 'tss',\n      commonKeychain: userCommonKeychain,\n      isMPCv2: true,\n    });\n    const backupKeychainPromise = keychains.add({\n      source: 'backup',\n      keyType: 'tss',\n      commonKeychain: backupCommonKeychain,\n      isMPCv2: true,\n    });\n\n    const [userKeychain, backupKeychain] = await Promise.all([userKeychainPromise, backupKeychainPromise]);\n    return { userKeychain, backupKeychain, bitgoKeychain };\n  }\n}\n"]}

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

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

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./redpallasMPCv2"), exports);
+__exportStar(require("./redpallasMPCv2KeyGenSender"), exports);
+__exportStar(require("./SMC/utils"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYml0Z28vdXRpbHMvdHNzL3JlZHBhbGxhcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsbURBQWlDO0FBQ2pDLCtEQUE2QztBQUM3Qyw4Q0FBNEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3JlZHBhbGxhc01QQ3YyJztcbmV4cG9ydCAqIGZyb20gJy4vcmVkcGFsbGFzTVBDdjJLZXlHZW5TZW5kZXInO1xuZXhwb3J0ICogZnJvbSAnLi9TTUMvdXRpbHMnO1xuIl19

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

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

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

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

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

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

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

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

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

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

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

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