fix: missing params broadcast fail on musig eth rec

Author: mtexeira-simtlix

src/api/enclaved/handlers/recoveryMultisigTransaction.ts

@@ -3,8 +3,13 @@ import { MethodNotImplementedError } from 'bitgo';
 import { EnclavedApiSpecRouteRequest } from '../../../enclavedBitgoExpress/routers/enclavedApiSpec';
 import logger from '../../../logger';
 import { isEthLikeCoin } from '../../../shared/coinUtils';
+import {
+  addEthLikeRecoveryExtras,
+  getDefaultMusigEthGasParams,
+  getReplayProtectionOptions,
+} from '../../../shared/recoveryUtils';
+import { SignedEthLikeRecoveryTx } from '../../../types/transaction';
 import { retrieveKmsPrvKey } from '../utils';
-import { HalfSignedEthLikeRecoveryTx } from '../../../types/transaction';
 
 export async function recoveryMultisigTransaction(
   req: EnclavedApiSpecRouteRequest<'v1.multisig.recovery', 'post'>,
@@ -29,28 +34,79 @@ export async function recoveryMultisigTransaction(
   if (coin.isEVM()) {
     // Every recovery method on every coin family varies one from another so we need to ensure with a guard.
     if (isEthLikeCoin(coin)) {
+      const walletKeys = unsignedSweepPrebuildTx.xpubxWithDerivationPath;
+      const pubs = [walletKeys?.user?.xpub, walletKeys?.backup?.xpub, walletKeys?.bitgo?.xpub];
+      const { gasPrice, gasLimit, maxFeePerGas, maxPriorityFeePerGas } =
+        getDefaultMusigEthGasParams();
+
       try {
-        const halfSignedTx = await coin.signTransaction({
+        const halfSignedTxBase = await coin.signTransaction({
           isLastSignature: false,
           prv: userPrv,
-          txPrebuild: { ...unsignedSweepPrebuildTx } as unknown as SignFinalOptions,
+          pubs,
+          keyList: walletKeys,
+          recipients: unsignedSweepPrebuildTx.recipients ?? [],
+          expireTime: unsignedSweepPrebuildTx.expireTime,
+          signingKeyNonce: unsignedSweepPrebuildTx.signingKeyNonce,
+          gasPrice,
+          gasLimit,
+          eip1559: {
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+          },
+          replayProtectionOptions: getReplayProtectionOptions(
+            unsignedSweepPrebuildTx.replayProtectionOptions,
+          ),
+          txPrebuild: {
+            ...unsignedSweepPrebuildTx,
+            gasPrice,
+            gasLimit,
+            eip1559: {
+              maxFeePerGas,
+              maxPriorityFeePerGas,
+            },
+            replayProtectionOptions: getReplayProtectionOptions(
+              unsignedSweepPrebuildTx.replayProtectionOptions,
+            ),
+          },
           walletContractAddress,
         });
 
-        const { halfSigned } = halfSignedTx as HalfSignedEthLikeRecoveryTx;
+        const halfSignedTx = addEthLikeRecoveryExtras({
+          signedTx: halfSignedTxBase as SignedEthLikeRecoveryTx,
+          transaction: unsignedSweepPrebuildTx,
+          isLastSignature: false,
+          replayProtectionOptions: unsignedSweepPrebuildTx.replayProtectionOptions,
+        });
+
+        const { halfSigned } = halfSignedTx;
         const fullSignedTx = await coin.signTransaction({
           isLastSignature: true,
           prv: backupPrv,
+          pubs,
+          keyList: walletKeys,
+          recipients: halfSignedTx.recipients ?? [],
+          expireTime: halfSigned?.expireTime,
+          signingKeyNonce: halfSigned?.backupKeyNonce,
+          gasPrice,
+          gasLimit,
           txPrebuild: {
             ...halfSignedTx,
-            txHex: halfSigned.signatures,
+            txHex: halfSigned?.txHex,
             halfSigned,
-            recipients: halfSigned.recipients ?? [],
+            recipients: halfSigned?.recipients ?? [],
+            gasPrice,
+            gasLimit,
+            eip1559: {
+              maxFeePerGas,
+              maxPriorityFeePerGas,
+            },
+            replayProtectionOptions: getReplayProtectionOptions(
+              halfSignedTx?.replayProtectionOptions,
+            ),
           } as unknown as SignFinalOptions,
           walletContractAddress,
-          signingKeyNonce: halfSigned.signingKeyNonce ?? 0,
-          backupKeyNonce: halfSigned.backupKeyNonce ?? 0,
-          recipients: halfSigned.recipients ?? [],
+          backupKeyNonce: halfSigned?.backupKeyNonce ?? 0,
         });
 
         return fullSignedTx;

src/api/master/handlers/recoveryWallet.ts

@@ -1,5 +1,9 @@
 import { MethodNotImplementedError } from 'bitgo';
 import { isEthLikeCoin } from '../../../shared/coinUtils';
+import {
+  getDefaultMusigEthGasParams,
+  getReplayProtectionOptions,
+} from '../../../shared/recoveryUtils';
 import { MasterApiSpecRouteRequest } from '../routers/masterApiSpec';
 
 export async function handleRecoveryWalletOnPrem(
@@ -31,9 +35,19 @@ export async function handleRecoveryWalletOnPrem(
 
   if (isEthLikeCoin(sdkCoin)) {
     try {
+      const { gasLimit, gasPrice, maxFeePerGas, maxPriorityFeePerGas } =
+        getDefaultMusigEthGasParams();
       const unsignedSweepPrebuildTx = await sdkCoin.recover({
         ...commonRecoveryParams,
+        gasPrice,
+        gasLimit,
+        eip1559: {
+          maxFeePerGas,
+          maxPriorityFeePerGas,
+        },
+        replayProtectionOptions: getReplayProtectionOptions(),
       });
+
       const fullSignedRecoveryTx = await enclavedExpressClient.recoveryMultisig({
         userPub,
         backupPub,

src/shared/recoveryUtils.ts

@@ -0,0 +1,77 @@
+import type { ReplayProtectionOptions, SignedEthLikeRecoveryTx } from '../types/transaction';
+
+export function addEthLikeRecoveryExtras({
+  signedTx,
+  transaction,
+  isLastSignature,
+  replayProtectionOptions,
+}: {
+  signedTx: SignedEthLikeRecoveryTx;
+  transaction: any; // Same type as UnsignedSweepPrebuildTx
+  isLastSignature: boolean;
+  replayProtectionOptions: ReplayProtectionOptions | undefined;
+}) {
+  const decoratedSignedTx = { ...signedTx };
+  if (signedTx.signatures) {
+    decoratedSignedTx.isFullSigned = true;
+  }
+  if (transaction.feeInfo) {
+    decoratedSignedTx.feeInfo = transaction.feeInfo;
+  }
+  if (transaction.coin) {
+    decoratedSignedTx.coin = transaction.coin;
+  }
+  if (transaction.gasPrice) {
+    decoratedSignedTx.gasPrice = transaction.gasPrice;
+  }
+  if (transaction.gasLimit) {
+    decoratedSignedTx.gasLimit = transaction.gasLimit;
+  }
+
+  if (transaction.eip1559) {
+    decoratedSignedTx.eip1559 = transaction.eip1559;
+  }
+  if (transaction.gasPrice && transaction.gasLimit) {
+    decoratedSignedTx.feesUsed = {
+      gasPrice: transaction.gasPrice,
+      gasLimit: transaction.gasLimit,
+    };
+  }
+  if (transaction.isEvmBasedCrossChainRecovery) {
+    decoratedSignedTx.isEvmBasedCrossChainRecovery = transaction.isEvmBasedCrossChainRecovery;
+  }
+  if (transaction.amount) {
+    decoratedSignedTx.amount = transaction.amount;
+  }
+  if (!isLastSignature) {
+    decoratedSignedTx.isHalfSigned = true;
+    decoratedSignedTx.backupKeyNonce =
+      'backupKeyNonce' in transaction
+        ? transaction.backupKeyNonce
+        : transaction.nextContractSequenceId;
+    decoratedSignedTx.walletContractAddress = transaction.walletContractAddress;
+    decoratedSignedTx.replayProtectionOptions = getReplayProtectionOptions(replayProtectionOptions);
+  }
+
+  return decoratedSignedTx;
+}
+
+export function getReplayProtectionOptions(
+  replayProtectionOptions: ReplayProtectionOptions | undefined = undefined,
+): ReplayProtectionOptions {
+  return (
+    replayProtectionOptions ?? {
+      chain: 17000, // 1 if mainnet, 17000 if testnet
+      hardfork: 'london',
+    }
+  );
+}
+
+export function getDefaultMusigEthGasParams() {
+  return {
+    gasPrice: 20000000000,
+    gasLimit: 200000,
+    maxFeePerGas: 20000000000,
+    maxPriorityFeePerGas: 10000000000,
+  };
+}

src/types/transaction.ts

@@ -1,10 +1,35 @@
 import { type Recipient, type SignedTransaction } from 'bitgo';
 
-export type HalfSignedEthLikeRecoveryTx = SignedTransaction & {
-  halfSigned: {
+export type SignedEthLikeRecoveryTx = SignedTransaction & {
+  signatures?: string;
+  halfSigned?: {
     signatures?: string;
     recipients?: Recipient[];
     signingKeyNonce?: number;
     backupKeyNonce?: number;
+    expireTime?: number;
+    txHex?: string;
   };
+  replayProtectionOptions?: ReplayProtectionOptions;
+  recipients?: Recipient[];
+  isFullSigned?: boolean;
+  isHalfSigned?: boolean;
+  backupKeyNonce?: number;
+  walletContractAddress?: string;
+  amount?: string;
+  isEvmBasedCrossChainRecovery?: boolean;
+  feesUsed?: {
+    gasPrice: number;
+    gasLimit: number;
+  };
+  gasLimit?: number;
+  coin?: string;
+  gasPrice?: number;
+  feeInfo?: any;
+  eip1559?: any;
+};
+
+export type ReplayProtectionOptions = {
+  chain: number; // 1 if mainnet, 17000 if testnet
+  hardfork: string;
 };