wip(mbe): migrate generate wallet to api-ts

Ticket: WP-46222

Author: mohammadalfaiyazbitgo

src/masterBitgoExpress/generateWallet.ts

@@ -8,6 +8,7 @@ import {
   Wallet,
   WalletWithKeychains,
   AddKeychainOptions,
+  BitGoBase,
 } from '@bitgo/sdk-core';
 import { createEnclavedExpressClient } from './enclavedExpressClient';
 import _ from 'lodash';
@@ -117,7 +118,7 @@ export async function handleGenerateWalletOnPrem(req: BitGoRequest) {
   const newWallet = await bitgo.post(baseCoin.url('/wallet/add')).send(finalWalletParams).result();
 
   const result: WalletWithKeychains = {
-    wallet: new Wallet(bitgo, baseCoin, newWallet),
+    wallet: new Wallet(bitgo as unknown as BitGoBase, baseCoin, newWallet),
     userKeychain: userKeychain,
     backupKeychain: backupKeychain,
     bitgoKeychain: bitgoKeychain,

src/masterBitgoExpress/routers/multiSig.ts

@@ -0,0 +1,167 @@
+import * as t from 'io-ts';
+import { apiSpec, httpRoute, httpRequest, HttpResponse } from '@api-ts/io-ts-http';
+import { createRouter, type WrappedRouter } from '@api-ts/typed-express-router';
+import { Response } from '@api-ts/response';
+import express, { Request } from 'express';
+import { BitGo } from 'bitgo';
+import { BitGoRequest, isBitGoRequest } from '../../types/request';
+import { MasterExpressConfig } from '../../config';
+import { handleGenerateWalletOnPrem } from '../generateWallet';
+import { withResponseHandler } from '../../shared/responseHandler';
+
+// Middleware functions
+export function parseBody(req: express.Request, res: express.Response, next: express.NextFunction) {
+  req.headers['content-type'] = req.headers['content-type'] || 'application/json';
+  return express.json({ limit: '20mb' })(req, res, next);
+}
+
+export function prepareBitGo(config: MasterExpressConfig) {
+  const { env, customRootUri } = config;
+  const BITGOEXPRESS_USER_AGENT = `BitGoExpress/${process.env.npm_package_version}`;
+
+  return function prepBitGo(
+    req: express.Request,
+    res: express.Response,
+    next: express.NextFunction,
+  ) {
+    let accessToken;
+    if (req.headers.authorization) {
+      const authSplit = req.headers.authorization.split(' ');
+      if (authSplit.length === 2 && authSplit[0].toLowerCase() === 'bearer') {
+        accessToken = authSplit[1];
+      }
+    }
+    const userAgent = req.headers['user-agent']
+      ? BITGOEXPRESS_USER_AGENT + ' ' + req.headers['user-agent']
+      : BITGOEXPRESS_USER_AGENT;
+
+    const bitgoConstructorParams = {
+      env,
+      customRootURI: customRootUri,
+      accessToken,
+      userAgent,
+    };
+
+    (req as BitGoRequest).bitgo = new BitGo(bitgoConstructorParams);
+    (req as BitGoRequest).config = config;
+
+    next();
+  };
+}
+
+// Response type for /generate endpoint
+const GenerateWalletResponse: HttpResponse = {
+  200: t.type({
+    id: t.string,
+    users: t.array(
+      t.type({
+        user: t.string,
+        permissions: t.array(t.array(t.string)),
+      }),
+    ),
+    coin: t.string,
+    label: t.string,
+    m: t.number,
+    n: t.number,
+    keys: t.array(t.string),
+    keySignatures: t.type({
+      backupPub: t.string,
+      bitgoPub: t.string,
+    }),
+    tags: t.array(t.string),
+    receiveAddress: t.type({
+      id: t.string,
+      address: t.string,
+      chain: t.number,
+      index: t.number,
+      coin: t.string,
+      wallet: t.string,
+      coinSpecific: t.record(t.string, t.unknown),
+      label: t.union([t.string, t.null]),
+      addressType: t.string,
+    }),
+    balance: t.number,
+    balanceString: t.string,
+    confirmedBalance: t.number,
+    confirmedBalanceString: t.string,
+    spendableBalance: t.number,
+    spendableBalanceString: t.string,
+    deleted: t.boolean,
+    isCold: t.boolean,
+    freeze: t.record(t.string, t.unknown),
+    disableTransactionNotifications: t.boolean,
+    admin: t.record(t.string, t.unknown),
+    approvalsRequired: t.number,
+    pendingApprovals: t.array(t.unknown),
+    allowBackupKeySigning: t.boolean,
+    coinSpecific: t.record(t.string, t.unknown),
+    clientFlags: t.array(t.string),
+    recoverable: t.boolean,
+    startDate: t.string,
+    hasLargeNumberOfAddresses: t.boolean,
+    config: t.record(t.string, t.unknown),
+  }),
+};
+
+// Request type for /generate endpoint
+const GenerateWalletRequest = {
+  label: t.string,
+  multisigType: t.union([t.undefined, t.literal('onchain'), t.literal('tss'), t.literal('blsdkg')]),
+  type: t.union([t.undefined, t.literal('hot'), t.literal('cold'), t.literal('custodial')]),
+  passphrase: t.union([t.undefined, t.string]),
+  userKey: t.union([t.undefined, t.string]),
+  backupXpub: t.union([t.undefined, t.string]),
+  backupXpubProvider: t.union([t.undefined, t.literal('dai')]),
+  enterprise: t.string,
+  disableTransactionNotifications: t.union([t.undefined, t.boolean]),
+  passcodeEncryptionCode: t.union([t.undefined, t.string]),
+  coldDerivationSeed: t.union([t.undefined, t.string]),
+  gasPrice: t.union([t.undefined, t.number]),
+  disableKRSEmail: t.union([t.undefined, t.boolean]),
+  walletVersion: t.union([t.undefined, t.number]),
+  isDistributedCustody: t.union([t.undefined, t.boolean]),
+  bitgoKeyId: t.union([t.undefined, t.string]),
+  commonKeychain: t.union([t.undefined, t.string]),
+};
+
+// API Specification
+export const MultiSigApiSpec = apiSpec({
+  'v1.wallet.generate': {
+    post: httpRoute({
+      method: 'POST',
+      path: '/api/{coin}/wallet/generate',
+      request: httpRequest({
+        params: {
+          coin: t.string,
+        },
+        body: GenerateWalletRequest,
+      }),
+      response: GenerateWalletResponse,
+      description: 'Generate a new wallet',
+    }),
+  },
+});
+
+// Create router with handlers
+export function createMultiSigRouter(
+  cfg: MasterExpressConfig,
+): WrappedRouter<typeof MultiSigApiSpec> {
+  const router = createRouter(MultiSigApiSpec);
+
+  // Add middleware to all routes
+  router.use(parseBody);
+  router.use(prepareBitGo(cfg));
+
+  // Generate wallet endpoint handler
+  router.post('v1.wallet.generate', [
+    withResponseHandler(async (req: BitGoRequest | Request) => {
+      if (!isBitGoRequest(req)) {
+        throw new Error('Invalid request type');
+      }
+      const result = await handleGenerateWalletOnPrem(req);
+      return Response.ok(result);
+    }),
+  ]);
+
+  return router;
+}

src/routes/master.ts

@@ -1,6 +1,5 @@
 import express from 'express';
 import { BitGo, BitGoOptions } from 'bitgo';
-import { BitGoBase } from '@bitgo/sdk-core';
 import { version } from 'bitgo/package.json';
 import pjson from '../../package.json';
 import { MasterExpressConfig } from '../config';
@@ -55,7 +54,7 @@ function prepareBitGo(config: MasterExpressConfig) {
       userAgent,
     };
 
-    (req as BitGoRequest).bitgo = new BitGo(bitgoConstructorParams) as unknown as BitGoBase;
+    (req as BitGoRequest).bitgo = new BitGo(bitgoConstructorParams);
     (req as BitGoRequest).config = config;
 
     next();

src/shared/responseHandler.ts

@@ -1,3 +1,4 @@
+import { BitGoRequest } from '../types/request';
 import { Request, Response as ExpressResponse, NextFunction } from 'express';
 
 // Extend Express Response to include sendEncoded
@@ -12,7 +13,7 @@ interface ApiResponse {
 }
 
 type ServiceFunction = (
-  req: Request,
+  req: Request | BitGoRequest,
   res: EncodedResponse,
   next: NextFunction,
 ) => Promise<ApiResponse> | ApiResponse;
@@ -23,7 +24,7 @@ type ServiceFunction = (
  * @returns Express middleware function that handles the response encoding
  */
 export function withResponseHandler(fn: ServiceFunction) {
-  return async (req: Request, res: EncodedResponse, next: NextFunction) => {
+  return async (req: Request | BitGoRequest, res: EncodedResponse, next: NextFunction) => {
     try {
       const result = await Promise.resolve(fn(req, res, next));
       return res.sendEncoded(result.type, result.payload);

src/types/request.ts

@@ -1,9 +1,13 @@
 import express from 'express';
-import { BitGoBase } from '@bitgo/sdk-core';
+import { type BitGo } from 'bitgo';
 import { MasterExpressConfig } from '../types';
 
 // Extended request type for BitGo Express
 export interface BitGoRequest extends express.Request {
-  bitgo: BitGoBase;
+  bitgo: BitGo;
   config: MasterExpressConfig;
 }
+
+export function isBitGoRequest(req: express.Request): req is BitGoRequest {
+  return (req as BitGoRequest).bitgo !== undefined && (req as BitGoRequest).config !== undefined;
+}