fix: Swallow orderbook service failure in AssetSwapperOrderbook [LIT-852] (0xProject#1273)

* Move `Orderbook implementations` under `src/orderbook`

* Remove unused getBatchOrdersAsync

* Add unit test

Author: kyu-c

src/asset-swapper/types.ts

@@ -685,11 +685,7 @@ export abstract class Orderbook {
         takerToken: string,
         pruneFn?: (o: SignedLimitOrder) => boolean,
     ): Promise<SignedLimitOrder[]>;
-    public abstract getBatchOrdersAsync(
-        makerTokens: string[],
-        takerToken: string,
-        pruneFn?: (o: SignedLimitOrder) => boolean,
-    ): Promise<SignedLimitOrder[][]>;
+
     public async destroyAsync(): Promise<void> {
         return;
     }

src/asset-swapper/utils/utils.ts

@@ -92,10 +92,6 @@ export const assert = {
     ...sharedAssert,
     isValidOrderbook(variableName: string, orderFetcher: Orderbook): void {
         sharedAssert.isFunction(`${variableName}.getOrdersAsync`, orderFetcher.getOrdersAsync.bind(orderFetcher));
-        sharedAssert.isFunction(
-            `${variableName}.getBatchOrdersAsync`,
-            orderFetcher.getBatchOrdersAsync.bind(orderFetcher),
-        );
     },
     isValidPercentage(variableName: string, percentage: number): void {
         assert.isNumber(variableName, percentage);

src/utils/asset_swapper_orderbook.ts renamed to src/orderbook/asset_swapper_orderbook.ts

@@ -1,5 +1,6 @@
 import { FillQuoteTransformerOrderType, Orderbook, SignedLimitOrder } from '../asset-swapper';
 import { DEFAULT_PAGE, DEFAULT_PER_PAGE } from '../constants';
+import { logger } from '../logger';
 import { OrderBookService } from '../services/orderbook_service';
 import { SRAOrder } from '../types';
 
@@ -8,40 +9,46 @@ export class AssetSwapperOrderbook extends Orderbook {
         super();
     }
 
+    /**
+     * Returns matching limit orders.
+     *
+     *  NOTE: If the request to orderbook service fails, it returns an empty array.
+     */
     public async getOrdersAsync(
         makerToken: string,
         takerToken: string,
         pruneFn?: (o: SignedLimitOrder) => boolean,
     ): Promise<SignedLimitOrder[]> {
-        const apiOrders = await this.orderbookService.getOrdersAsync(
-            DEFAULT_PAGE,
-            DEFAULT_PER_PAGE,
-            {
-                makerToken,
-                takerToken,
-            },
-            {},
-        );
+        const apiOrders = await this.orderbookService
+            .getOrdersAsync(
+                DEFAULT_PAGE,
+                DEFAULT_PER_PAGE,
+                {
+                    makerToken,
+                    takerToken,
+                },
+                {},
+            )
+            .catch((err) => {
+                logger.warn(
+                    {
+                        takerToken,
+                        makerToken,
+                        errorMessage: err.message,
+                    },
+                    'Request to OrderBookService failed',
+                );
+
+                return {
+                    records: [],
+                };
+            });
 
         const orders = apiOrders.records.map(apiOrderToOrderbookOrder);
         const result = pruneFn ? orders.filter(pruneFn) : orders;
         return result;
     }
-    public async getBatchOrdersAsync(
-        makerTokens: string[],
-        takerToken: string,
-        pruneFn?: (o: SignedLimitOrder) => boolean,
-    ): Promise<SignedLimitOrder[][]> {
-        const apiOrders = await this.orderbookService.getBatchOrdersAsync(DEFAULT_PAGE, DEFAULT_PER_PAGE, makerTokens, [
-            takerToken,
-        ]);
-        const orders = apiOrders.records.map(apiOrderToOrderbookOrder);
-        const pruned = pruneFn ? orders.filter(pruneFn) : orders;
-        const groupedByMakerToken: SignedLimitOrder[][] = makerTokens.map((token) =>
-            pruned.filter((o) => o.order.makerToken === token),
-        );
-        return groupedByMakerToken;
-    }
+
     public async destroyAsync(): Promise<void> {
         return;
     }

src/utils/no_op_orderbook.ts renamed to src/orderbook/no_op_orderbook.ts

@@ -12,13 +12,6 @@ export class NoOpOrderbook extends Orderbook {
     ): Promise<SignedLimitOrder[]> {
         return [];
     }
-    public async getBatchOrdersAsync(
-        _makerTokens: string[],
-        _takerToken: string,
-        _pruneFn?: (o: SignedLimitOrder) => boolean,
-    ): Promise<SignedLimitOrder[][]> {
-        return [];
-    }
     public async destroyAsync(): Promise<void> {
         return;
     }

src/runners/utils.ts

@@ -28,8 +28,8 @@ import { OrderBookService } from '../services/orderbook_service';
 import { PostgresRfqtFirmQuoteValidator } from '../services/postgres_rfqt_firm_quote_validator';
 import { SwapService } from '../services/swap_service';
 import { HttpServiceConfig, AppDependencies } from '../types';
-import { AssetSwapperOrderbook } from '../utils/asset_swapper_orderbook';
-import { NoOpOrderbook } from '../utils/no_op_orderbook';
+import { AssetSwapperOrderbook } from '../orderbook/asset_swapper_orderbook';
+import { NoOpOrderbook } from '../orderbook/no_op_orderbook';
 import { RfqClient } from '../utils/rfq_client';
 import { RfqDynamicBlacklist } from '../utils/rfq_dyanmic_blacklist';
 import { S3Client } from '../utils/s3_client';

test/orderbook/asset_swapper_orderbook_test.ts

@@ -0,0 +1,21 @@
+import { expect } from '@0x/contracts-test-utils';
+import 'mocha';
+import { AssetSwapperOrderbook } from '../../src/orderbook/asset_swapper_orderbook';
+import { OrderBookService } from '../../src/services/orderbook_service';
+
+describe('AssetSwapperOrderbook', () => {
+    describe('getOrdersAsync', () => {
+        it('Returns an empty array of orders on failure', async () => {
+            const fakeOrderbookService = {
+                getOrdersAsync: async () => {
+                    throw new Error('orderbook service failure');
+                },
+            } as unknown as OrderBookService;
+
+            const orderbook = new AssetSwapperOrderbook(fakeOrderbookService);
+            const orders = await orderbook.getOrdersAsync('makerToken', 'takerToken');
+
+            expect(orders).to.have.lengthOf(0);
+        });
+    });
+});