Merge pull request #6991 from BitGo/WP-5414-express-migrate-api-v2-coin-keychain-local-to-typed-routes

feat(express): migrate keychainlocal to typed routes

Author: danielzhao122

modules/express/src/clientRoutes.ts

@@ -686,7 +686,7 @@ async function handleV2PendingApproval(req: express.Request): Promise<any> {
  * create a keychain
  * @param req
  */
-function handleV2CreateLocalKeyChain(req: express.Request) {
+export function handleV2CreateLocalKeyChain(req: ExpressApiRouteRequest<'express.keychain.local', 'post'>) {
   const bitgo = req.bitgo;
   const coin = bitgo.coin(req.params.coin);
   return coin.keychains().create(req.body);
@@ -1609,12 +1609,7 @@ export function setupAPIRoutes(app: express.Application, config: Config): void {
   // API v2
 
   // create keychain
-  app.post(
-    '/api/v2/:coin/keychain/local',
-    parseBody,
-    prepareBitGo(config),
-    promiseWrapper(handleV2CreateLocalKeyChain)
-  );
+  router.post('express.keychain.local', [prepareBitGo(config), typedPromiseWrapper(handleV2CreateLocalKeyChain)]);
 
   // generate wallet
   app.post('/api/v2/:coin/wallet/generate', parseBody, prepareBitGo(config), promiseWrapper(handleV2GenerateWallet));

modules/express/src/typedRoutes/api/index.ts

@@ -13,6 +13,7 @@ import { PostAcceptShare } from './v1/acceptShare';
 import { PostSimpleCreate } from './v1/simpleCreate';
 import { PutPendingApproval } from './v1/pendingApproval';
 import { PostSignTransaction } from './v1/signTransaction';
+import { PostKeychainLocal } from './v2/keychainLocal';
 import { PostLightningInitWallet } from './v2/lightningInitWallet';
 import { PostVerifyCoinAddress } from './v2/verifyAddress';
 
@@ -47,6 +48,9 @@ export const ExpressApi = apiSpec({
   'express.v1.wallet.signTransaction': {
     post: PostSignTransaction,
   },
+  'express.keychain.local': {
+    post: PostKeychainLocal,
+  },
   'express.lightning.initWallet': {
     post: PostLightningInitWallet,
   },

modules/express/src/typedRoutes/api/v2/keychainLocal.ts

@@ -0,0 +1,45 @@
+import * as t from 'io-ts';
+import { httpRoute, httpRequest } from '@api-ts/io-ts-http';
+import { BitgoExpressError } from '../../schemas/error';
+
+/**
+ * Request parameters for creating a local keychain
+ * @property {string} coin - Coin identifier (e.g. btc, tbtc, eth)
+ */
+export const KeychainLocalRequestParams = {
+  /** Coin identifier (e.g. btc, tbtc, eth) */
+  coin: t.string,
+} as const;
+
+export const KeychainLocalRequestResponse200 = t.type({
+  prv: t.string,
+  pub: t.string,
+});
+
+/**
+ * Response for creating a local keychain
+ */
+export const KeychainLocalResponse = {
+  /** Newly generated local keychain. */
+  200: KeychainLocalRequestResponse200,
+  /** Invalid request or key generation fails. */
+  400: BitgoExpressError,
+} as const;
+
+/**
+ * Local client-side function to create a new keychain.
+ * Creating your keychains is a critical step for safely securing your Bitcoin. When generating new keychains, this API uses a random number generator that adheres to industry standards. If you provide your own seed, you must take extreme caution when creating it.
+ * Returns an object containing the xprv and xpub for the new chain. The created keychain is not known to the BitGo service. To use it with the BitGo service, use the ‘Store Keychain’ API call.
+ *
+ * For security reasons, it is highly recommended that you encrypt and destroy the original xprv immediately to prevent theft.
+ *
+ * @operationId express.keychain.local
+ */
+export const PostKeychainLocal = httpRoute({
+  path: '/api/v2/{coin}/keychain/local',
+  method: 'POST',
+  request: httpRequest({
+    params: KeychainLocalRequestParams,
+  }),
+  response: KeychainLocalResponse,
+});

modules/express/test/unit/clientRoutes/keychainLocal.ts

@@ -0,0 +1,60 @@
+import * as sinon from 'sinon';
+
+import 'should-http';
+import 'should-sinon';
+import '../../lib/asserts';
+
+import nock from 'nock';
+import { TestBitGo, TestBitGoAPI } from '@bitgo/sdk-test';
+import { BitGo } from 'bitgo';
+import { BaseCoin, decodeOrElse } from '@bitgo/sdk-core';
+
+import { ExpressApiRouteRequest } from '../../../src/typedRoutes/api';
+import { handleV2CreateLocalKeyChain } from '../../../src/clientRoutes';
+import { KeychainLocalResponse } from '../../../src/typedRoutes/api/v2/keychainLocal';
+
+describe('Create Local Keychain', () => {
+  let bitgo: TestBitGoAPI;
+
+  before(async function () {
+    if (!nock.isActive()) {
+      nock.activate();
+    }
+
+    bitgo = TestBitGo.decorate(BitGo, { env: 'test' });
+    bitgo.initializeTestVars();
+
+    nock.disableNetConnect();
+    nock.enableNetConnect('127.0.0.1');
+  });
+
+  after(() => {
+    if (nock.isActive()) {
+      nock.restore();
+    }
+  });
+
+  it('should create a local keychain and return the keypair', async () => {
+    const createdKeypair = { prv: 'prv-example', pub: 'pub-example' };
+    const keychainsInstance = { create: sinon.stub().returns(createdKeypair) } as const;
+    const coinStub = {
+      keychains: sinon.stub<[], typeof keychainsInstance>().returns(keychainsInstance),
+    } as unknown as BaseCoin;
+    const coinMethodStub = sinon.stub(bitgo, 'coin').returns(coinStub as any);
+
+    const req = {
+      bitgo: bitgo,
+      params: { coin: 'tbtc' },
+      body: {},
+    } as unknown as ExpressApiRouteRequest<'express.keychain.local', 'post'>;
+
+    const res = await handleV2CreateLocalKeyChain(req);
+
+    decodeOrElse('KeychainLocalResponse200', KeychainLocalResponse[200], res, (errors) => {
+      throw new Error(`Response did not match expected codec: ${errors}`);
+    });
+
+    sinon.assert.calledOnce(keychainsInstance.create);
+    coinMethodStub.restore();
+  });
+});

modules/express/test/unit/typedRoutes/decode.ts

@@ -6,6 +6,7 @@ import { LoginRequest } from '../../../src/typedRoutes/api/common/login';
 import { VerifyAddressBody } from '../../../src/typedRoutes/api/common/verifyAddress';
 import { VerifyAddressV2Body, VerifyAddressV2Params } from '../../../src/typedRoutes/api/v2/verifyAddress';
 import { SimpleCreateRequestBody } from '../../../src/typedRoutes/api/v1/simpleCreate';
+import { KeychainLocalRequestParams } from '../../../src/typedRoutes/api/v2/keychainLocal';
 import {
   LightningInitWalletBody,
   LightningInitWalletParams,
@@ -133,6 +134,28 @@ describe('io-ts decode tests', function () {
       passphrase: 'pass',
     });
   });
+  it('express.keychain.local', function () {
+    // coin parameter is required
+    assert.throws(() => assertDecode(t.type(KeychainLocalRequestParams), {}));
+    // coin must be a string
+    assert.throws(() =>
+      assertDecode(t.type(KeychainLocalRequestParams), {
+        coin: 123,
+      })
+    );
+    // valid with coin parameter
+    assertDecode(t.type(KeychainLocalRequestParams), {
+      coin: 'btc',
+    });
+    // valid with different coin
+    assertDecode(t.type(KeychainLocalRequestParams), {
+      coin: 'eth',
+    });
+    // valid with testnet coin
+    assertDecode(t.type(KeychainLocalRequestParams), {
+      coin: 'tbtc',
+    });
+  });
   it('express.lightning.initWallet params', function () {
     // missing walletId
     assert.throws(() => assertDecode(t.type(LightningInitWalletParams), { coin: 'ltc' }));