Run prettier

packages/connect/src/http_client.ts

@@ -59,7 +59,9 @@ export class HttpClient implements Client {
      * @param   requestOpts     Options specifying assetData information to retrieve and page information, defaults to { page: 1, perPage: 100 }
      * @return  The resulting AssetPairsItems that match the request
      */
-    public async getAssetPairsAsync(requestOpts?: RequestOpts & AssetPairsRequestOpts & PagedRequestOpts): Promise<AssetPairsResponse> {
+    public async getAssetPairsAsync(
+        requestOpts?: RequestOpts & AssetPairsRequestOpts & PagedRequestOpts,
+    ): Promise<AssetPairsResponse> {
         if (!_.isUndefined(requestOpts)) {
             assert.doesConformToSchema('requestOpts', requestOpts, clientSchemas.assetPairsRequestOptsSchema);
             assert.doesConformToSchema('requestOpts', requestOpts, clientSchemas.pagedRequestOptsSchema);
@@ -77,7 +79,9 @@ export class HttpClient implements Client {
      * @param   requestOpts     Options specifying orders to retrieve and page information, defaults to { page: 1, perPage: 100 }
      * @return  The resulting SignedOrders that match the request
      */
-    public async getOrdersAsync(requestOpts?: RequestOpts & OrdersRequestOpts & PagedRequestOpts): Promise<OrdersResponse> {
+    public async getOrdersAsync(
+        requestOpts?: RequestOpts & OrdersRequestOpts & PagedRequestOpts,
+    ): Promise<OrdersResponse> {
         if (!_.isUndefined(requestOpts)) {
             assert.doesConformToSchema('requestOpts', requestOpts, clientSchemas.ordersRequestOptsSchema);
             assert.doesConformToSchema('requestOpts', requestOpts, clientSchemas.pagedRequestOptsSchema);
@@ -134,7 +138,10 @@ export class HttpClient implements Client {
      * @param   request     A OrderConfigRequest instance describing the specific fees to retrieve
      * @return  The resulting OrderConfigResponse that matches the request
      */
-    public async getOrderConfigAsync(request: OrderConfigRequest, requestOpts?: RequestOpts): Promise<OrderConfigResponse> {
+    public async getOrderConfigAsync(
+        request: OrderConfigRequest,
+        requestOpts?: RequestOpts,
+    ): Promise<OrderConfigResponse> {
         if (!_.isUndefined(requestOpts)) {
             assert.doesConformToSchema('requestOpts', requestOpts, clientSchemas.requestOptsSchema);
         }

packages/connect/src/orders_channel_factory.ts

@@ -12,10 +12,7 @@ export const ordersChannelFactory = {
      *                               channel updates
      * @return  An OrdersChannel Promise
      */
-    async createWebSocketOrdersChannelAsync(
+    async createWebSocketOrdersChannelAsync(url: string, handler: OrdersChannelHandler): Promise<OrdersChannel> {
-        url: string,
-        handler: OrdersChannelHandler,
-    ): Promise<OrdersChannel> {
         assert.isUri('url', url);
         assert.isOrdersChannelHandler('handler', handler);
         return new Promise<OrdersChannel>((resolve, reject) => {

packages/connect/src/schemas/order_config_request_schema.ts

@@ -6,7 +6,7 @@ export const orderConfigRequestSchema = {
         takerAddress: { $ref: '/addressSchema' },
         makerAssetAmount: { $ref: '/numberSchema' },
         takerAssetAmount: { $ref: '/numberSchema' },
-        makerAssetData: { $ref: '/hexSchema'},
+        makerAssetData: { $ref: '/hexSchema' },
         takerAssetData: { $ref: '/hexSchema' },
         exchangeAddress: { $ref: '/addressSchema' },
         expirationTimeSeconds: { $ref: '/numberSchema' },

packages/connect/src/types.ts

@@ -2,7 +2,9 @@ import { SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 
 export interface Client {
-    getAssetPairsAsync: (requestOpts?: AssetPairsRequestOpts & PagedRequestOpts) => Promise<PaginatedCollection<AssetPairsItem>>;
+    getAssetPairsAsync: (
+        requestOpts?: AssetPairsRequestOpts & PagedRequestOpts,
+    ) => Promise<PaginatedCollection<AssetPairsItem>>;
     getOrdersAsync: (requestOpts?: OrdersRequestOpts & PagedRequestOpts) => Promise<PaginatedCollection<APIOrder>>;
     getOrderAsync: (orderHash: string) => Promise<APIOrder>;
     getOrderbookAsync: (request: OrderbookRequest, requestOpts?: PagedRequestOpts) => Promise<OrderbookResponse>;
@@ -28,18 +30,12 @@ export interface OrdersChannelSubscriptionOpts {
 }
 
 export interface OrdersChannelHandler {
-    onUpdate: (
+    onUpdate: (channel: OrdersChannel, subscriptionOpts: OrdersChannelSubscriptionOpts, orders: APIOrder[]) => void;
-        channel: OrdersChannel,
-        subscriptionOpts: OrdersChannelSubscriptionOpts,
-        orders: APIOrder[],
-    ) => void;
     onError: (channel: OrdersChannel, err: Error, subscriptionOpts?: OrdersChannelSubscriptionOpts) => void;
     onClose: (channel: OrdersChannel) => void;
 }
 
-export type OrdersChannelMessage =
+export type OrdersChannelMessage = UpdateOrdersChannelMessage | UnknownOrdersChannelMessage;
-    | UpdateOrdersChannelMessage
-    | UnknownOrdersChannelMessage;
 
 export enum OrdersChannelMessageTypes {
     Update = 'update',

packages/connect/src/utils/relayer_response_json_parsers.ts

@@ -1,7 +1,14 @@
 import { assert } from '@0xproject/assert';
 import { schemas } from '@0xproject/json-schemas';
 
-import { APIOrder, AssetPairsItem, AssetPairsResponse, OrderbookResponse, OrderConfigResponse, OrdersResponse } from '../types';
+import {
+    APIOrder,
+    AssetPairsItem,
+    AssetPairsResponse,
+    OrderbookResponse,
+    OrderConfigResponse,
+    OrdersResponse,
+} from '../types';
 
 import { typeConverters } from './type_converters';
 

packages/connect/src/ws_orders_channel.ts

@@ -2,12 +2,7 @@ import * as _ from 'lodash';
 import { v4 as uuid } from 'uuid';
 import * as WebSocket from 'websocket';
 
-import {
+import { OrdersChannel, OrdersChannelHandler, OrdersChannelMessageTypes, OrdersChannelSubscriptionOpts } from './types';
-    OrdersChannel,
-    OrdersChannelHandler,
-    OrdersChannelMessageTypes,
-    OrdersChannelSubscriptionOpts,
-} from './types';
 import { assert } from './utils/assert';
 import { ordersChannelMessageParser } from './utils/orders_channel_message_parser';
 

packages/connect/test/fixtures/standard_relayer_api/orders.json

@@ -24,4 +24,3 @@
         }
     ]
 }
-

packages/connect/test/http_client_test.ts

@@ -109,9 +109,9 @@ describe('HttpClient', () => {
         };
         const url = `${relayUrl}/orderbook`;
         it('gets orderbook with default page options when none are provided', async () => {
-            const urlWithQuery = `${url}?baseAssetData=${
+            const urlWithQuery = `${url}?baseAssetData=${request.baseAssetData}&quoteAssetData=${
-                request.baseAssetData
+                request.quoteAssetData
-            }&quoteAssetData=${request.quoteAssetData}`;
+            }`;
             fetchMock.get(urlWithQuery, orderbookJSON);
             const orderbook = await relayerClient.getOrderbookAsync(request);
             expect(orderbook).to.be.deep.equal(orderbookResponse);

packages/connect/test/orders_channel_factory_test.ts

@@ -20,10 +20,7 @@ describe('ordersChannelFactory', () => {
         it('throws when input is not a url', () => {
             const badUrlInput = 54;
             expect(
-                ordersChannelFactory.createWebSocketOrdersChannelAsync(
+                ordersChannelFactory.createWebSocketOrdersChannelAsync(badUrlInput as any, emptyOrdersChannelHandler),
-                    badUrlInput as any,
-                    emptyOrdersChannelHandler,
-                ),
             ).to.be.rejected();
         });
         it('throws when handler has the incorrect members', () => {