feat(mbe): fix rebase

Author: cpatino-intive

src/api/master/handlers/recoveryWallet.ts

@@ -1,170 +1,65 @@
-import { BaseCoin, MethodNotImplementedError } from 'bitgo';
-
-import { AbstractEthLikeNewCoins } from '@bitgo/abstract-eth';
-import { AbstractUtxoCoin } from '@bitgo/abstract-utxo';
-
-import {
-  isEthLikeCoin,
-  isFormattedOfflineVaultTxInfo,
-  isUtxoCoin,
-} from '../../../shared/coinUtils';
-import {
-  DEFAULT_MUSIG_ETH_GAS_PARAMS,
-  getReplayProtectionOptions,
-} from '../../../shared/recoveryUtils';
-import { EnvironmentName } from '../../../shared/types/index';
-import { EnclavedExpressClient } from '../clients/enclavedExpressClient';
 import { MasterApiSpecRouteRequest } from '../routers/masterApiSpec';
-
-interface RecoveryParams {
-  userKey: string;
-  backupKey: string;
-  walletContractAddress: string;
-  recoveryDestination: string;
-  apiKey: string;
-}
-
-interface EnclavedRecoveryParams {
-  userPub: string;
-  backupPub: string;
-  apiKey: string;
-  unsignedSweepPrebuildTx: any; // TODO: type this properly once we have the SDK types
-  coinSpecificParams: any;
-  walletContractAddress: string;
-}
-
-async function handleEthLikeRecovery(
-  sdkCoin: BaseCoin,
-  commonRecoveryParams: RecoveryParams,
-  enclavedExpressClient: any,
-  params: EnclavedRecoveryParams,
-  env: EnvironmentName,
+import logger from '../../../logger';
+import { isSolCoin } from '../../../shared/coinUtils';
+import { MPCTx } from 'bitgo';
+import { RecoveryTransaction } from '@bitgo/sdk-coin-trx';
+
+// Handler for recovery from receive addresses (consolidation sweeps)
+export async function handleRecoveryConsolidationsOnPrem(
+  req: MasterApiSpecRouteRequest<'v1.wallet.recoveryConsolidations', 'post'>,
 ) {
-  try {
-    const { gasLimit, gasPrice, maxFeePerGas, maxPriorityFeePerGas } = DEFAULT_MUSIG_ETH_GAS_PARAMS;
-    const unsignedSweepPrebuildTx = await (sdkCoin as AbstractEthLikeNewCoins).recover({
-      ...commonRecoveryParams,
-      gasPrice,
-      gasLimit,
-      eip1559: {
-        maxFeePerGas,
-        maxPriorityFeePerGas,
-      },
-      replayProtectionOptions: getReplayProtectionOptions(env),
-    });
+  const bitgo = req.bitgo;
+  const coin = req.decoded.coin;
+  const enclavedExpressClient = req.enclavedExpressClient;
 
-    const fullSignedRecoveryTx = await enclavedExpressClient.recoveryMultisig({
-      ...params,
-      unsignedSweepPrebuildTx,
-    });
+  const { userPub, backupPub, bitgoPub } = req.decoded;
 
-    return fullSignedRecoveryTx;
-  } catch (err) {
-    throw err;
+  const sdkCoin = bitgo.coin(coin);
+  let txs: MPCTx[] | RecoveryTransaction[] = [];
+  // 1. Build unsigned consolidations
+  if (isSolCoin(sdkCoin) && !req.decoded.durableNonces) {
+    throw new Error('durableNonces is required for Solana consolidation recovery');
   }
-}
-
-export type UtxoCoinSpecificRecoveryParams = Pick<
-  Parameters<AbstractUtxoCoin['recover']>[0],
-  | 'apiKey'
-  | 'userKey'
-  | 'backupKey'
-  | 'bitgoKey'
-  | 'ignoreAddressTypes'
-  | 'scan'
-  | 'feeRate'
-  | 'recoveryDestination'
->;
 
-async function handleUtxoLikeRecovery(
-  sdkCoin: BaseCoin,
-  enclavedClient: EnclavedExpressClient,
-  recoveryParams: UtxoCoinSpecificRecoveryParams,
-): Promise<{ txHex: string }> {
-  const abstractUtxoCoin = sdkCoin as unknown as AbstractUtxoCoin;
-  const recoverTx = await abstractUtxoCoin.recover(recoveryParams);
-
-  console.log('UTXO recovery transaction created:', recoverTx);
-  if (!isFormattedOfflineVaultTxInfo(recoverTx)) {
-    throw new MethodNotImplementedError(`Unknown transaction ${JSON.stringify(recoverTx)} created`);
+  if (typeof (sdkCoin as any).recoverConsolidations !== 'function') {
+    throw new Error(`recoverConsolidations is not supported for coin: ${coin}`);
   }
 
-  return (await enclavedClient.recoveryMultisig({
-    userPub: recoveryParams.userKey,
-    backupPub: recoveryParams.backupKey,
-    bitgoPub: recoveryParams.bitgoKey,
-    unsignedSweepPrebuildTx: recoverTx,
-    walletContractAddress: '',
-  })) as { txHex: string };
-}
-
-export async function handleRecoveryWalletOnPrem(
-  req: MasterApiSpecRouteRequest<'v1.wallet.recovery', 'post'>,
-) {
-  const bitgo = req.bitgo;
-  const coin = req.decoded.coin;
-  const enclavedExpressClient = req.enclavedExpressClient;
-
-  const {
-    userPub,
-    backupPub,
-    bitgoPub,
-    walletContractAddress,
-    recoveryDestinationAddress,
-    coinSpecificParams,
-    apiKey,
-  } = req.decoded;
-
-  //construct a common payload for the recovery that it's repeated in any kind of recovery
-  const commonRecoveryParams: RecoveryParams = {
+  // Use type assertion to access recoverConsolidations
+  const result = await (sdkCoin as any).recoverConsolidations({
+    ...req.decoded,
     userKey: userPub,
     backupKey: backupPub,
-    walletContractAddress,
-    recoveryDestination: recoveryDestinationAddress,
-    apiKey,
-  };
-
-  const sdkCoin = bitgo.coin(coin);
-
-  // Check if the public key is valid
-  if (!sdkCoin.isValidPub(userPub)) {
-    throw new Error('Invalid user public key format');
-  } else if (!sdkCoin.isValidPub(backupPub)) {
-    throw new Error('Invalid backup public');
+    bitgoKey: bitgoPub,
+    durableNonces: req.decoded.durableNonces,
+  });
+
+  if ('transactions' in result) {
+    txs = result.transactions;
+  } else if ('txRequests' in result) {
+    txs = result.txRequests;
+  } else {
+    throw new Error('recoverConsolidations did not return expected transactions');
   }
 
-  if (isEthLikeCoin(sdkCoin)) {
-    return handleEthLikeRecovery(
-      sdkCoin,
-      commonRecoveryParams,
-      enclavedExpressClient,
-      {
+  logger.debug(`Found ${txs.length} unsigned consolidation transactions`);
+
+  // 2. For each unsigned sweep, get it signed by EBE (using recoveryMultisig)
+  const signedTxs = [];
+  try {
+    for (const tx of txs) {
+      const signedTx = await enclavedExpressClient.recoveryMultisig({
         userPub,
         backupPub,
-        apiKey,
-        unsignedSweepPrebuildTx: undefined,
-        coinSpecificParams: undefined,
-        walletContractAddress,
-      },
-      bitgo.env as EnvironmentName,
-    );
-  }
-  if (!bitgoPub) {
-    throw new Error('BitGo public key is required for recovery');
-  }
+        unsignedSweepPrebuildTx: tx,
+        walletContractAddress: '',
+      });
+      signedTxs.push(signedTx);
+    }
 
-  if (isUtxoCoin(sdkCoin)) {
-    return handleUtxoLikeRecovery(sdkCoin, req.enclavedExpressClient, {
-      userKey: userPub,
-      backupKey: backupPub,
-      bitgoKey: bitgoPub,
-      ignoreAddressTypes: coinSpecificParams?.ignoreAddressTypes ?? [],
-      scan: coinSpecificParams?.addressScan,
-      feeRate: coinSpecificParams?.feeRate,
-      recoveryDestination: recoveryDestinationAddress,
-      apiKey,
-    });
+    return { signedTxs };
+  } catch (err) {
+    logger.error('Error during consolidation recovery:', err);
+    throw err;
   }
-
-  throw new MethodNotImplementedError('Recovery wallet is not supported for this coin: ' + coin);
 }

src/api/master/routers/masterApiSpec.ts

@@ -24,6 +24,7 @@ import { handleRecoveryWalletOnPrem } from '../handlers/recoveryWallet';
 import { handleConsolidate } from '../handlers/handleConsolidate';
 import { handleAccelerate } from '../handlers/handleAccelerate';
 import { handleConsolidateUnspents } from '../handlers/handleConsolidateUnspents';
+import { handleRecoveryConsolidationsOnPrem } from '../handlers/recoveryConsolidationsWallet';
 
 // Middleware functions
 export function parseBody(req: express.Request, res: express.Response, next: express.NextFunction) {
@@ -187,6 +188,26 @@ const RecoveryWalletRequest = {
 
 export type RecoveryWalletRequest = typeof RecoveryWalletRequest;
 
+const RecoveryConsolidationsWalletRequest = {
+  userPub: t.string,
+  backupPub: t.string,
+  bitgoPub: t.union([t.undefined, t.string]),
+  walletContractAddress: t.string,
+  recoveryDestinationAddress: t.string,
+  apiKey: t.string,
+  durableNonces: t.union([t.undefined, t.boolean]),
+};
+
+// Response type for /recoveryconsolidations endpoint
+const RecoveryConsolidationsWalletResponse: HttpResponse = {
+  200: t.any,
+  500: t.type({
+    error: t.string,
+    details: t.string,
+  }),
+};
+
+
 export const ConsolidateUnspentsRequest = {
   pubkey: t.string,
   source: t.union([t.literal('user'), t.literal('backup')]),
@@ -263,6 +284,20 @@ export const MasterApiSpec = apiSpec({
       description: 'Recover an existing wallet',
     }),
   },
+  'v1.wallet.recoveryConsolidations': {
+    post: httpRoute({
+      method: 'POST',
+      path: '/api/{coin}/wallet/recoveryconsolidations',
+      request: httpRequest({
+        params: {
+          coin: t.string,
+        },
+        body: RecoveryConsolidationsWalletRequest,
+      }),
+      response: RecoveryConsolidationsWalletResponse,
+      description: 'Consolidate and recover an existing wallet',
+    }),
+  },
   'v1.wallet.consolidate': {
     post: httpRoute({
       method: 'POST',
@@ -368,6 +403,14 @@ export function createMasterApiRouter(
     }),
   ]);
 
+  router.post('v1.wallet.recoveryConsolidations', [
+    responseHandler<MasterExpressConfig>(async (req: express.Request) => {
+      const typedReq = req as GenericMasterApiSpecRouteRequest;
+      const result = await handleRecoveryConsolidationsOnPrem(typedReq);
+      return Response.ok(result);
+    }),
+  ]);
+
   router.post('v1.wallet.accelerate', [
     responseHandler<MasterExpressConfig>(async (req: express.Request) => {
       const typedReq = req as GenericMasterApiSpecRouteRequest;