Use OrderFillRequest interface for batchFillOrKill

4 files changed, 44 insertions, 52 deletions

diff --git a/src/contract_wrappers/exchange_wrapper.ts b/src/contract_wrappers/exchange_wrapper.ts
index 9e4936de6..e7b4a437f 100644
--- a/src/contract_wrappers/exchange_wrapper.ts
+++ b/src/contract_wrappers/exchange_wrapper.ts
@@ -11,7 +11,6 @@ import {
     OrderValues,
     OrderAddresses,
     Order,
-    OrderFillOrKillRequest,
     SignedOrder,
     ContractEvent,
     ExchangeEvents,
@@ -452,26 +451,26 @@ export class ExchangeWrapper extends ContractWrapper {
     /**
      * Batch version of fillOrKill. Allows a taker to specify a batch of orders that will either be atomically
      * filled (each to the specified fillAmount) or aborted.
-     * @param   orderFillOrKillRequests     An array of objects that conform to the OrderFillOrKillRequest interface.
+     * @param   orderFillRequests           An array of objects that conform to the OrderFillRequest interface.
      * @param   takerAddress                The user Ethereum address who would like to fill there orders.
      *                                      Must be available via the supplied Web3.Provider passed to 0x.js.
      * @param   orderTransactionOpts        Optional arguments this method accepts.
      * @return  Transaction hash.
      */
     @decorators.contractCallErrorHandler
-    public async batchFillOrKillAsync(orderFillOrKillRequests: OrderFillOrKillRequest[],
+    public async batchFillOrKillAsync(orderFillRequests: OrderFillRequest[],
                                       takerAddress: string,
                                       orderTransactionOpts?: OrderTransactionOpts): Promise<string> {
-        assert.doesConformToSchema('orderFillOrKillRequests', orderFillOrKillRequests,
-                                   schemas.orderFillOrKillRequestsSchema);
+        assert.doesConformToSchema('orderFillRequests', orderFillRequests,
+                                   schemas.orderFillRequestsSchema);
         const exchangeContractAddresses = _.map(
-            orderFillOrKillRequests,
-            orderFillOrKillRequest => orderFillOrKillRequest.signedOrder.exchangeContractAddress,
+            orderFillRequests,
+            orderFillRequest => orderFillRequest.signedOrder.exchangeContractAddress,
         );
         assert.hasAtMostOneUniqueValue(exchangeContractAddresses,
                                        ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress);
         await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
-        if (_.isEmpty(orderFillOrKillRequests)) {
+        if (_.isEmpty(orderFillRequests)) {
             throw new Error(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
         }
         const exchangeInstance = await this._getExchangeContractAsync();
@@ -482,18 +481,18 @@ export class ExchangeWrapper extends ContractWrapper {
         if (shouldValidate) {
             const zrxTokenAddress = await this.getZRXTokenAddressAsync();
             const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper);
-            for (const orderFillOrKillRequest of orderFillOrKillRequests) {
+            for (const orderFillRequest of orderFillRequests) {
                 await this._orderValidationUtils.validateFillOrKillOrderThrowIfInvalidAsync(
-                    exchangeTradeEmulator, orderFillOrKillRequest.signedOrder, orderFillOrKillRequest.fillTakerAmount,
+                    exchangeTradeEmulator, orderFillRequest.signedOrder, orderFillRequest.takerTokenFillAmount,
                     takerAddress, zrxTokenAddress,
                 );
             }
         }
 
-        const orderAddressesValuesAndTakerTokenFillAmounts = _.map(orderFillOrKillRequests, request => {
+        const orderAddressesValuesAndTakerTokenFillAmounts = _.map(orderFillRequests, request => {
             return [
                 ...ExchangeWrapper._getOrderAddressesAndValues(request.signedOrder),
-                request.fillTakerAmount,
+                request.takerTokenFillAmount,
                 request.signedOrder.ecSignature.v,
                 request.signedOrder.ecSignature.r,
                 request.signedOrder.ecSignature.s,
diff --git a/src/index.ts b/src/index.ts
index 97ab084b7..b9f50b0d6 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -16,7 +16,6 @@ export {
     IndexedFilterValues,
     SubscriptionOpts,
     BlockParam,
-    OrderFillOrKillRequest,
     OrderCancellationRequest,
     OrderFillRequest,
     LogErrorContractEventArgs,
diff --git a/src/types.ts b/src/types.ts
index 8c0bc1cf9..4d0b477dd 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -57,7 +57,7 @@ export interface ExchangeContract extends Web3.ContractInstance {
         callAsync: (orderHash: string, defaultBlock?: Web3.BlockParam) => Promise<BigNumber.BigNumber>;
     };
     isRoundingError: {
-        callAsync: (fillTakerAmount: BigNumber.BigNumber, takerTokenAmount: BigNumber.BigNumber,
+        callAsync: (takerTokenFillAmount: BigNumber.BigNumber, takerTokenAmount: BigNumber.BigNumber,
                     makerTokenAmount: BigNumber.BigNumber, txOpts?: TxOpts) => Promise<boolean>;
     };
     fillOrder: {
@@ -360,11 +360,6 @@ export interface SubscriptionOpts {
 
 export type DoneCallback = (err?: Error) => void;
 
-export interface OrderFillOrKillRequest {
-    signedOrder: SignedOrder;
-    fillTakerAmount: BigNumber.BigNumber;
-}
-
 export interface OrderCancellationRequest {
     order: Order|SignedOrder;
     takerTokenCancelAmount: BigNumber.BigNumber;
diff --git a/test/exchange_wrapper_test.ts b/test/exchange_wrapper_test.ts
index afc33f1f4..8c5344b37 100644
--- a/test/exchange_wrapper_test.ts
+++ b/test/exchange_wrapper_test.ts
@@ -16,9 +16,8 @@ import {
     ContractEvent,
     ExchangeContractErrs,
     OrderCancellationRequest,
-    OrderFillRequest,
     LogFillContractEventArgs,
-    OrderFillOrKillRequest,
+    OrderFillRequest,
     LogEvent,
 } from '../src';
 import {DoneCallback, BlockParamLiteral} from '../src/types';
@@ -65,7 +64,7 @@ describe('ExchangeWrapper', () => {
         let makerAddress: string;
         let takerAddress: string;
         let feeRecipient: string;
-        const fillTakerAmount = new BigNumber(5);
+        const takerTokenFillAmount = new BigNumber(5);
         before(async () => {
             [coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
             tokens = await zeroEx.tokenRegistry.getTokensAsync();
@@ -83,44 +82,44 @@ describe('ExchangeWrapper', () => {
                 const anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
                     makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
                 );
-                const orderFillOrKillRequests = [
+                const orderFillRequests = [
                     {
                         signedOrder,
-                        fillTakerAmount: partialFillTakerAmount,
+                        takerTokenFillAmount: partialFillTakerAmount,
                     },
                     {
                         signedOrder: anotherSignedOrder,
-                        fillTakerAmount: partialFillTakerAmount,
+                        takerTokenFillAmount: partialFillTakerAmount,
                     },
                 ];
-                await zeroEx.exchange.batchFillOrKillAsync(orderFillOrKillRequests, takerAddress);
+                await zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress);
             });
             describe('order transaction options', () => {
                 let signedOrder: SignedOrder;
-                let orderFillOrKillRequests: OrderFillOrKillRequest[];
+                let orderFillRequests: OrderFillRequest[];
                 const fillableAmount = new BigNumber(5);
                 beforeEach(async () => {
                     signedOrder = await fillScenarios.createFillableSignedOrderAsync(
                         makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
                     );
-                    orderFillOrKillRequests = [
+                    orderFillRequests = [
                         {
                             signedOrder,
-                            fillTakerAmount: new BigNumber(0),
+                            takerTokenFillAmount: new BigNumber(0),
                         },
                     ];
                 });
                 it('should validate when orderTransactionOptions are not present', async () => {
-                    return expect(zeroEx.exchange.batchFillOrKillAsync(orderFillOrKillRequests, takerAddress))
+                    return expect(zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress))
                         .to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
                 });
                 it('should validate when orderTransactionOptions specify to validate', async () => {
-                    return expect(zeroEx.exchange.batchFillOrKillAsync(orderFillOrKillRequests, takerAddress, {
+                    return expect(zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress, {
                         shouldValidate: true,
                     })).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
                 });
                 it('should not validate when orderTransactionOptions specify not to validate', async () => {
-                    return expect(zeroEx.exchange.batchFillOrKillAsync(orderFillOrKillRequests, takerAddress, {
+                    return expect(zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress, {
                         shouldValidate: false,
                     })).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
                 });
@@ -144,15 +143,15 @@ describe('ExchangeWrapper', () => {
                         .to.be.bignumber.equal(0);
                     expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress))
                         .to.be.bignumber.equal(fillableAmount);
-                    await zeroEx.exchange.fillOrKillOrderAsync(signedOrder, fillTakerAmount, takerAddress);
+                    await zeroEx.exchange.fillOrKillOrderAsync(signedOrder, takerTokenFillAmount, takerAddress);
                     expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress))
-                        .to.be.bignumber.equal(fillableAmount.minus(fillTakerAmount));
+                        .to.be.bignumber.equal(fillableAmount.minus(takerTokenFillAmount));
                     expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress))
-                        .to.be.bignumber.equal(fillTakerAmount);
+                        .to.be.bignumber.equal(takerTokenFillAmount);
                     expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress))
-                        .to.be.bignumber.equal(fillTakerAmount);
+                        .to.be.bignumber.equal(takerTokenFillAmount);
                     expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress))
-                        .to.be.bignumber.equal(fillableAmount.minus(fillTakerAmount));
+                        .to.be.bignumber.equal(fillableAmount.minus(takerTokenFillAmount));
                 });
                 it('should partially fill a valid order', async () => {
                     const partialFillAmount = new BigNumber(3);
@@ -194,7 +193,7 @@ describe('ExchangeWrapper', () => {
         let takerAddress: string;
         let feeRecipient: string;
         const fillableAmount = new BigNumber(5);
-        const fillTakerAmount = new BigNumber(5);
+        const takerTokenFillAmount = new BigNumber(5);
         const shouldThrowOnInsufficientBalanceOrAllowance = true;
         before(async () => {
             [coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
@@ -218,16 +217,16 @@ describe('ExchangeWrapper', () => {
                     expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress))
                         .to.be.bignumber.equal(fillableAmount);
                     const txHash = await zeroEx.exchange.fillOrderAsync(
-                        signedOrder, fillTakerAmount, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress);
+                        signedOrder, takerTokenFillAmount, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress);
                     await zeroEx.awaitTransactionMinedAsync(txHash);
                     expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress))
-                        .to.be.bignumber.equal(fillableAmount.minus(fillTakerAmount));
+                        .to.be.bignumber.equal(fillableAmount.minus(takerTokenFillAmount));
                     expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress))
-                        .to.be.bignumber.equal(fillTakerAmount);
+                        .to.be.bignumber.equal(takerTokenFillAmount);
                     expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress))
-                        .to.be.bignumber.equal(fillTakerAmount);
+                        .to.be.bignumber.equal(takerTokenFillAmount);
                     expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress))
-                        .to.be.bignumber.equal(fillableAmount.minus(fillTakerAmount));
+                        .to.be.bignumber.equal(fillableAmount.minus(takerTokenFillAmount));
                 });
                 it('should partially fill the valid order', async () => {
                     const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
@@ -254,7 +253,7 @@ describe('ExchangeWrapper', () => {
                         makerAddress, takerAddress, fillableAmount, feeRecipient,
                     );
                     const txHash = await zeroEx.exchange.fillOrderAsync(
-                        signedOrder, fillTakerAmount, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress);
+                        signedOrder, takerTokenFillAmount, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress);
                     await zeroEx.awaitTransactionMinedAsync(txHash);
                     expect(await zeroEx.token.getBalanceAsync(zrxTokenAddress, feeRecipient))
                         .to.be.bignumber.equal(makerFee.plus(takerFee));
@@ -308,11 +307,11 @@ describe('ExchangeWrapper', () => {
                     orderFillBatch = [
                         {
                             signedOrder,
-                            takerTokenFillAmount: fillTakerAmount,
+                            takerTokenFillAmount: takerTokenFillAmount,
                         },
                         {
                             signedOrder: anotherSignedOrder,
-                            takerTokenFillAmount: fillTakerAmount,
+                            takerTokenFillAmount: takerTokenFillAmount,
                         },
                     ];
                 });
@@ -327,8 +326,8 @@ describe('ExchangeWrapper', () => {
                     await zeroEx.awaitTransactionMinedAsync(txHash);
                     const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
                     const anotherFilledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
-                    expect(filledAmount).to.be.bignumber.equal(fillTakerAmount);
-                    expect(anotherFilledAmount).to.be.bignumber.equal(fillTakerAmount);
+                    expect(filledAmount).to.be.bignumber.equal(takerTokenFillAmount);
+                    expect(anotherFilledAmount).to.be.bignumber.equal(takerTokenFillAmount);
                 });
             });
             describe('order transaction options', () => {
@@ -627,7 +626,7 @@ describe('ExchangeWrapper', () => {
         let makerAddress: string;
         let fillableAmount: BigNumber.BigNumber;
         let signedOrder: SignedOrder;
-        const fillTakerAmountInBaseUnits = new BigNumber(1);
+        const takerTokenFillAmountInBaseUnits = new BigNumber(1);
         const cancelTakerAmountInBaseUnits = new BigNumber(1);
         before(() => {
             [coinbase, makerAddress, takerAddress] = userAddresses;
@@ -659,7 +658,7 @@ describe('ExchangeWrapper', () => {
                     ExchangeEvents.LogFill, indexFilterValues, callback,
                 );
                 await zeroEx.exchange.fillOrderAsync(
-                    signedOrder, fillTakerAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
+                    signedOrder, takerTokenFillAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
                 );
             })().catch(done);
         });
@@ -695,7 +694,7 @@ describe('ExchangeWrapper', () => {
                     ExchangeEvents.LogFill, indexFilterValues, callback,
                 );
                 await zeroEx.exchange.fillOrderAsync(
-                    signedOrder, fillTakerAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
+                    signedOrder, takerTokenFillAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
                 );
             })().catch(done);
         });
@@ -709,7 +708,7 @@ describe('ExchangeWrapper', () => {
                 );
                 zeroEx.exchange.unsubscribe(subscriptionToken);
                 await zeroEx.exchange.fillOrderAsync(
-                    signedOrder, fillTakerAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
+                    signedOrder, takerTokenFillAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
                 );
                 done();
             })().catch(done);