Merge pull request #857 from 0xProject/feature/contracts/batchGetOrderInfo

Add getOrdersInfo function

6 files changed, 344 insertions, 12 deletions

diff --git a/packages/contracts/src/2.0.0/protocol/Exchange/MixinExchangeCore.sol b/packages/contracts/src/2.0.0/protocol/Exchange/MixinExchangeCore.sol
index ec84b1e19..6f435892b 100644
--- a/packages/contracts/src/2.0.0/protocol/Exchange/MixinExchangeCore.sol
+++ b/packages/contracts/src/2.0.0/protocol/Exchange/MixinExchangeCore.sol
@@ -154,6 +154,9 @@ contract MixinExchangeCore is
         // Compute the order hash
         orderInfo.orderHash = getOrderHash(order);
 
+        // Fetch filled amount
+        orderInfo.orderTakerAssetFilledAmount = filled[orderInfo.orderHash];
+
         // If order.makerAssetAmount is zero, we also reject the order.
         // While the Exchange contract handles them correctly, they create
         // edge cases in the supporting infrastructure because they have
@@ -172,6 +175,12 @@ contract MixinExchangeCore is
             return orderInfo;
         }
 
+        // Validate order availability
+        if (orderInfo.orderTakerAssetFilledAmount >= order.takerAssetAmount) {
+            orderInfo.orderStatus = uint8(OrderStatus.FULLY_FILLED);
+            return orderInfo;
+        }
+
         // Validate order expiration
         // solhint-disable-next-line not-rely-on-time
         if (block.timestamp >= order.expirationTimeSeconds) {
@@ -189,13 +198,6 @@ contract MixinExchangeCore is
             return orderInfo;
         }
 
-        // Fetch filled amount and validate order availability
-        orderInfo.orderTakerAssetFilledAmount = filled[orderInfo.orderHash];
-        if (orderInfo.orderTakerAssetFilledAmount >= order.takerAssetAmount) {
-            orderInfo.orderStatus = uint8(OrderStatus.FULLY_FILLED);
-            return orderInfo;
-        }
-
         // All other statuses are ruled out: order is Fillable
         orderInfo.orderStatus = uint8(OrderStatus.FILLABLE);
         return orderInfo;
diff --git a/packages/contracts/src/2.0.0/protocol/Exchange/MixinWrapperFunctions.sol b/packages/contracts/src/2.0.0/protocol/Exchange/MixinWrapperFunctions.sol
index a16d2f897..d420f7e85 100644
--- a/packages/contracts/src/2.0.0/protocol/Exchange/MixinWrapperFunctions.sol
+++ b/packages/contracts/src/2.0.0/protocol/Exchange/MixinWrapperFunctions.sol
@@ -529,4 +529,20 @@ contract MixinWrapperFunctions is
             cancelOrder(orders[i]);
         }
     }
+
+    /// @dev Fetches information for all passed in orders.
+    /// @param orders Array of order specifications.
+    /// @return Array of OrderInfo instances that correspond to each order.
+    function getOrdersInfo(LibOrder.Order[] memory orders)
+        public
+        view
+        returns (LibOrder.OrderInfo[] memory)
+    {
+        uint256 length = orders.length;
+        LibOrder.OrderInfo[] memory ordersInfo = new LibOrder.OrderInfo[](length);
+        for (uint256 i = 0; i < length; i++) {
+            ordersInfo[i] = getOrderInfo(orders[i]);
+        }
+        return ordersInfo;
+    }
 }
diff --git a/packages/contracts/src/2.0.0/protocol/Exchange/interfaces/IWrapperFunctions.sol b/packages/contracts/src/2.0.0/protocol/Exchange/interfaces/IWrapperFunctions.sol
index ad7a56a06..56a533646 100644
--- a/packages/contracts/src/2.0.0/protocol/Exchange/interfaces/IWrapperFunctions.sol
+++ b/packages/contracts/src/2.0.0/protocol/Exchange/interfaces/IWrapperFunctions.sol
@@ -149,4 +149,12 @@ contract IWrapperFunctions {
     /// @param orders Array of order specifications.
     function batchCancelOrders(LibOrder.Order[] memory orders)
         public;
+
+    /// @dev Fetches information for all passed in orders
+    /// @param orders Array of order specifications.
+    /// @return Array of OrderInfo instances that correspond to each order.
+    function getOrdersInfo(LibOrder.Order[] memory orders)
+        public
+        view
+        returns (LibOrder.OrderInfo[] memory);
 }
diff --git a/packages/contracts/test/exchange/core.ts b/packages/contracts/test/exchange/core.ts
index d24208424..1eb6f2a5c 100644
--- a/packages/contracts/test/exchange/core.ts
+++ b/packages/contracts/test/exchange/core.ts
@@ -15,14 +15,14 @@ import { ERC721ProxyContract } from '../../generated_contract_wrappers/erc721_pr
 import { ExchangeCancelEventArgs, ExchangeContract } from '../../generated_contract_wrappers/exchange';
 import { artifacts } from '../utils/artifacts';
 import { expectTransactionFailedAsync } from '../utils/assertions';
-import { getLatestBlockTimestampAsync } from '../utils/block_timestamp';
+import { getLatestBlockTimestampAsync, increaseTimeAndMineBlockAsync } from '../utils/block_timestamp';
 import { chaiSetup } from '../utils/chai_setup';
 import { constants } from '../utils/constants';
 import { ERC20Wrapper } from '../utils/erc20_wrapper';
 import { ERC721Wrapper } from '../utils/erc721_wrapper';
 import { ExchangeWrapper } from '../utils/exchange_wrapper';
 import { OrderFactory } from '../utils/order_factory';
-import { ERC20BalancesByOwner } from '../utils/types';
+import { ERC20BalancesByOwner, OrderStatus } from '../utils/types';
 import { provider, txDefaults, web3Wrapper } from '../utils/web3_wrapper';
 
 chaiSetup.configure();
@@ -483,6 +483,124 @@ describe('Exchange core', () => {
             );
         });
     });
+
+    describe('getOrderInfo', () => {
+        beforeEach(async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync();
+        });
+        it('should return the correct orderInfo for an unfilled valid order', async () => {
+            const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
+            const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+            const expectedTakerAssetFilledAmount = new BigNumber(0);
+            const expectedOrderStatus = OrderStatus.FILLABLE;
+            expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+            expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+            expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+        });
+        it('should return the correct orderInfo for a fully filled order', async () => {
+            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress);
+            const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
+            const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+            const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount;
+            const expectedOrderStatus = OrderStatus.FULLY_FILLED;
+            expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+            expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+            expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+        });
+        it('should return the correct orderInfo for a partially filled order', async () => {
+            const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
+            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
+            const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
+            const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+            const expectedTakerAssetFilledAmount = takerAssetFillAmount;
+            const expectedOrderStatus = OrderStatus.FILLABLE;
+            expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+            expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+            expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+        });
+        it('should return the correct orderInfo for a cancelled and unfilled order', async () => {
+            await exchangeWrapper.cancelOrderAsync(signedOrder, makerAddress);
+            const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
+            const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+            const expectedTakerAssetFilledAmount = new BigNumber(0);
+            const expectedOrderStatus = OrderStatus.CANCELLED;
+            expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+            expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+            expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+        });
+        it('should return the correct orderInfo for a cancelled and partially filled order', async () => {
+            const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
+            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
+            await exchangeWrapper.cancelOrderAsync(signedOrder, makerAddress);
+            const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
+            const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+            const expectedTakerAssetFilledAmount = takerAssetFillAmount;
+            const expectedOrderStatus = OrderStatus.CANCELLED;
+            expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+            expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+            expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+        });
+        it('should return the correct orderInfo for an expired and unfilled order', async () => {
+            const currentTimestamp = await getLatestBlockTimestampAsync();
+            const timeUntilExpiration = signedOrder.expirationTimeSeconds.minus(currentTimestamp).toNumber();
+            await increaseTimeAndMineBlockAsync(timeUntilExpiration);
+            const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
+            const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+            const expectedTakerAssetFilledAmount = new BigNumber(0);
+            const expectedOrderStatus = OrderStatus.EXPIRED;
+            expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+            expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+            expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+        });
+        it('should return the correct orderInfo for an expired and partially filled order', async () => {
+            const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
+            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
+            const currentTimestamp = await getLatestBlockTimestampAsync();
+            const timeUntilExpiration = signedOrder.expirationTimeSeconds.minus(currentTimestamp).toNumber();
+            await increaseTimeAndMineBlockAsync(timeUntilExpiration);
+            const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
+            const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+            const expectedTakerAssetFilledAmount = takerAssetFillAmount;
+            const expectedOrderStatus = OrderStatus.EXPIRED;
+            expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+            expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+            expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+        });
+        it('should return the correct orderInfo for an expired and fully filled order', async () => {
+            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress);
+            const currentTimestamp = await getLatestBlockTimestampAsync();
+            const timeUntilExpiration = signedOrder.expirationTimeSeconds.minus(currentTimestamp).toNumber();
+            await increaseTimeAndMineBlockAsync(timeUntilExpiration);
+            const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
+            const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+            const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount;
+            // FULLY_FILLED takes precedence over EXPIRED
+            const expectedOrderStatus = OrderStatus.FULLY_FILLED;
+            expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+            expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+            expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+        });
+        it('should return the correct orderInfo for an order with a makerAssetAmount of 0', async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync({ makerAssetAmount: new BigNumber(0) });
+            const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
+            const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+            const expectedTakerAssetFilledAmount = new BigNumber(0);
+            const expectedOrderStatus = OrderStatus.INVALID_MAKER_ASSET_AMOUNT;
+            expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+            expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+            expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+        });
+        it('should return the correct orderInfo for an order with a takerAssetAmount of 0', async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync({ takerAssetAmount: new BigNumber(0) });
+            const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
+            const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+            const expectedTakerAssetFilledAmount = new BigNumber(0);
+            const expectedOrderStatus = OrderStatus.INVALID_TAKER_ASSET_AMOUNT;
+            expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+            expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+            expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+        });
+    });
 });
 // tslint:disable:max-file-line-count
 // tslint:enable:no-unnecessary-type-assertion
diff --git a/packages/contracts/test/exchange/wrapper.ts b/packages/contracts/test/exchange/wrapper.ts
index 0ccf08f1e..abcb8364a 100644
--- a/packages/contracts/test/exchange/wrapper.ts
+++ b/packages/contracts/test/exchange/wrapper.ts
@@ -1,5 +1,5 @@
 import { BlockchainLifecycle } from '@0xproject/dev-utils';
-import { assetProxyUtils } from '@0xproject/order-utils';
+import { assetProxyUtils, orderHashUtils } from '@0xproject/order-utils';
 import { RevertReason, SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
@@ -13,14 +13,14 @@ import { ERC721ProxyContract } from '../../generated_contract_wrappers/erc721_pr
 import { ExchangeContract } from '../../generated_contract_wrappers/exchange';
 import { artifacts } from '../utils/artifacts';
 import { expectTransactionFailedAsync } from '../utils/assertions';
-import { getLatestBlockTimestampAsync } from '../utils/block_timestamp';
+import { getLatestBlockTimestampAsync, increaseTimeAndMineBlockAsync } from '../utils/block_timestamp';
 import { chaiSetup } from '../utils/chai_setup';
 import { constants } from '../utils/constants';
 import { ERC20Wrapper } from '../utils/erc20_wrapper';
 import { ERC721Wrapper } from '../utils/erc721_wrapper';
 import { ExchangeWrapper } from '../utils/exchange_wrapper';
 import { OrderFactory } from '../utils/order_factory';
-import { ERC20BalancesByOwner } from '../utils/types';
+import { ERC20BalancesByOwner, OrderStatus } from '../utils/types';
 import { provider, txDefaults, web3Wrapper } from '../utils/web3_wrapper';
 
 chaiSetup.configure();
@@ -1071,5 +1071,189 @@ describe('Exchange wrappers', () => {
                 expect(erc20Balances).to.be.deep.equal(newBalances);
             });
         });
+
+        describe('getOrdersInfo', () => {
+            beforeEach(async () => {
+                signedOrders = [
+                    await orderFactory.newSignedOrderAsync(),
+                    await orderFactory.newSignedOrderAsync(),
+                    await orderFactory.newSignedOrderAsync(),
+                ];
+            });
+            it('should get the correct information for multiple unfilled orders', async () => {
+                const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
+                expect(ordersInfo.length).to.be.equal(3);
+                _.forEach(signedOrders, (signedOrder, index) => {
+                    const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+                    const expectedTakerAssetFilledAmount = new BigNumber(0);
+                    const expectedOrderStatus = OrderStatus.FILLABLE;
+                    const orderInfo = ordersInfo[index];
+                    expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+                    expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+                    expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+                });
+            });
+            it('should get the correct information for multiple partially filled orders', async () => {
+                const takerAssetFillAmounts = _.map(signedOrders, signedOrder => signedOrder.takerAssetAmount.div(2));
+                await exchangeWrapper.batchFillOrdersAsync(signedOrders, takerAddress, { takerAssetFillAmounts });
+                const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
+                expect(ordersInfo.length).to.be.equal(3);
+                _.forEach(signedOrders, (signedOrder, index) => {
+                    const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+                    const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount.div(2);
+                    const expectedOrderStatus = OrderStatus.FILLABLE;
+                    const orderInfo = ordersInfo[index];
+                    expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+                    expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+                    expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+                });
+            });
+            it('should get the correct information for multiple fully filled orders', async () => {
+                await exchangeWrapper.batchFillOrdersAsync(signedOrders, takerAddress);
+                const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
+                expect(ordersInfo.length).to.be.equal(3);
+                _.forEach(signedOrders, (signedOrder, index) => {
+                    const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+                    const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount;
+                    const expectedOrderStatus = OrderStatus.FULLY_FILLED;
+                    const orderInfo = ordersInfo[index];
+                    expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+                    expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+                    expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+                });
+            });
+            it('should get the correct information for multiple cancelled and unfilled orders', async () => {
+                await exchangeWrapper.batchCancelOrdersAsync(signedOrders, makerAddress);
+                const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
+                expect(ordersInfo.length).to.be.equal(3);
+                _.forEach(signedOrders, (signedOrder, index) => {
+                    const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+                    const expectedTakerAssetFilledAmount = new BigNumber(0);
+                    const expectedOrderStatus = OrderStatus.CANCELLED;
+                    const orderInfo = ordersInfo[index];
+                    expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+                    expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+                    expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+                });
+            });
+            it('should get the correct information for multiple cancelled and partially filled orders', async () => {
+                const takerAssetFillAmounts = _.map(signedOrders, signedOrder => signedOrder.takerAssetAmount.div(2));
+                await exchangeWrapper.batchFillOrdersAsync(signedOrders, takerAddress, { takerAssetFillAmounts });
+                await exchangeWrapper.batchCancelOrdersAsync(signedOrders, makerAddress);
+                const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
+                expect(ordersInfo.length).to.be.equal(3);
+                _.forEach(signedOrders, (signedOrder, index) => {
+                    const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+                    const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount.div(2);
+                    const expectedOrderStatus = OrderStatus.CANCELLED;
+                    const orderInfo = ordersInfo[index];
+                    expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+                    expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+                    expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+                });
+            });
+            it('should get the correct information for multiple expired and unfilled orders', async () => {
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const timeUntilExpiration = signedOrders[0].expirationTimeSeconds.minus(currentTimestamp).toNumber();
+                await increaseTimeAndMineBlockAsync(timeUntilExpiration);
+                const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
+                expect(ordersInfo.length).to.be.equal(3);
+                _.forEach(signedOrders, (signedOrder, index) => {
+                    const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+                    const expectedTakerAssetFilledAmount = new BigNumber(0);
+                    const expectedOrderStatus = OrderStatus.EXPIRED;
+                    const orderInfo = ordersInfo[index];
+                    expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+                    expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+                    expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+                });
+            });
+            it('should get the correct information for multiple expired and partially filled orders', async () => {
+                const takerAssetFillAmounts = _.map(signedOrders, signedOrder => signedOrder.takerAssetAmount.div(2));
+                await exchangeWrapper.batchFillOrdersAsync(signedOrders, takerAddress, { takerAssetFillAmounts });
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const timeUntilExpiration = signedOrders[0].expirationTimeSeconds.minus(currentTimestamp).toNumber();
+                await increaseTimeAndMineBlockAsync(timeUntilExpiration);
+                const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
+                expect(ordersInfo.length).to.be.equal(3);
+                _.forEach(signedOrders, (signedOrder, index) => {
+                    const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+                    const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount.div(2);
+                    const expectedOrderStatus = OrderStatus.EXPIRED;
+                    const orderInfo = ordersInfo[index];
+                    expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+                    expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
+                    expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
+                });
+            });
+            it('should get the correct information for a mix of unfilled, partially filled, fully filled, cancelled, and expired orders', async () => {
+                const unfilledOrder = await orderFactory.newSignedOrderAsync();
+                const partiallyFilledOrder = await orderFactory.newSignedOrderAsync();
+                await exchangeWrapper.fillOrderAsync(partiallyFilledOrder, takerAddress, {
+                    takerAssetFillAmount: partiallyFilledOrder.takerAssetAmount.div(2),
+                });
+                const fullyFilledOrder = await orderFactory.newSignedOrderAsync();
+                await exchangeWrapper.fillOrderAsync(fullyFilledOrder, takerAddress);
+                const cancelledOrder = await orderFactory.newSignedOrderAsync();
+                await exchangeWrapper.cancelOrderAsync(cancelledOrder, makerAddress);
+                const currentTimestamp = await getLatestBlockTimestampAsync();
+                const expiredOrder = await orderFactory.newSignedOrderAsync({
+                    expirationTimeSeconds: new BigNumber(currentTimestamp),
+                });
+                signedOrders = [unfilledOrder, partiallyFilledOrder, fullyFilledOrder, cancelledOrder, expiredOrder];
+                const ordersInfo = await exchangeWrapper.getOrdersInfoAsync(signedOrders);
+                expect(ordersInfo.length).to.be.equal(5);
+
+                const expectedUnfilledOrderHash = orderHashUtils.getOrderHashHex(unfilledOrder);
+                const expectedUnfilledTakerAssetFilledAmount = new BigNumber(0);
+                const expectedUnfilledOrderStatus = OrderStatus.FILLABLE;
+                const unfilledOrderInfo = ordersInfo[0];
+                expect(unfilledOrderInfo.orderHash).to.be.equal(expectedUnfilledOrderHash);
+                expect(unfilledOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
+                    expectedUnfilledTakerAssetFilledAmount,
+                );
+                expect(unfilledOrderInfo.orderStatus).to.be.equal(expectedUnfilledOrderStatus);
+
+                const expectedPartialOrderHash = orderHashUtils.getOrderHashHex(partiallyFilledOrder);
+                const expectedPartialTakerAssetFilledAmount = partiallyFilledOrder.takerAssetAmount.div(2);
+                const expectedPartialOrderStatus = OrderStatus.FILLABLE;
+                const partialOrderInfo = ordersInfo[1];
+                expect(partialOrderInfo.orderHash).to.be.equal(expectedPartialOrderHash);
+                expect(partialOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
+                    expectedPartialTakerAssetFilledAmount,
+                );
+                expect(partialOrderInfo.orderStatus).to.be.equal(expectedPartialOrderStatus);
+
+                const expectedFilledOrderHash = orderHashUtils.getOrderHashHex(fullyFilledOrder);
+                const expectedFilledTakerAssetFilledAmount = fullyFilledOrder.takerAssetAmount;
+                const expectedFilledOrderStatus = OrderStatus.FULLY_FILLED;
+                const filledOrderInfo = ordersInfo[2];
+                expect(filledOrderInfo.orderHash).to.be.equal(expectedFilledOrderHash);
+                expect(filledOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
+                    expectedFilledTakerAssetFilledAmount,
+                );
+                expect(filledOrderInfo.orderStatus).to.be.equal(expectedFilledOrderStatus);
+
+                const expectedCancelledOrderHash = orderHashUtils.getOrderHashHex(cancelledOrder);
+                const expectedCancelledTakerAssetFilledAmount = new BigNumber(0);
+                const expectedCancelledOrderStatus = OrderStatus.CANCELLED;
+                const cancelledOrderInfo = ordersInfo[3];
+                expect(cancelledOrderInfo.orderHash).to.be.equal(expectedCancelledOrderHash);
+                expect(cancelledOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
+                    expectedCancelledTakerAssetFilledAmount,
+                );
+                expect(cancelledOrderInfo.orderStatus).to.be.equal(expectedCancelledOrderStatus);
+
+                const expectedExpiredOrderHash = orderHashUtils.getOrderHashHex(expiredOrder);
+                const expectedExpiredTakerAssetFilledAmount = new BigNumber(0);
+                const expectedExpiredOrderStatus = OrderStatus.EXPIRED;
+                const expiredOrderInfo = ordersInfo[4];
+                expect(expiredOrderInfo.orderHash).to.be.equal(expectedExpiredOrderHash);
+                expect(expiredOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
+                    expectedExpiredTakerAssetFilledAmount,
+                );
+                expect(expiredOrderInfo.orderStatus).to.be.equal(expectedExpiredOrderStatus);
+            });
+        });
     });
 }); // tslint:disable-line:max-file-line-count
diff --git a/packages/contracts/test/utils/exchange_wrapper.ts b/packages/contracts/test/utils/exchange_wrapper.ts
index 155d0eeb0..a71a0d495 100644
--- a/packages/contracts/test/utils/exchange_wrapper.ts
+++ b/packages/contracts/test/utils/exchange_wrapper.ts
@@ -223,6 +223,10 @@ export class ExchangeWrapper {
         const orderInfo = (await this._exchange.getOrderInfo.callAsync(signedOrder)) as OrderInfo;
         return orderInfo;
     }
+    public async getOrdersInfoAsync(signedOrders: SignedOrder[]): Promise<OrderInfo[]> {
+        const ordersInfo = (await this._exchange.getOrdersInfo.callAsync(signedOrders)) as OrderInfo[];
+        return ordersInfo;
+    }
     public async matchOrdersAsync(
         signedOrderLeft: SignedOrder,
         signedOrderRight: SignedOrder,