Merge branch 'development' into feature/forwarder-helper/init

* development: (31 commits)
  Update CI config to check development instead of v2-prototype branch
  fix: Make non-interactive npm login for publish tests more robust
  Run prettier
  Remove comment in updates json-schemas doc
  Add documentation for json-schemas
  Fix typo
  Remove artifacts
  Update variable names, make release candidate
  Update more names in docs
  Improve documentation
  Pin sra-report to 0xproject/connect v1.0.4
  Run prettier
  lint everything
  Update websocket for SRA v2
  Remove default query parameters
  Add networkId request param option
  Rename websocket files and types
  Use uuid as string for requestId
  Update changelogs
  Add fee recipients test
  ...

5 files changed, 95 insertions, 72 deletions

diff --git a/packages/connect/src/utils/assert.ts b/packages/connect/src/utils/assert.ts
index a0fd12fbd..3d8f1c799 100644
--- a/packages/connect/src/utils/assert.ts
+++ b/packages/connect/src/utils/assert.ts
@@ -10,15 +10,14 @@ import * as _ from 'lodash';
 
 export const assert = {
     ...sharedAssert,
-    isOrderbookChannelSubscriptionOpts(variableName: string, subscriptionOpts: any): void {
+    isOrdersChannelSubscriptionOpts(variableName: string, subscriptionOpts: any): void {
         sharedAssert.doesConformToSchema(
             variableName,
             subscriptionOpts,
-            schemas.relayerApiOrderbookChannelSubscribePayload,
+            schemas.relayerApiOrdersChannelSubscribePayload,
         );
     },
-    isOrderbookChannelHandler(variableName: string, handler: any): void {
-        sharedAssert.isFunction(`${variableName}.onSnapshot`, _.get(handler, 'onSnapshot'));
+    isOrdersChannelHandler(variableName: string, handler: any): void {
         sharedAssert.isFunction(`${variableName}.onUpdate`, _.get(handler, 'onUpdate'));
         sharedAssert.isFunction(`${variableName}.onError`, _.get(handler, 'onError'));
         sharedAssert.isFunction(`${variableName}.onClose`, _.get(handler, 'onClose'));
diff --git a/packages/connect/src/utils/orderbook_channel_message_parser.ts b/packages/connect/src/utils/orderbook_channel_message_parser.ts
deleted file mode 100644
index 593288078..000000000
--- a/packages/connect/src/utils/orderbook_channel_message_parser.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import { assert } from '@0xproject/assert';
-import { schemas } from '@0xproject/json-schemas';
-import * as _ from 'lodash';
-
-import { OrderbookChannelMessage, OrderbookChannelMessageTypes } from '../types';
-
-import { relayerResponseJsonParsers } from './relayer_response_json_parsers';
-
-export const orderbookChannelMessageParser = {
-    parse(utf8Data: string): OrderbookChannelMessage {
-        // parse the message
-        const messageObj = JSON.parse(utf8Data);
-        // ensure we have a type parameter to switch on
-        const type: string = _.get(messageObj, 'type');
-        assert.assert(!_.isUndefined(type), `Message is missing a type parameter: ${utf8Data}`);
-        assert.isString('type', type);
-        // ensure we have a request id for the resulting message
-        const requestId: number = _.get(messageObj, 'requestId');
-        assert.assert(!_.isUndefined(requestId), `Message is missing a requestId parameter: ${utf8Data}`);
-        assert.isNumber('requestId', requestId);
-        switch (type) {
-            case OrderbookChannelMessageTypes.Snapshot: {
-                assert.doesConformToSchema('message', messageObj, schemas.relayerApiOrderbookChannelSnapshotSchema);
-                const orderbookJson = messageObj.payload;
-                const orderbook = relayerResponseJsonParsers.parseOrderbookResponseJson(orderbookJson);
-                return _.assign(messageObj, { payload: orderbook });
-            }
-            case OrderbookChannelMessageTypes.Update: {
-                assert.doesConformToSchema('message', messageObj, schemas.relayerApiOrderbookChannelUpdateSchema);
-                const orderJson = messageObj.payload;
-                const order = relayerResponseJsonParsers.parseOrderJson(orderJson);
-                return _.assign(messageObj, { payload: order });
-            }
-            default: {
-                return {
-                    type: OrderbookChannelMessageTypes.Unknown,
-                    requestId,
-                    payload: undefined,
-                };
-            }
-        }
-    },
-};
diff --git a/packages/connect/src/utils/orders_channel_message_parser.ts b/packages/connect/src/utils/orders_channel_message_parser.ts
new file mode 100644
index 000000000..1b6cda17b
--- /dev/null
+++ b/packages/connect/src/utils/orders_channel_message_parser.ts
@@ -0,0 +1,37 @@
+import { assert } from '@0xproject/assert';
+import { schemas } from '@0xproject/json-schemas';
+import * as _ from 'lodash';
+
+import { OrdersChannelMessage, OrdersChannelMessageTypes } from '../types';
+
+import { relayerResponseJsonParsers } from './relayer_response_json_parsers';
+
+export const ordersChannelMessageParser = {
+    parse(utf8Data: string): OrdersChannelMessage {
+        // parse the message
+        const messageObj = JSON.parse(utf8Data);
+        // ensure we have a type parameter to switch on
+        const type: string = _.get(messageObj, 'type');
+        assert.assert(!_.isUndefined(type), `Message is missing a type parameter: ${utf8Data}`);
+        assert.isString('type', type);
+        // ensure we have a request id for the resulting message
+        const requestId: string = _.get(messageObj, 'requestId');
+        assert.assert(!_.isUndefined(requestId), `Message is missing a requestId parameter: ${utf8Data}`);
+        assert.isString('requestId', requestId);
+        switch (type) {
+            case OrdersChannelMessageTypes.Update: {
+                assert.doesConformToSchema('message', messageObj, schemas.relayerApiOrdersChannelUpdateSchema);
+                const ordersJson = messageObj.payload;
+                const orders = relayerResponseJsonParsers.parseAPIOrdersJson(ordersJson);
+                return _.assign(messageObj, { payload: orders });
+            }
+            default: {
+                return {
+                    type: OrdersChannelMessageTypes.Unknown,
+                    requestId,
+                    payload: undefined,
+                };
+            }
+        }
+    },
+};
diff --git a/packages/connect/src/utils/relayer_response_json_parsers.ts b/packages/connect/src/utils/relayer_response_json_parsers.ts
index ccae8b115..ebd877b70 100644
--- a/packages/connect/src/utils/relayer_response_json_parsers.ts
+++ b/packages/connect/src/utils/relayer_response_json_parsers.ts
@@ -1,37 +1,49 @@
 import { assert } from '@0xproject/assert';
 import { schemas } from '@0xproject/json-schemas';
-import { SignedOrder } from '@0xproject/types';
 
-import { FeesResponse, OrderbookResponse, TokenPairsItem } from '../types';
+import {
+    APIOrder,
+    AssetPairsItem,
+    AssetPairsResponse,
+    OrderbookResponse,
+    OrderConfigResponse,
+    OrdersResponse,
+} from '../types';
 
 import { typeConverters } from './type_converters';
 
 export const relayerResponseJsonParsers = {
-    parseTokenPairsJson(json: any): TokenPairsItem[] {
-        assert.doesConformToSchema('tokenPairs', json, schemas.relayerApiTokenPairsResponseSchema);
-        return json.map((tokenPair: any) => {
-            return typeConverters.convertStringsFieldsToBigNumbers(tokenPair, [
-                'tokenA.minAmount',
-                'tokenA.maxAmount',
-                'tokenB.minAmount',
-                'tokenB.maxAmount',
+    parseAssetDataPairsJson(json: any): AssetPairsResponse {
+        assert.doesConformToSchema('assetDataPairsResponse', json, schemas.relayerApiAssetDataPairsResponseSchema);
+        return { ...json, records: relayerResponseJsonParsers.parseAssetPairsItemsJson(json.records) };
+    },
+    parseAssetPairsItemsJson(json: any): AssetPairsItem[] {
+        return json.map((assetDataPair: any) => {
+            return typeConverters.convertStringsFieldsToBigNumbers(assetDataPair, [
+                'assetDataA.minAmount',
+                'assetDataA.maxAmount',
+                'assetDataB.minAmount',
+                'assetDataB.maxAmount',
             ]);
         });
     },
-    parseOrdersJson(json: any): SignedOrder[] {
-        assert.doesConformToSchema('orders', json, schemas.signedOrdersSchema);
-        return json.map((order: object) => typeConverters.convertOrderStringFieldsToBigNumber(order));
+    parseOrdersJson(json: any): OrdersResponse {
+        assert.doesConformToSchema('relayerApiOrdersResponse', json, schemas.relayerApiOrdersResponseSchema);
+        return { ...json, records: relayerResponseJsonParsers.parseAPIOrdersJson(json.records) };
+    },
+    parseAPIOrdersJson(json: any): APIOrder[] {
+        return json.map(relayerResponseJsonParsers.parseAPIOrderJson.bind(relayerResponseJsonParsers));
     },
-    parseOrderJson(json: any): SignedOrder {
-        assert.doesConformToSchema('order', json, schemas.signedOrderSchema);
-        return typeConverters.convertOrderStringFieldsToBigNumber(json);
+    parseAPIOrderJson(json: any): APIOrder {
+        assert.doesConformToSchema('relayerApiOrder', json, schemas.relayerApiOrderSchema);
+        return typeConverters.convertAPIOrderStringFieldsToBigNumber(json);
     },
     parseOrderbookResponseJson(json: any): OrderbookResponse {
-        assert.doesConformToSchema('orderBook', json, schemas.relayerApiOrderBookResponseSchema);
+        assert.doesConformToSchema('orderBookResponse', json, schemas.relayerApiOrderbookResponseSchema);
         return typeConverters.convertOrderbookStringFieldsToBigNumber(json);
     },
-    parseFeesResponseJson(json: any): FeesResponse {
-        assert.doesConformToSchema('fees', json, schemas.relayerApiFeesResponseSchema);
+    parseOrderConfigResponseJson(json: any): OrderConfigResponse {
+        assert.doesConformToSchema('orderConfigResponse', json, schemas.relayerApiOrderConfigResponseSchema);
         return typeConverters.convertStringsFieldsToBigNumbers(json, ['makerFee', 'takerFee']);
     },
 };
diff --git a/packages/connect/src/utils/type_converters.ts b/packages/connect/src/utils/type_converters.ts
index 210d452b9..4b211a0b2 100644
--- a/packages/connect/src/utils/type_converters.ts
+++ b/packages/connect/src/utils/type_converters.ts
@@ -1,29 +1,47 @@
 import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
 
+import { APIOrder } from '../types';
+
 export const typeConverters = {
     convertOrderbookStringFieldsToBigNumber(orderbook: any): any {
         const bids = _.get(orderbook, 'bids', []);
         const asks = _.get(orderbook, 'asks', []);
+        const convertedBids = {
+            ...bids,
+            records: bids.records.map((order: any) => typeConverters.convertAPIOrderStringFieldsToBigNumber(order)),
+        };
+        const convertedAsks = {
+            ...asks,
+            records: asks.records.map((order: any) => typeConverters.convertAPIOrderStringFieldsToBigNumber(order)),
+        };
         return {
-            bids: bids.map((order: any) => typeConverters.convertOrderStringFieldsToBigNumber(order)),
-            asks: asks.map((order: any) => typeConverters.convertOrderStringFieldsToBigNumber(order)),
+            bids: convertedBids,
+            asks: convertedAsks,
         };
     },
+    convertAPIOrderStringFieldsToBigNumber(apiOrder: any): APIOrder {
+        return { ...apiOrder, order: typeConverters.convertOrderStringFieldsToBigNumber(apiOrder.order) };
+    },
     convertOrderStringFieldsToBigNumber(order: any): any {
         return typeConverters.convertStringsFieldsToBigNumbers(order, [
-            'makerTokenAmount',
-            'takerTokenAmount',
+            'makerAssetAmount',
+            'takerAssetAmount',
             'makerFee',
             'takerFee',
-            'expirationUnixTimestampSec',
+            'expirationTimeSeconds',
             'salt',
         ]);
     },
     convertStringsFieldsToBigNumbers(obj: any, fields: string[]): any {
         const result = _.assign({}, obj);
         _.each(fields, field => {
-            _.update(result, field, (value: string) => new BigNumber(value));
+            _.update(result, field, (value: string) => {
+                if (_.isUndefined(value)) {
+                    throw new Error(`Could not find field '${field}' while converting string fields to BigNumber.`);
+                }
+                return new BigNumber(value);
+            });
         });
         return result;
     },