Merge development

packages/contracts/test/exchange/core.ts

@@ -441,11 +441,10 @@ describe('Exchange', () => {
             expect(signedOrder.feeRecipient).to.be.equal(logArgs.feeRecipient);
             expect(signedOrder.makerTokenAddress).to.be.equal(logArgs.makerToken);
             expect(signedOrder.takerTokenAddress).to.be.equal(logArgs.takerToken);
-            expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.filledMakerTokenAmount);
-            expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.filledTakerTokenAmount);
+            expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.makerTokenFilledAmount);
+            expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.takerTokenFilledAmount);
             expect(expectedFeeMPaid).to.be.bignumber.equal(logArgs.makerFeePaid);
             expect(expectedFeeTPaid).to.be.bignumber.equal(logArgs.takerFeePaid);
-            expect(expectedTokens).to.be.equal(logArgs.tokens);
             expect(ZeroEx.getOrderHashHex(signedOrder)).to.be.equal(logArgs.orderHash);
         });
 
@@ -472,11 +471,10 @@ describe('Exchange', () => {
             expect(signedOrder.feeRecipient).to.be.equal(logArgs.feeRecipient);
             expect(signedOrder.makerTokenAddress).to.be.equal(logArgs.makerToken);
             expect(signedOrder.takerTokenAddress).to.be.equal(logArgs.takerToken);
-            expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.filledMakerTokenAmount);
-            expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.filledTakerTokenAmount);
+            expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.makerTokenFilledAmount);
+            expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.takerTokenFilledAmount);
             expect(expectedFeeMPaid).to.be.bignumber.equal(logArgs.makerFeePaid);
             expect(expectedFeeTPaid).to.be.bignumber.equal(logArgs.takerFeePaid);
-            expect(expectedTokens).to.be.equal(logArgs.tokens);
             expect(ZeroEx.getOrderHashHex(signedOrder)).to.be.equal(logArgs.orderHash);
         });
 
@@ -764,7 +762,7 @@ describe('Exchange', () => {
                 takerTokenFillAmount: signedOrder.takerTokenAmount,
             });
             const log = res.logs[0] as LogWithDecodedArgs<LogFillContractEventArgs>;
-            expect(log.args.filledTakerTokenAmount).to.be.bignumber.equal(
+            expect(log.args.takerTokenFilledAmount).to.be.bignumber.equal(
                 signedOrder.takerTokenAmount.minus(takerTokenCancelAmount),
             );
 
@@ -819,9 +817,8 @@ describe('Exchange', () => {
             expect(signedOrder.feeRecipient).to.be.equal(logArgs.feeRecipient);
             expect(signedOrder.makerTokenAddress).to.be.equal(logArgs.makerToken);
             expect(signedOrder.takerTokenAddress).to.be.equal(logArgs.takerToken);
-            expect(expectedCancelledMakerTokenAmount).to.be.bignumber.equal(logArgs.cancelledMakerTokenAmount);
-            expect(expectedCancelledTakerTokenAmount).to.be.bignumber.equal(logArgs.cancelledTakerTokenAmount);
-            expect(expectedTokens).to.be.equal(logArgs.tokens);
+            expect(expectedCancelledMakerTokenAmount).to.be.bignumber.equal(logArgs.makerTokenCancelledAmount);
+            expect(expectedCancelledTakerTokenAmount).to.be.bignumber.equal(logArgs.takerTokenCancelledAmount);
             expect(ZeroEx.getOrderHashHex(signedOrder)).to.be.equal(logArgs.orderHash);
         });
 

packages/contracts/util/exchange_wrapper.ts

@@ -144,13 +144,13 @@ export class ExchangeWrapper {
     public async batchCancelOrdersAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { cancelTakerTokenAmounts?: BigNumber[] } = {},
+        opts: { takerTokenCancelAmounts?: BigNumber[] } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = formatters.createBatchCancel(orders, opts.cancelTakerTokenAmounts);
+        const params = formatters.createBatchCancel(orders, opts.takerTokenCancelAmounts);
         const txHash = await this._exchange.batchCancelOrders.sendTransactionAsync(
             params.orderAddresses,
             params.orderValues,
-            params.cancelTakerTokenAmounts,
+            params.takerTokenCancelAmounts,
             { from },
         );
         const tx = await this._zeroEx.awaitTransactionMinedAsync(txHash);

packages/contracts/util/formatters.ts

@@ -76,11 +76,11 @@ export const formatters = {
         });
         return marketFillOrders;
     },
-    createBatchCancel(signedOrders: SignedOrder[], cancelTakerTokenAmounts: BigNumber[] = []) {
+    createBatchCancel(signedOrders: SignedOrder[], takerTokenCancelAmounts: BigNumber[] = []) {
         const batchCancel: BatchCancelOrders = {
             orderAddresses: [],
             orderValues: [],
-            cancelTakerTokenAmounts,
+            takerTokenCancelAmounts,
         };
         signedOrders.forEach(signedOrder => {
             batchCancel.orderAddresses.push([
@@ -98,8 +98,8 @@ export const formatters = {
                 signedOrder.expirationUnixTimestampSec,
                 signedOrder.salt,
             ]);
-            if (cancelTakerTokenAmounts.length < signedOrders.length) {
-                batchCancel.cancelTakerTokenAmounts.push(signedOrder.takerTokenAmount);
+            if (takerTokenCancelAmounts.length < signedOrders.length) {
+                batchCancel.takerTokenCancelAmounts.push(signedOrder.takerTokenAmount);
             }
         });
         return batchCancel;

packages/contracts/util/order.ts

@@ -1,105 +0,0 @@
-import { BigNumber } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
-import ethUtil = require('ethereumjs-util');
-import * as _ from 'lodash';
-
-import { crypto } from './crypto';
-import { OrderParams } from './types';
-
-export class Order {
-    public params: OrderParams;
-    private _web3Wrapper: Web3Wrapper;
-    constructor(web3Wrapper: Web3Wrapper, params: OrderParams) {
-        this.params = params;
-        this._web3Wrapper = web3Wrapper;
-    }
-    public isValidSignature() {
-        const { v, r, s } = this.params;
-        if (_.isUndefined(v) || _.isUndefined(r) || _.isUndefined(s)) {
-            throw new Error('Cannot call isValidSignature on unsigned order');
-        }
-        const orderHash = this._getOrderHash();
-        const msgHash = ethUtil.hashPersonalMessage(ethUtil.toBuffer(orderHash));
-        try {
-            const pubKey = ethUtil.ecrecover(msgHash, v, ethUtil.toBuffer(r), ethUtil.toBuffer(s));
-            const recoveredAddress = ethUtil.bufferToHex(ethUtil.pubToAddress(pubKey));
-            return recoveredAddress === this.params.maker;
-        } catch (err) {
-            return false;
-        }
-    }
-    public async signAsync() {
-        const orderHash = this._getOrderHash();
-        const signature = await this._web3Wrapper.signTransactionAsync(this.params.maker, orderHash);
-        const { v, r, s } = ethUtil.fromRpcSig(signature);
-        this.params = _.assign(this.params, {
-            orderHashHex: orderHash,
-            v,
-            r: ethUtil.bufferToHex(r),
-            s: ethUtil.bufferToHex(s),
-        });
-    }
-    public createFill(takerTokenFillAmount?: BigNumber) {
-        const fill = {
-            orderAddresses: [
-                this.params.maker,
-                this.params.taker,
-                this.params.makerToken,
-                this.params.takerToken,
-                this.params.feeRecipient,
-            ],
-            orderValues: [
-                this.params.makerTokenAmount,
-                this.params.takerTokenAmount,
-                this.params.makerFee,
-                this.params.takerFee,
-                this.params.expirationTimestampInSec,
-                this.params.salt,
-            ],
-            takerTokenFillAmount: takerTokenFillAmount || this.params.takerTokenAmount,
-            v: this.params.v,
-            r: this.params.r,
-            s: this.params.s,
-        };
-        return fill;
-    }
-    public createCancel(takerTokenCancelAmount?: BigNumber) {
-        const cancel = {
-            orderAddresses: [
-                this.params.maker,
-                this.params.taker,
-                this.params.makerToken,
-                this.params.takerToken,
-                this.params.feeRecipient,
-            ],
-            orderValues: [
-                this.params.makerTokenAmount,
-                this.params.takerTokenAmount,
-                this.params.makerFee,
-                this.params.takerFee,
-                this.params.expirationTimestampInSec,
-                this.params.salt,
-            ],
-            takerTokenCancelAmount: takerTokenCancelAmount || this.params.takerTokenAmount,
-        };
-        return cancel;
-    }
-    private _getOrderHash(): string {
-        const orderHash = crypto.solSHA3([
-            this.params.exchangeContractAddress,
-            this.params.maker,
-            this.params.taker,
-            this.params.makerToken,
-            this.params.takerToken,
-            this.params.feeRecipient,
-            this.params.makerTokenAmount,
-            this.params.takerTokenAmount,
-            this.params.makerFee,
-            this.params.takerFee,
-            this.params.expirationTimestampInSec,
-            this.params.salt,
-        ]);
-        const orderHashHex = ethUtil.bufferToHex(orderHash);
-        return orderHashHex;
-    }
-}

packages/contracts/util/types.ts

@@ -32,7 +32,7 @@ export interface MarketFillOrders {
 export interface BatchCancelOrders {
     orderAddresses: string[][];
     orderValues: BigNumber[][];
-    cancelTakerTokenAmounts: BigNumber[];
+    takerTokenCancelAmounts: BigNumber[];
 }
 
 export interface DefaultOrderParams {