WIP: draft for eddsa recvoery

Author: mohammadalfaiyazbitgo

package.json

@@ -27,6 +27,11 @@
     "@api-ts/typed-express-router": "^1.1.13",
     "@bitgo/sdk-core": "^35.3.0",
     "@bitgo-beta/sdk-lib-mpc": "8.2.1-alpha.291",
+    "@bitgo/sdk-coin-ada": "^4.11.5",
+    "@bitgo/sdk-coin-dot": "^4.3.5",
+    "@bitgo/sdk-coin-sui": "^5.15.5",
+    "@bitgo/sdk-coin-near": "^2.7.0",
+    "@bitgo/sdk-coin-sol": "^4.12.5",
     "bitgo": "^48.1.0",
     "@bitgo/abstract-utxo": "^9.21.4",
     "@bitgo/statics": "^54.6.0",
@@ -44,6 +49,9 @@
     "winston": "^3.11.0",
     "zod": "^3.25.48"
   },
+  "resolutions": {
+    "@bitgo/sdk-core": "^35.3.0"
+  },
   "devDependencies": {
     "@api-ts/openapi-generator": "^5.7.0",
     "@types/body-parser": "^1.17.0",

src/__tests__/masterBitgoExpress/generateWallet.test.ts

@@ -0,0 +1,113 @@
+import { BitGoAPI } from '@bitgo/sdk-api';
+import { retrieveKmsPrvKey } from '../utils';
+import { EnclavedConfig } from '../../../shared/types';
+import { BaseCoin, Eddsa, YShare, SigningMaterial } from '@bitgo/sdk-core';
+import { Ed25519Bip32HdTree } from '@bitgo/sdk-lib-mpc';
+import { CoinFamily, coins } from '@bitgo/statics';
+
+export type SignEddsaRecoveryTransactionParams = {
+  sdk: BitGoAPI;
+  request: {
+    commonKeychain: string;
+    signableHex: string;
+    derivationPath: string;
+  };
+  cfg: EnclavedConfig;
+  coin: BaseCoin;
+};
+
+export async function signEddsaRecoveryTransaction({
+  sdk,
+  cfg,
+  request,
+  coin
+}: SignEddsaRecoveryTransactionParams) {
+  let txBuilder;
+  switch (coin.getFamily()) {
+    case CoinFamily.NEAR: {
+      const { TransactionBuilderFactory, register } = await import('@bitgo/sdk-coin-near');
+      register(sdk);
+      const staticCoin = coins.get(coin.getFamily());
+      txBuilder =  new TransactionBuilderFactory(staticCoin).from(request.signableHex);
+      break;
+    } case CoinFamily.SOL: {
+
+    }
+    default: {
+      throw new Error();
+    }
+  }
+  // Get user and backup private keys
+  const userPrv = await retrieveKmsPrvKey({
+    pub: request.commonKeychain.toString(),
+    source: 'user',
+    cfg,
+    options: { useLocalEncipherment: false },
+  });
+
+  const backupPrv = await retrieveKmsPrvKey({
+    pub: request.commonKeychain.toString(),
+    source: 'backup',
+    cfg,
+    options: { useLocalEncipherment: false },
+  });
+
+  if (!userPrv || !backupPrv) {
+    throw new Error('Missing required private keys for recovery');
+  }
+
+  const userSigningMaterial = JSON.parse(userPrv) as SigningMaterial;
+  const backupSigningMaterial = JSON.parse(backupPrv) as SigningMaterial;
+
+  // Initialize MPC components
+  const hdTree = await Ed25519Bip32HdTree.initialize();
+  const MPC = await Eddsa.initialize(hdTree);
+
+  // Get the first transaction request
+  const messageBuffer = Buffer.from(request.signableHex, 'hex');
+
+  // Derive user subkey
+  const userSubkey = MPC.keyDerive(
+    userSigningMaterial.uShare,
+    [userSigningMaterial.bitgoYShare, userSigningMaterial.backupYShare as YShare],
+    request.derivationPath,
+  );
+
+  // Combine backup subkey
+  const backupSubkey = MPC.keyCombine(backupSigningMaterial.uShare, [
+    userSubkey.yShares[2],
+    backupSigningMaterial.bitgoYShare,
+  ]);
+
+  // Create partial signatures
+  const userSignShare = MPC.signShare(messageBuffer, userSubkey.pShare, [userSubkey.yShares[2]]);
+
+  const backupSignShare = MPC.signShare(messageBuffer, backupSubkey.pShare, [
+    backupSubkey.jShares[1],
+  ]);
+
+  // Sign with both keys
+  const userSign = MPC.sign(
+    messageBuffer,
+    userSignShare.xShare,
+    [backupSignShare.rShares[1]],
+    [userSigningMaterial.bitgoYShare],
+  );
+
+  const backupSign = MPC.sign(
+    messageBuffer,
+    backupSignShare.xShare,
+    [userSignShare.rShares[2]],
+    [backupSigningMaterial.bitgoYShare],
+  );
+
+  // Combine signatures
+  const signature = MPC.signCombine([userSign, backupSign]);
+
+  return {
+    txHex: Buffer.concat([
+      Buffer.from(signature.R, 'hex'),
+      Buffer.from(signature.sigma, 'hex'),
+    ]).toString('hex'),
+  };
+}

src/api/enclaved/handlers/signEddsaRecoveryTransaction.ts

@@ -13,6 +13,9 @@ import {
   GShare,
   Keychain,
   ApiKeyShare,
+  MPCSweepTxs,
+  MPCTx,
+  MPCTxs,
 } from '@bitgo/sdk-core';
 import { superagentRequestFactory, buildApiClient, ApiClient } from '@api-ts/superagent-wrapper';
 import { OfflineVaultTxInfo, RecoveryInfo, UnsignedSweepTxMPCv2 } from '@bitgo/sdk-coin-eth';
@@ -173,6 +176,72 @@ interface SignMpcV2Round3Response {
 }
 
 export class EnclavedExpressClient {
+  async recoveryMPC(params: {
+    unsignedSweepPrebuildTx: MPCTx | MPCSweepTxs | MPCTxs;
+    userPub: string;
+    backupPub: string;
+    apiKey: string;
+    coinSpecificParams: any;
+    walletContractAddress: string;
+  }): Promise<SignedTransaction> {
+    if (!this.coin) {
+      throw new Error('Coin must be specified to recover MPC');
+    }
+
+    try {
+      debugLogger('Recovering MPC for coin: %s', this.coin);
+
+      // Extract the required information from the sweep tx
+      const tx = params.unsignedSweepPrebuildTx;
+      const txRequest = {
+        unsignedTx: '',
+        signableHex: '',
+        derivationPath: '',
+      };
+
+      // Handle different tx formats
+      if ('txRequests' in tx && Array.isArray(tx.txRequests)) {
+        // MPCTxs format
+        const firstRequest = tx.txRequests[0];
+        if (firstRequest && firstRequest.transactions && firstRequest.transactions[0]) {
+          const firstTx = firstRequest.transactions[0];
+          txRequest.signableHex = firstTx.unsignedTx?.serializedTx || '';
+          txRequest.derivationPath = firstTx.unsignedTx?.derivationPath || '';
+        }
+      } else if ('signableHex' in tx) {
+        // MPCTx format
+        txRequest.signableHex = tx.signableHex || '';
+        txRequest.derivationPath = tx.derivationPath || '';
+      } else if (Array.isArray(tx) && tx.length > 0) {
+        // MPCSweepTxs format
+        const firstTx = tx[0];
+        if (firstTx && firstTx.transactions && firstTx.transactions[0]) {
+          const transaction = firstTx.transactions[0];
+          txRequest.signableHex = transaction.unsignedTx?.signableHex || '';
+          txRequest.derivationPath = transaction.unsignedTx?.derivationPath || '';
+        }
+      }
+
+      let request = this.apiClient['v1.mpc.recovery'].post({
+        coin: this.coin,
+        commonKeychain: params.userPub,
+        unsignedSweepPrebuildTx: {
+          txRequests: [txRequest],
+        },
+      });
+
+      if (this.tlsMode === TlsMode.MTLS) {
+        request = request.agent(this.createHttpsAgent());
+      }
+
+      const response = await request.decodeExpecting(200);
+      return response.body;
+    } catch (error) {
+      const err = error as Error;
+      debugLogger('Failed to recover MPC: %s', err.message);
+      throw err;
+    }
+  }
   private readonly baseUrl: string;
   private readonly enclavedExpressCert: string;
   private readonly tlsKey?: string;

src/api/master/clients/enclavedExpressClient.ts

@@ -0,0 +1,55 @@
+import { BaseCoin, MPCRecoveryOptions, MPCSweepTxs, MPCTx, MPCTxs } from 'bitgo';
+import { BitGoBase } from '@bitgo/sdk-core';
+import { CoinFamily } from '@bitgo/statics';
+import type { SolRecoveryOptions } from '@bitgo/sdk-coin-sol';
+import type { Sol, Tsol } from '@bitgo/sdk-coin-sol';
+import type { Near, TNear } from '@bitgo/sdk-coin-near';
+import type { Sui, Tsui } from '@bitgo/sdk-coin-sui';
+import type { Ada, Tada } from '@bitgo/sdk-coin-ada';
+import type { Dot, Tdot } from '@bitgo/sdk-coin-dot';
+
+export type RecoverEddsaWalletsParams = MPCRecoveryOptions | SolRecoveryOptions;
+
+export async function recoverEddsaWallets(
+  sdk: BitGoBase,
+  baseCoin: BaseCoin,
+  params: RecoverEddsaWalletsParams,
+): Promise<MPCTx | MPCSweepTxs | MPCTxs> {
+  const family = baseCoin.getFamily();
+
+  switch (family) {
+    case CoinFamily.SOL: {
+      const { register } = await import('@bitgo/sdk-coin-sol');
+      register(sdk);
+      const solCoin = baseCoin as unknown as Sol | Tsol;
+      const solParams = params as SolRecoveryOptions;
+      return await solCoin.recover(solParams);
+    }
+    case CoinFamily.NEAR: {
+      const { register } = await import('@bitgo/sdk-coin-near');
+      register(sdk);
+      const nearCoin = baseCoin as unknown as Near | TNear;
+      const nearParams: Parameters<Near['recover']>[0] = {
+        userKey: params.bitgoKey,
+        backupKey: params.bitgoKey,
+        bitgoKey: params.bitgoKey,
+        recoveryDestination: params.recoveryDestination,
+        walletPassphrase: '',
+      };
+      return await nearCoin.recover(nearParams);
+    }
+    default: {
+      const [{ register: registerSui }, { register: registerAda }, { register: registerDot }] =
+        await Promise.all([
+          import('@bitgo/sdk-coin-sui'),
+          import('@bitgo/sdk-coin-ada'),
+          import('@bitgo/sdk-coin-dot'),
+        ]);
+      registerAda(sdk);
+      registerSui(sdk);
+      registerDot(sdk);
+      const coin = baseCoin as unknown as Sui | Tsui | Ada | Tada | Dot | Tdot;
+      return await coin.recover(params as MPCRecoveryOptions);
+    }
+  }
+}

src/api/master/handlers/recoverEddsaWallets.ts

@@ -1,9 +1,10 @@
-import { BaseCoin, MethodNotImplementedError } from 'bitgo';
+import { BaseCoin, BitGoAPI, MethodNotImplementedError } from 'bitgo';
 
 import { AbstractEthLikeNewCoins } from '@bitgo/abstract-eth';
 import { AbstractUtxoCoin } from '@bitgo/abstract-utxo';
 
 import {
+  isEddsaCoin,
   isEthLikeCoin,
   isFormattedOfflineVaultTxInfo,
   isUtxoCoin,
@@ -12,9 +13,10 @@ 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';
+import { recoverEddsaWallets } from './recoverEddsaWallets';
+import { EnvironmentName } from '../../../shared/types';
 
 interface RecoveryParams {
   userKey: string;
@@ -64,6 +66,51 @@ async function handleEthLikeRecovery(
   }
 }
 
+// function getKeyNonceFromParams(
+//   coinSpecificParams: EnclavedRecoveryParams['coinSpecificParams'] | undefined,
+// ) {
+//   // formatted as in WRW
+//   if (!coinSpecificParams) return undefined;
+//
+//   const { publicKeyNonce, secretKeyNonce } = coinSpecificParams;
+//   if (!publicKeyNonce || !secretKeyNonce) return undefined;
+//
+//   // coinSpecificParams is untyped so we need to cast the keys in order to avoid build errors.
+//   return { publicKey: publicKeyNonce as string, secretKey: secretKeyNonce as string };
+// }
+
+async function handleEddsaRecovery(
+  bitgo: BitGoAPI,
+  sdkCoin: BaseCoin,
+  commonRecoveryParams: RecoveryParams,
+  enclavedExpressClient: EnclavedExpressClient,
+  params: EnclavedRecoveryParams,
+) {
+  const { recoveryDestination, userKey } = commonRecoveryParams;
+  try {
+    const unsignedSweepPrebuildTx = await recoverEddsaWallets(bitgo, sdkCoin, {
+      bitgoKey: userKey,
+      recoveryDestination,
+      apiKey: params.apiKey,
+    });
+    console.log('Unsigned sweep tx');
+    console.log(JSON.stringify(unsignedSweepPrebuildTx, null, 2));
+
+    const fullSignedRecoveryTx = await enclavedExpressClient.recoveryMPC({
+      userPub: params.userPub,
+      backupPub: params.backupPub,
+      apiKey: params.apiKey,
+      unsignedSweepPrebuildTx,
+      coinSpecificParams: params.coinSpecificParams,
+      walletContractAddress: params.walletContractAddress,
+    });
+
+    return fullSignedRecoveryTx;
+  } catch (err) {
+    throw err;
+  }
+}
+
 export type UtxoCoinSpecificRecoveryParams = Pick<
   Parameters<AbstractUtxoCoin['recover']>[0],
   | 'apiKey'
@@ -113,7 +160,10 @@ export async function handleRecoveryWalletOnPrem(
     recoveryDestinationAddress,
     coinSpecificParams,
     apiKey,
+    isTssRecovery,
+    commonKeychain,
   } = req.decoded;
+  console.log(req.decoded);
 
   //construct a common payload for the recovery that it's repeated in any kind of recovery
   const commonRecoveryParams: RecoveryParams = {
@@ -126,6 +176,33 @@ export async function handleRecoveryWalletOnPrem(
 
   const sdkCoin = bitgo.coin(coin);
 
+  if (isTssRecovery) {
+    if (!commonKeychain) {
+      throw new Error('Common keychain is required for TSS recovery');
+    }
+    if (isEddsaCoin(sdkCoin)) {
+      const tx = await handleEddsaRecovery(
+        req.bitgo,
+        sdkCoin,
+        commonRecoveryParams,
+        enclavedExpressClient,
+        {
+          userPub: commonKeychain,
+          backupPub: commonKeychain,
+          apiKey: '',
+          walletContractAddress: '',
+          unsignedSweepPrebuildTx: undefined,
+          coinSpecificParams: undefined,
+        },
+      );
+      return tx;
+    } else {
+      throw new MethodNotImplementedError(
+        `TSS recovery is not implemented for coin: ${coin}. Supported coins are Eddsa coins.`,
+      );
+    }
+  }
+
   // Check if the public key is valid
   if (!sdkCoin.isValidPub(userPub)) {
     throw new Error('Invalid user public key format');