feat: add multisig generate wallet API for MBE

Ticket: WP-4378

Author: pranavjain97

src/masterBitgoExpress/generateWallet.ts

@@ -0,0 +1,128 @@
+import {
+  GenerateWalletOptions,
+  promiseProps,
+  RequestTracer,
+  SupplementGenerateWalletOptions,
+  Keychain,
+  KeychainsTriplet,
+  Wallet,
+  WalletWithKeychains,
+  AddKeychainOptions,
+} from '@bitgo/sdk-core';
+import { createEnclavedExpressClient } from './enclavedExpressClient';
+import _ from 'lodash';
+import { BitGoRequest } from '../types/request';
+
+/**
+ * This route is used to generate a multisig wallet when enclaved express is enabled
+ */
+export async function handleGenerateWalletOnPrem(req: BitGoRequest) {
+  const bitgo = req.bitgo;
+  const baseCoin = bitgo.coin(req.params.coin);
+
+  const enclavedExpressClient = createEnclavedExpressClient(req.params.coin);
+  if (!enclavedExpressClient) {
+    throw new Error(
+      'Enclaved express client not configured - enclaved express features will be disabled',
+    );
+  }
+
+  const params = req.body as GenerateWalletOptions;
+  const reqId = new RequestTracer();
+
+  // Assign the default multiSig type value based on the coin
+  if (!params.multisigType) {
+    params.multisigType = baseCoin.getDefaultMultisigType();
+  }
+
+  if (typeof params.label !== 'string') {
+    throw new Error('missing required string parameter label');
+  }
+
+  const { label, enterprise } = params;
+
+  // Create wallet parameters with type assertion to allow 'onprem' subtype
+  const walletParams = {
+    label: label,
+    m: 2,
+    n: 3,
+    keys: [],
+    type: 'cold',
+    subType: 'onprem',
+    multisigType: 'onchain',
+  } as unknown as SupplementGenerateWalletOptions; // TODO: Add onprem to the SDK subType and remove "unknown" type casting
+
+  if (!_.isUndefined(enterprise)) {
+    if (!_.isString(enterprise)) {
+      throw new Error('invalid enterprise argument, expecting string');
+    }
+    walletParams.enterprise = enterprise;
+  }
+
+  const userKeychainPromise = async (): Promise<Keychain> => {
+    const userKeychain = await enclavedExpressClient.createIndependentKeychain({
+      source: 'user',
+      coin: req.params.coin,
+      type: 'independent',
+    });
+    const userKeychainParams: AddKeychainOptions = {
+      pub: userKeychain.pub,
+      keyType: userKeychain.type,
+      source: userKeychain.source,
+      reqId,
+    };
+
+    const newUserKeychain = await baseCoin.keychains().add(userKeychainParams);
+    return _.extend({}, newUserKeychain, userKeychain);
+  };
+
+  const backupKeychainPromise = async (): Promise<Keychain> => {
+    const backupKeychain = await enclavedExpressClient.createIndependentKeychain({
+      source: 'backup',
+      coin: req.params.coin,
+      type: 'independent',
+    });
+    const backupKeychainParams: AddKeychainOptions = {
+      pub: backupKeychain.pub,
+      keyType: backupKeychain.type,
+      source: backupKeychain.source,
+      reqId,
+    };
+
+    const newBackupKeychain = await baseCoin.keychains().add(backupKeychainParams);
+    return _.extend({}, newBackupKeychain, backupKeychain);
+  };
+
+  const { userKeychain, backupKeychain, bitgoKeychain }: KeychainsTriplet = await promiseProps({
+    userKeychain: userKeychainPromise(),
+    backupKeychain: backupKeychainPromise(),
+    bitgoKeychain: baseCoin.keychains().createBitGo({
+      enterprise: params.enterprise,
+      reqId,
+      isDistributedCustody: params.isDistributedCustody,
+    }),
+  });
+
+  walletParams.keys = [userKeychain.id, backupKeychain.id, bitgoKeychain.id];
+
+  const keychains = {
+    userKeychain,
+    backupKeychain,
+    bitgoKeychain,
+  };
+
+  const finalWalletParams = await baseCoin.supplementGenerateWallet(walletParams, keychains);
+
+  bitgo.setRequestTracer(reqId);
+  const newWallet = await bitgo.post(baseCoin.url('/wallet/add')).send(finalWalletParams).result();
+
+  const result: WalletWithKeychains = {
+    wallet: new Wallet(bitgo, baseCoin, newWallet),
+    userKeychain: userKeychain,
+    backupKeychain: backupKeychain,
+    bitgoKeychain: bitgoKeychain,
+    responseType: 'WalletWithKeychains',
+  };
+
+  return { ...result, wallet: result.wallet.toJSON() };
+}

src/masterExpressApp.ts

@@ -7,8 +7,11 @@ import https from 'https';
 import http from 'http';
 import superagent from 'superagent';
 import { BitGo, BitGoOptions } from 'bitgo';
+import { BitGoBase } from '@bitgo/sdk-core';
+import { version } from 'bitgo/package.json';
 
 import { MasterExpressConfig, config, isMasterExpressConfig } from './config';
+import { BitGoRequest } from './types/request';
 import {
   setupLogging,
   setupDebugNamespaces,
@@ -25,18 +28,11 @@ import bodyParser from 'body-parser';
 import { ProxyAgent } from 'proxy-agent';
 import { promiseWrapper } from './routes';
 import pjson from '../package.json';
-import { createEnclavedExpressClient } from './masterBitgoExpress/enclavedExpressClient';
+import { handleGenerateWalletOnPrem } from './masterBitgoExpress/generateWallet';
 
 const debugLogger = debug('master-express:express');
-const { version } = require('bitgo/package.json');
 const BITGOEXPRESS_USER_AGENT = `BitGoExpress/${pjson.version} BitGoJS/${version}`;
 
-// Add this interface before the startup function
-interface BitGoRequest extends express.Request {
-  bitgo: BitGo;
-  config: MasterExpressConfig;
-}
-
 /**
  * Create a startup function which will be run upon server initialization
  */
@@ -58,16 +54,6 @@ function isSSL(config: MasterExpressConfig): boolean {
   return Boolean((keyPath && crtPath) || (sslKey && sslCert));
 }
 
-/**
- *
- * @param status
- * @param result
- * @param message
- */
-function apiResponse(status: number, result: any, message: string): ApiResponseError {
-  return new ApiResponseError(message, status, result);
-}
-
 const expressJSONParser = bodyParser.json({ limit: '20mb' });
 
 /**
@@ -120,7 +106,7 @@ function prepareBitGo(config: MasterExpressConfig) {
         : {}),
     };
 
-    (req as BitGoRequest).bitgo = new BitGo(bitgoConstructorParams);
+    (req as BitGoRequest).bitgo = new BitGo(bitgoConstructorParams) as unknown as BitGoBase;
     (req as BitGoRequest).config = config;
 
     next();
@@ -179,16 +165,18 @@ function setupMasterExpressRoutes(app: express.Application): void {
   // Setup common health check routes
   setupHealthCheckRoutes(app, 'master express');
 
+  const cfg = config() as MasterExpressConfig;
+  console.log('SSL Enabled:', cfg.enableSSL);
+  console.log('Enclaved Express URL:', cfg.enclavedExpressUrl);
+  console.log('Certificate exists:', Boolean(cfg.enclavedExpressSSLCert));
+  console.log('Certificate length:', cfg.enclavedExpressSSLCert.length);
+  console.log('Certificate content:', cfg.enclavedExpressSSLCert);
+
   // Add enclaved express ping route
   app.get('/ping/enclavedExpress', async (req, res) => {
-    const cfg = config() as MasterExpressConfig;
     try {
       console.log('Pinging enclaved express');
-      console.log('SSL Enabled:', cfg.enableSSL);
-      console.log('Enclaved Express URL:', cfg.enclavedExpressUrl);
-      console.log('Certificate exists:', Boolean(cfg.enclavedExpressSSLCert));
-      console.log('Certificate length:', cfg.enclavedExpressSSLCert.length);
-      console.log('Certificate content:', cfg.enclavedExpressSSLCert);
+
       const response = await superagent
         .get(`${cfg.enclavedExpressUrl}/ping`)
         .ca(cfg.enclavedExpressSSLCert)
@@ -213,6 +201,14 @@ function setupMasterExpressRoutes(app: express.Application): void {
     }
   });
 
+  // TODO: Add api-ts to these new API routes
+  app.post(
+    '/api/:coin/wallet/generate',
+    parseBody,
+    prepareBitGo(config() as MasterExpressConfig),
+    promiseWrapper(handleGenerateWalletOnPrem),
+  );
+
   // Add a catch-all for unsupported routes
   app.use('*', (_req, res) => {
     res.status(404).json({

src/types/request.ts

@@ -0,0 +1,12 @@
+/**
+ * @prettier
+ */
+import express from 'express';
+import { BitGoBase } from '@bitgo/sdk-core';
+import { MasterExpressConfig } from '../types';
+
+// Extended request type for BitGo Express
+export interface BitGoRequest extends express.Request {
+  bitgo: BitGoBase;
+  config: MasterExpressConfig;
+}