Merge branch 'master' into batchFillOrKill

# Conflicts:
#	test/exchange_wrapper_test.ts

4 files changed, 111 insertions, 34 deletions

diff --git a/src/0x.js.ts b/src/0x.js.ts
index 8f1178b2a..2bf8cad5e 100644
--- a/src/0x.js.ts
+++ b/src/0x.js.ts
@@ -33,7 +33,7 @@ export class ZeroEx {
     private web3Wrapper: Web3Wrapper;
     /**
      * Verifies that the elliptic curve signature `signature` was generated
-     * by signing `data` with the private key corresponding to the `signerAddressHex` address.
+     * by signing `dataHex` with the private key corresponding to the `signerAddressHex` address.
      */
     public static isValidSignature(dataHex: string, signature: ECSignature, signerAddressHex: string): boolean {
         assert.isHexString('dataHex', dataHex);
@@ -83,11 +83,11 @@ export class ZeroEx {
      * E.g: If a currency has 18 decimal places, 1e18 or one quintillion of the currency is equivalent
      * to 1 unit.
      */
-    public static toUnitAmount(amount: BigNumber.BigNumber, decimals: number): BigNumber.BigNumber {
+    public static toUnitAmount(amount: BigNumber.BigNumber, numDecimals: number): BigNumber.BigNumber {
         assert.isBigNumber('amount', amount);
-        assert.isNumber('decimals', decimals);
+        assert.isNumber('numDecimals', numDecimals);
 
-        const aUnit = new BigNumber(10).pow(decimals);
+        const aUnit = new BigNumber(10).pow(numDecimals);
         const unit = amount.div(aUnit);
         return unit;
     }
@@ -96,11 +96,11 @@ export class ZeroEx {
      * is the amount expressed in the smallest denomination.
      * E.g: 1 unit of a token with 18 decimal places is expressed in baseUnits as 1000000000000000000
      */
-    public static toBaseUnitAmount(amount: BigNumber.BigNumber, decimals: number): BigNumber.BigNumber {
+    public static toBaseUnitAmount(amount: BigNumber.BigNumber, numDecimals: number): BigNumber.BigNumber {
         assert.isBigNumber('amount', amount);
-        assert.isNumber('decimals', decimals);
+        assert.isNumber('numDecimals', numDecimals);
 
-        const unit = new BigNumber(10).pow(decimals);
+        const unit = new BigNumber(10).pow(numDecimals);
         const baseUnitAmount = amount.times(unit);
         return baseUnitAmount;
     }
@@ -138,7 +138,7 @@ export class ZeroEx {
         return orderHashHex;
     }
     /**
-     * Signs an orderHash and returns it's elliptic curve signature
+     * Signs an orderHash and returns it's elliptic curve signature.
      * This method currently supports TestRPC, Geth and Parity above and below V1.6.6
      */
     public async signOrderHashAsync(orderHashHex: string, signerAddress: string): Promise<ECSignature> {
diff --git a/src/contract_wrappers/contract_wrapper.ts b/src/contract_wrappers/contract_wrapper.ts
index 9f4cd8039..c3067f613 100644
--- a/src/contract_wrappers/contract_wrapper.ts
+++ b/src/contract_wrappers/contract_wrapper.ts
@@ -5,7 +5,7 @@ import {ZeroExError} from '../types';
 import {utils} from '../utils/utils';
 
 export class ContractWrapper {
-    public web3Wrapper: Web3Wrapper;
+    protected web3Wrapper: Web3Wrapper;
     constructor(web3Wrapper: Web3Wrapper) {
         this.web3Wrapper = web3Wrapper;
     }
diff --git a/src/contract_wrappers/exchange_wrapper.ts b/src/contract_wrappers/exchange_wrapper.ts
index 96dbf403a..6ef87b7ed 100644
--- a/src/contract_wrappers/exchange_wrapper.ts
+++ b/src/contract_wrappers/exchange_wrapper.ts
@@ -21,6 +21,7 @@ import {
     EventCallback,
     ContractResponse,
     OrderCancellationRequest,
+    OrderFillRequest,
 } from '../types';
 import {assert} from '../utils/assert';
 import {utils} from '../utils/utils';
@@ -71,23 +72,6 @@ export class ExchangeWrapper extends ContractWrapper {
         await this.stopWatchingExchangeLogEventsAsync();
         delete this.exchangeContractIfExists;
     }
-    public async isValidSignatureAsync(dataHex: string, ecSignature: ECSignature,
-                                       signerAddressHex: string): Promise<boolean> {
-        assert.isHexString('dataHex', dataHex);
-        assert.doesConformToSchema('ecSignature', ecSignature, ecSignatureSchema);
-        assert.isETHAddressHex('signerAddressHex', signerAddressHex);
-
-        const exchangeInstance = await this.getExchangeContractAsync();
-
-        const isValidSignature = await exchangeInstance.isValidSignature.call(
-            signerAddressHex,
-            dataHex,
-            ecSignature.v,
-            ecSignature.r,
-            ecSignature.s,
-        );
-        return isValidSignature;
-    }
     /**
      * Returns the unavailable takerAmount of an order. Unavailable amount is defined as the total
      * amount that has been filled or cancelled. The remaining takerAmount can be calculated by
@@ -127,31 +111,31 @@ export class ExchangeWrapper extends ContractWrapper {
         return cancelledAmountInBaseUnits;
     }
     /**
-     * Fills a signed order with a fillAmount denominated in baseUnits of the taker token.
+     * Fills a signed order with an amount denominated in baseUnits of the taker token.
      * Since the order in which transactions are included in the next block is indeterminate, race-conditions
      * could arise where a users balance or allowance changes before the fillOrder executes. Because of this,
      * we allow you to specify `shouldCheckTransfer`. If true, the smart contract will not throw if while
      * executing, the parties do not have sufficient balances/allowances, preserving gas costs. Setting it to
      * false forgoes this check and causes the smart contract to throw instead.
      */
-    public async fillOrderAsync(signedOrder: SignedOrder, fillTakerAmount: BigNumber.BigNumber,
+    public async fillOrderAsync(signedOrder: SignedOrder, takerTokenFillAmount: BigNumber.BigNumber,
                                 shouldCheckTransfer: boolean, takerAddress: string): Promise<void> {
         assert.doesConformToSchema('signedOrder',
                                    SchemaValidator.convertToJSONSchemaCompatibleObject(signedOrder as object),
                                    signedOrderSchema);
-        assert.isBigNumber('fillTakerAmount', fillTakerAmount);
+        assert.isBigNumber('takerTokenFillAmount', takerTokenFillAmount);
         assert.isBoolean('shouldCheckTransfer', shouldCheckTransfer);
         await assert.isSenderAddressAsync('takerAddress', takerAddress, this.web3Wrapper);
 
         const exchangeInstance = await this.getExchangeContractAsync();
-        await this.validateFillOrderAndThrowIfInvalidAsync(signedOrder, fillTakerAmount, takerAddress);
+        await this.validateFillOrderAndThrowIfInvalidAsync(signedOrder, takerTokenFillAmount, takerAddress);
 
         const [orderAddresses, orderValues] = ExchangeWrapper.getOrderAddressesAndValues(signedOrder);
 
         const gas = await exchangeInstance.fill.estimateGas(
             orderAddresses,
             orderValues,
-            fillTakerAmount,
+            takerTokenFillAmount,
             shouldCheckTransfer,
             signedOrder.ecSignature.v,
             signedOrder.ecSignature.r,
@@ -163,7 +147,7 @@ export class ExchangeWrapper extends ContractWrapper {
         const response: ContractResponse = await exchangeInstance.fill(
             orderAddresses,
             orderValues,
-            fillTakerAmount,
+            takerTokenFillAmount,
             shouldCheckTransfer,
             signedOrder.ecSignature.v,
             signedOrder.ecSignature.r,
@@ -176,6 +160,71 @@ export class ExchangeWrapper extends ContractWrapper {
         this.throwErrorLogsAsErrors(response.logs);
     }
     /**
+     * Batch version of fillOrderAsync.
+     * Executes multiple fills atomically in a single transaction.
+     * If shouldCheckTransfer is set to true, it will continue filling subsequent orders even when earlier ones fail.
+     * When shouldCheckTransfer is set to false, if any fill fails, the entire batch fails.
+     */
+    public async batchFillOrderAsync(orderFillRequests: OrderFillRequest[],
+                                     shouldCheckTransfer: boolean, takerAddress: string): Promise<void> {
+        assert.isBoolean('shouldCheckTransfer', shouldCheckTransfer);
+        await assert.isSenderAddressAsync('takerAddress', takerAddress, this.web3Wrapper);
+        _.forEach(orderFillRequests,
+            async (orderFillRequest: OrderFillRequest, i: number) => {
+            assert.doesConformToSchema(`orderFillRequests[${i}].signedOrder`,
+                SchemaValidator.convertToJSONSchemaCompatibleObject(orderFillRequest.signedOrder as object),
+                signedOrderSchema);
+            assert.isBigNumber(`orderFillRequests[${i}].takerTokenFillAmount`, orderFillRequest.takerTokenFillAmount);
+            await this.validateFillOrderAndThrowIfInvalidAsync(
+                orderFillRequest.signedOrder, orderFillRequest.takerTokenFillAmount, takerAddress);
+        });
+        if (_.isEmpty(orderFillRequests)) {
+            return; // no-op
+        }
+
+        const orderAddressesValuesAmountsAndSignatureArray = _.map(orderFillRequests, orderFillRequest => {
+            return [
+                ...ExchangeWrapper.getOrderAddressesAndValues(orderFillRequest.signedOrder),
+                orderFillRequest.takerTokenFillAmount,
+                orderFillRequest.signedOrder.ecSignature.v,
+                orderFillRequest.signedOrder.ecSignature.r,
+                orderFillRequest.signedOrder.ecSignature.s,
+            ];
+        });
+        // We use _.unzip<any> because _.unzip doesn't type check if values have different types :'(
+        const [orderAddressesArray, orderValuesArray, takerTokenFillAmountArray, vArray, rArray, sArray] = _.unzip<any>(
+            orderAddressesValuesAmountsAndSignatureArray,
+        );
+
+        const exchangeInstance = await this.getExchangeContractAsync();
+        const gas = await exchangeInstance.batchFill.estimateGas(
+            orderAddressesArray,
+            orderValuesArray,
+            takerTokenFillAmountArray,
+            shouldCheckTransfer,
+            vArray,
+            rArray,
+            sArray,
+            {
+                from: takerAddress,
+            },
+        );
+        const response: ContractResponse = await exchangeInstance.batchFill(
+            orderAddressesArray,
+            orderValuesArray,
+            takerTokenFillAmountArray,
+            shouldCheckTransfer,
+            vArray,
+            rArray,
+            sArray,
+            {
+                from: takerAddress,
+                gas,
+            },
+        );
+        this.throwErrorLogsAsErrors(response.logs);
+    }
+    /**
      * Attempts to fill a specific amount of an order. If the entire amount specified cannot be filled,
      * the fill order is abandoned.
      */
@@ -285,7 +334,7 @@ export class ExchangeWrapper extends ContractWrapper {
             SchemaValidator.convertToJSONSchemaCompatibleObject(order as object),
             orderSchema);
         assert.isBigNumber('takerTokenCancelAmount', takerTokenCancelAmount);
-        await assert.isSenderAddressAvailableAsync(this.web3Wrapper, 'order.maker', order.maker);
+        await assert.isSenderAddressAsync('order.maker', order.maker, this.web3Wrapper);
 
         const exchangeInstance = await this.getExchangeContractAsync();
         await this.validateCancelOrderAndThrowIfInvalidAsync(order, takerTokenCancelAmount);
@@ -321,7 +370,7 @@ export class ExchangeWrapper extends ContractWrapper {
         const makers = _.map(orderCancellationRequests, cancellationRequest => cancellationRequest.order.maker);
         assert.assert(_.uniq(makers).length === 1, ExchangeContractErrs.MULTIPLE_MAKERS_IN_SINGLE_CANCEL_BATCH);
         const maker = makers[0];
-        await assert.isSenderAddressAvailableAsync(this.web3Wrapper, 'maker', maker);
+        await assert.isSenderAddressAsync('maker', maker, this.web3Wrapper);
         _.forEach(orderCancellationRequests,
             async (cancellationRequest: OrderCancellationRequest, i: number) => {
             assert.doesConformToSchema(`orderCancellationRequests[${i}].order`,
@@ -389,6 +438,23 @@ export class ExchangeWrapper extends ContractWrapper {
         logEventObj.watch(callback);
         this.exchangeLogEventObjs.push(logEventObj);
     }
+    private async isValidSignatureUsingContractCallAsync(dataHex: string, ecSignature: ECSignature,
+                                                         signerAddressHex: string): Promise<boolean> {
+        assert.isHexString('dataHex', dataHex);
+        assert.doesConformToSchema('ecSignature', ecSignature, ecSignatureSchema);
+        assert.isETHAddressHex('signerAddressHex', signerAddressHex);
+
+        const exchangeInstance = await this.getExchangeContractAsync();
+
+        const isValidSignature = await exchangeInstance.isValidSignature.call(
+            signerAddressHex,
+            dataHex,
+            ecSignature.v,
+            ecSignature.r,
+            ecSignature.s,
+        );
+        return isValidSignature;
+    }
     private async getOrderHashHexAsync(order: Order|SignedOrder): Promise<string> {
         const exchangeInstance = await this.getExchangeContractAsync();
         const orderHashHex = utils.getOrderHashHex(order, exchangeInstance.address);
diff --git a/src/types.ts b/src/types.ts
index 55bab6282..dc5a5e6b3 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -68,6 +68,12 @@ export interface ExchangeContract extends ContractInstance {
         estimateGas: (orderAddresses: OrderAddresses, orderValues: OrderValues, fillAmount: BigNumber.BigNumber,
                       shouldCheckTransfer: boolean, v: number, r: string, s: string, txOpts?: TxOpts) => number;
     };
+    batchFill: {
+        (orderAddresses: OrderAddresses[], orderValues: OrderValues[], fillAmounts: BigNumber.BigNumber[],
+         shouldCheckTransfer: boolean, v: number[], r: string[], s: string[], txOpts?: TxOpts): ContractResponse;
+        estimateGas: (orderAddresses: OrderAddresses[], orderValues: OrderValues[], fillAmounts: BigNumber.BigNumber[],
+                      shouldCheckTransfer: boolean, v: number[], r: string[], s: string[], txOpts?: TxOpts) => number;
+    };
     cancel: {
         (orderAddresses: OrderAddresses, orderValues: OrderValues, cancelAmount: BigNumber.BigNumber,
          txOpts?: TxOpts): ContractResponse;
@@ -245,3 +251,8 @@ export interface OrderCancellationRequest {
     order: Order|SignedOrder;
     takerTokenCancelAmount: BigNumber.BigNumber;
 }
+
+export interface OrderFillRequest {
+    signedOrder: SignedOrder;
+    takerTokenFillAmount: BigNumber.BigNumber;
+}