From 3335fc7bafcd9e1c7b23747622933e535a72460d Mon Sep 17 00:00:00 2001 From: Amir Bandeali Date: Sat, 21 Apr 2018 16:55:03 -0700 Subject: Rename token => asset --- packages/contracts/test/exchange/core.ts | 442 ++++++++++++++-------------- packages/contracts/test/exchange/helpers.ts | 4 +- packages/contracts/test/exchange/wrapper.ts | 438 +++++++++++++-------------- 3 files changed, 442 insertions(+), 442 deletions(-) (limited to 'packages/contracts/test/exchange') diff --git a/packages/contracts/test/exchange/core.ts b/packages/contracts/test/exchange/core.ts index a33b06a12..b2f6aaa74 100644 --- a/packages/contracts/test/exchange/core.ts +++ b/packages/contracts/test/exchange/core.ts @@ -147,8 +147,8 @@ describe('Exchange', () => { exchangeAddress: exchange.address, makerAddress, feeRecipientAddress, - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), makerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18), takerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18), makerAssetData: proxyUtils.encodeERC20ProxyData(defaultMakerTokenAddress), @@ -214,80 +214,80 @@ describe('Exchange', () => { it('should create an unfillable order', async () => { signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: new BigNumber(1001), - takerTokenAmount: new BigNumber(3), + makerAssetAmount: new BigNumber(1001), + takerAssetAmount: new BigNumber(3), }); - const takerTokenFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount( + const takerAssetFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount( orderUtils.getOrderHashHex(signedOrder), ); - expect(takerTokenFilledAmountBefore).to.be.bignumber.equal(0); + expect(takerAssetFilledAmountBefore).to.be.bignumber.equal(0); const fillTakerTokenAmount1 = new BigNumber(2); await exWrapper.fillOrderAsync(signedOrder, takerAddress, { - takerTokenFillAmount: fillTakerTokenAmount1, + takerAssetFillAmount: fillTakerTokenAmount1, }); - const takerTokenFilledAmountAfter1 = await exWrapper.getTakerTokenFilledAmount( + const takerAssetFilledAmountAfter1 = await exWrapper.getTakerTokenFilledAmount( orderUtils.getOrderHashHex(signedOrder), ); - expect(takerTokenFilledAmountAfter1).to.be.bignumber.equal(fillTakerTokenAmount1); + expect(takerAssetFilledAmountAfter1).to.be.bignumber.equal(fillTakerTokenAmount1); const fillTakerTokenAmount2 = new BigNumber(1); await exWrapper.fillOrderAsync(signedOrder, takerAddress, { - takerTokenFillAmount: fillTakerTokenAmount2, + takerAssetFillAmount: fillTakerTokenAmount2, }); - const takerTokenFilledAmountAfter2 = await exWrapper.getTakerTokenFilledAmount( + const takerAssetFilledAmountAfter2 = await exWrapper.getTakerTokenFilledAmount( orderUtils.getOrderHashHex(signedOrder), ); - expect(takerTokenFilledAmountAfter2).to.be.bignumber.equal(takerTokenFilledAmountAfter1); + expect(takerAssetFilledAmountAfter2).to.be.bignumber.equal(takerAssetFilledAmountAfter1); }); - it('should transfer the correct amounts when makerTokenAmount === takerTokenAmount', async () => { + it('should transfer the correct amounts when makerAssetAmount === takerAssetAmount', async () => { signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), }); - const takerTokenFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount( + const takerAssetFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount( orderUtils.getOrderHashHex(signedOrder), ); - expect(takerTokenFilledAmountBefore).to.be.bignumber.equal(0); + expect(takerAssetFilledAmountBefore).to.be.bignumber.equal(0); - const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2); - await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }); + const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2); + await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }); const makerAmountBoughtAfter = await exWrapper.getTakerTokenFilledAmount( orderUtils.getOrderHashHex(signedOrder), ); - expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerTokenFillAmount); + expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerAssetFillAmount); const newBalances = await dmyBalances.getAsync(); - const makerTokenFilledAmount = takerTokenFillAmount - .times(signedOrder.makerTokenAmount) - .dividedToIntegerBy(signedOrder.takerTokenAmount); + const makerAssetFilledAmount = takerAssetFillAmount + .times(signedOrder.makerAssetAmount) + .dividedToIntegerBy(signedOrder.takerAssetAmount); const makerFeePaid = signedOrder.makerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); const takerFeePaid = signedOrder.takerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount), + balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount), ); expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount), + balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount), ); expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( balances[makerAddress][zrx.address].minus(makerFeePaid), ); expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount), + balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount), ); expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount), + balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount), ); expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( balances[takerAddress][zrx.address].minus(takerFeePaid), @@ -297,50 +297,50 @@ describe('Exchange', () => { ); }); - it('should transfer the correct amounts when makerTokenAmount > takerTokenAmount', async () => { + it('should transfer the correct amounts when makerAssetAmount > takerAssetAmount', async () => { signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), }); - const takerTokenFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount( + const takerAssetFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount( orderUtils.getOrderHashHex(signedOrder), ); - expect(takerTokenFilledAmountBefore).to.be.bignumber.equal(0); + expect(takerAssetFilledAmountBefore).to.be.bignumber.equal(0); - const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2); - await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }); + const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2); + await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }); const makerAmountBoughtAfter = await exWrapper.getTakerTokenFilledAmount( orderUtils.getOrderHashHex(signedOrder), ); - expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerTokenFillAmount); + expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerAssetFillAmount); const newBalances = await dmyBalances.getAsync(); - const makerTokenFilledAmount = takerTokenFillAmount - .times(signedOrder.makerTokenAmount) - .dividedToIntegerBy(signedOrder.takerTokenAmount); + const makerAssetFilledAmount = takerAssetFillAmount + .times(signedOrder.makerAssetAmount) + .dividedToIntegerBy(signedOrder.takerAssetAmount); const makerFeePaid = signedOrder.makerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); const takerFeePaid = signedOrder.takerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount), + balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount), ); expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount), + balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount), ); expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( balances[makerAddress][zrx.address].minus(makerFeePaid), ); expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount), + balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount), ); expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount), + balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount), ); expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( balances[takerAddress][zrx.address].minus(takerFeePaid), @@ -350,50 +350,50 @@ describe('Exchange', () => { ); }); - it('should transfer the correct amounts when makerTokenAmount < takerTokenAmount', async () => { + it('should transfer the correct amounts when makerAssetAmount < takerAssetAmount', async () => { signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), }); - const takerTokenFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount( + const takerAssetFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount( orderUtils.getOrderHashHex(signedOrder), ); - expect(takerTokenFilledAmountBefore).to.be.bignumber.equal(0); + expect(takerAssetFilledAmountBefore).to.be.bignumber.equal(0); - const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2); - await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }); + const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2); + await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }); const makerAmountBoughtAfter = await exWrapper.getTakerTokenFilledAmount( orderUtils.getOrderHashHex(signedOrder), ); - expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerTokenFillAmount); + expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerAssetFillAmount); const newBalances = await dmyBalances.getAsync(); - const makerTokenFilledAmount = takerTokenFillAmount - .times(signedOrder.makerTokenAmount) - .dividedToIntegerBy(signedOrder.takerTokenAmount); + const makerAssetFilledAmount = takerAssetFillAmount + .times(signedOrder.makerAssetAmount) + .dividedToIntegerBy(signedOrder.takerAssetAmount); const makerFeePaid = signedOrder.makerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); const takerFeePaid = signedOrder.takerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount), + balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount), ); expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount), + balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount), ); expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( balances[makerAddress][zrx.address].minus(makerFeePaid), ); expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount), + balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount), ); expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount), + balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount), ); expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( balances[takerAddress][zrx.address].minus(takerFeePaid), @@ -406,49 +406,49 @@ describe('Exchange', () => { it('should transfer the correct amounts when taker is specified and order is claimed by taker', async () => { signedOrder = orderFactory.newSignedOrder({ takerAddress, - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), }); - const takerTokenFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount( + const takerAssetFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount( orderUtils.getOrderHashHex(signedOrder), ); - expect(takerTokenFilledAmountBefore).to.be.bignumber.equal(0); + expect(takerAssetFilledAmountBefore).to.be.bignumber.equal(0); - const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2); - await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }); + const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2); + await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }); const makerAmountBoughtAfter = await exWrapper.getTakerTokenFilledAmount( orderUtils.getOrderHashHex(signedOrder), ); - const expectedMakerAmountBoughtAfter = takerTokenFillAmount.add(takerTokenFilledAmountBefore); + const expectedMakerAmountBoughtAfter = takerAssetFillAmount.add(takerAssetFilledAmountBefore); expect(makerAmountBoughtAfter).to.be.bignumber.equal(expectedMakerAmountBoughtAfter); const newBalances = await dmyBalances.getAsync(); - const makerTokenFilledAmount = takerTokenFillAmount - .times(signedOrder.makerTokenAmount) - .dividedToIntegerBy(signedOrder.takerTokenAmount); + const makerAssetFilledAmount = takerAssetFillAmount + .times(signedOrder.makerAssetAmount) + .dividedToIntegerBy(signedOrder.takerAssetAmount); const makerFeePaid = signedOrder.makerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); const takerFeePaid = signedOrder.takerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount), + balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount), ); expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount), + balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount), ); expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( balances[makerAddress][zrx.address].minus(makerFeePaid), ); expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount), + balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount), ); expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount), + balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount), ); expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( balances[takerAddress][zrx.address].minus(takerFeePaid), @@ -458,33 +458,33 @@ describe('Exchange', () => { ); }); - it('should fill remaining value if takerTokenFillAmount > remaining takerTokenAmount', async () => { - const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2); - await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }); + it('should fill remaining value if takerAssetFillAmount > remaining takerAssetAmount', async () => { + const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2); + await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }); const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress, { - takerTokenFillAmount: signedOrder.takerTokenAmount, + takerAssetFillAmount: signedOrder.takerAssetAmount, }); const log = res.logs[0] as LogWithDecodedArgs; - expect(log.args.takerTokenFilledAmount).to.be.bignumber.equal( - signedOrder.takerTokenAmount.minus(takerTokenFillAmount), + expect(log.args.takerAssetFilledAmount).to.be.bignumber.equal( + signedOrder.takerAssetAmount.minus(takerAssetFillAmount), ); const newBalances = await dmyBalances.getAsync(); expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultMakerTokenAddress].minus(signedOrder.makerTokenAmount), + balances[makerAddress][defaultMakerTokenAddress].minus(signedOrder.makerAssetAmount), ); expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultTakerTokenAddress].add(signedOrder.takerTokenAmount), + balances[makerAddress][defaultTakerTokenAddress].add(signedOrder.takerAssetAmount), ); expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( balances[makerAddress][zrx.address].minus(signedOrder.makerFee), ); expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultTakerTokenAddress].minus(signedOrder.takerTokenAmount), + balances[takerAddress][defaultTakerTokenAddress].minus(signedOrder.takerAssetAmount), ); expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultMakerTokenAddress].add(signedOrder.makerTokenAmount), + balances[takerAddress][defaultMakerTokenAddress].add(signedOrder.makerAssetAmount), ); expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( balances[takerAddress][zrx.address].minus(signedOrder.takerFee), @@ -497,14 +497,14 @@ describe('Exchange', () => { it('should log 1 event with the correct arguments when order has a feeRecipient', async () => { const divisor = 2; const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress, { - takerTokenFillAmount: signedOrder.takerTokenAmount.div(divisor), + takerAssetFillAmount: signedOrder.takerAssetAmount.div(divisor), }); expect(res.logs).to.have.length(1); const log = res.logs[0] as LogWithDecodedArgs; const logArgs = log.args; - const expectedFilledMakerTokenAmount = signedOrder.makerTokenAmount.div(divisor); - const expectedFilledTakerTokenAmount = signedOrder.takerTokenAmount.div(divisor); + const expectedFilledMakerTokenAmount = signedOrder.makerAssetAmount.div(divisor); + const expectedFilledTakerTokenAmount = signedOrder.takerAssetAmount.div(divisor); const expectedFeeMPaid = signedOrder.makerFee.div(divisor); const expectedFeeTPaid = signedOrder.takerFee.div(divisor); @@ -513,8 +513,8 @@ describe('Exchange', () => { expect(signedOrder.feeRecipientAddress).to.be.equal(logArgs.feeRecipientAddress); expect(signedOrder.makerAssetData).to.be.equal(logArgs.makerAssetData); expect(signedOrder.takerAssetData).to.be.equal(logArgs.takerAssetData); - expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.makerTokenFilledAmount); - expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.takerTokenFilledAmount); + expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.makerAssetFilledAmount); + expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.takerAssetFilledAmount); expect(expectedFeeMPaid).to.be.bignumber.equal(logArgs.makerFeePaid); expect(expectedFeeTPaid).to.be.bignumber.equal(logArgs.takerFeePaid); expect(orderUtils.getOrderHashHex(signedOrder)).to.be.equal(logArgs.orderHash); @@ -526,14 +526,14 @@ describe('Exchange', () => { }); const divisor = 2; const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress, { - takerTokenFillAmount: signedOrder.takerTokenAmount.div(divisor), + takerAssetFillAmount: signedOrder.takerAssetAmount.div(divisor), }); expect(res.logs).to.have.length(1); const log = res.logs[0] as LogWithDecodedArgs; const logArgs = log.args; - const expectedFilledMakerTokenAmount = signedOrder.makerTokenAmount.div(divisor); - const expectedFilledTakerTokenAmount = signedOrder.takerTokenAmount.div(divisor); + const expectedFilledMakerTokenAmount = signedOrder.makerAssetAmount.div(divisor); + const expectedFilledTakerTokenAmount = signedOrder.takerAssetAmount.div(divisor); const expectedFeeMPaid = new BigNumber(0); const expectedFeeTPaid = new BigNumber(0); @@ -542,8 +542,8 @@ describe('Exchange', () => { expect(signedOrder.feeRecipientAddress).to.be.equal(logArgs.feeRecipientAddress); expect(signedOrder.makerAssetData).to.be.equal(logArgs.makerAssetData); expect(signedOrder.takerAssetData).to.be.equal(logArgs.takerAssetData); - expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.makerTokenFilledAmount); - expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.takerTokenFilledAmount); + expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.makerAssetFilledAmount); + expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.takerAssetFilledAmount); expect(expectedFeeMPaid).to.be.bignumber.equal(logArgs.makerFeePaid); expect(expectedFeeTPaid).to.be.bignumber.equal(logArgs.takerFeePaid); expect(orderUtils.getOrderHashHex(signedOrder)).to.be.equal(logArgs.orderHash); @@ -552,15 +552,15 @@ describe('Exchange', () => { it('should throw when taker is specified and order is claimed by other', async () => { signedOrder = orderFactory.newSignedOrder({ takerAddress: feeRecipientAddress, - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), }); return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT); }); it('should throw if signature is invalid', async () => { signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(10), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(10), 18), }); const invalidR = ethUtil.sha3('invalidR'); @@ -572,35 +572,35 @@ describe('Exchange', () => { return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT); }); - it('should throw if makerTokenAmount is 0', async () => { + it('should throw if makerAssetAmount is 0', async () => { signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: new BigNumber(0), + makerAssetAmount: new BigNumber(0), }); return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT); }); - it('should throw if takerTokenAmount is 0', async () => { + it('should throw if takerAssetAmount is 0', async () => { signedOrder = orderFactory.newSignedOrder({ - takerTokenAmount: new BigNumber(0), + takerAssetAmount: new BigNumber(0), }); return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT); }); - it('should throw if takerTokenFillAmount is 0', async () => { + it('should throw if takerAssetFillAmount is 0', async () => { signedOrder = orderFactory.newSignedOrder(); return expect( exWrapper.fillOrderAsync(signedOrder, takerAddress, { - takerTokenFillAmount: new BigNumber(0), + takerAssetFillAmount: new BigNumber(0), }), ).to.be.rejectedWith(constants.REVERT); }); it('should throw if maker balances are too low to fill order', async () => { signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18), }); return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT); @@ -608,7 +608,7 @@ describe('Exchange', () => { it('should throw if taker balances are too low to fill order', async () => { signedOrder = orderFactory.newSignedOrder({ - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18), }); return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT); @@ -678,17 +678,17 @@ describe('Exchange', () => { return expect(exWrapper.cancelOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT); }); - it('should throw if makerTokenAmount is 0', async () => { + it('should throw if makerAssetAmount is 0', async () => { signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: new BigNumber(0), + makerAssetAmount: new BigNumber(0), }); return expect(exWrapper.cancelOrderAsync(signedOrder, makerAddress)).to.be.rejectedWith(constants.REVERT); }); - it('should throw if takerTokenAmount is 0', async () => { + it('should throw if takerAssetAmount is 0', async () => { signedOrder = orderFactory.newSignedOrder({ - takerTokenAmount: new BigNumber(0), + takerAssetAmount: new BigNumber(0), }); return expect(exWrapper.cancelOrderAsync(signedOrder, makerAddress)).to.be.rejectedWith(constants.REVERT); @@ -697,7 +697,7 @@ describe('Exchange', () => { it('should be able to cancel a full order', async () => { await exWrapper.cancelOrderAsync(signedOrder, makerAddress); await exWrapper.fillOrderAsync(signedOrder, takerAddress, { - takerTokenFillAmount: signedOrder.takerTokenAmount.div(2), + takerAssetFillAmount: signedOrder.takerAssetAmount.div(2), }); const newBalances = await dmyBalances.getAsync(); @@ -770,31 +770,31 @@ describe('Exchange', () => { balances = await dmyBalances.getAsync(); const signedOrders = await Promise.all([ orderFactory.newSignedOrder({ - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(9), 18), - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(9), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(9), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(9), 18), salt: new BigNumber(0), }), orderFactory.newSignedOrder({ - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(79), 18), - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(79), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(79), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(79), 18), salt: new BigNumber(1), }), orderFactory.newSignedOrder({ - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(979), 18), - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(979), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(979), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(979), 18), salt: new BigNumber(2), }), orderFactory.newSignedOrder({ - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(7979), 18), - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(7979), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(7979), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(7979), 18), salt: new BigNumber(3), }), ]); await exWrapper.batchFillOrdersNoThrowAsync(signedOrders, takerAddress); const newBalances = await dmyBalances.getAsync(); - const fillMakerTokenAmount = signedOrders[2].makerTokenAmount.add(signedOrders[3].makerTokenAmount); - const fillTakerTokenAmount = signedOrders[2].takerTokenAmount.add(signedOrders[3].takerTokenAmount); + const fillMakerTokenAmount = signedOrders[2].makerAssetAmount.add(signedOrders[3].makerAssetAmount); + const fillTakerTokenAmount = signedOrders[2].takerAssetAmount.add(signedOrders[3].takerAssetAmount); const makerFee = signedOrders[2].makerFee.add(signedOrders[3].makerFee); const takerFee = signedOrders[2].takerFee.add(signedOrders[3].takerFee); expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( @@ -824,165 +824,165 @@ describe('Exchange', () => { describe('Testing Exchange of ERC721 Tokens', () => { it('should successfully exchange a single token between the maker and taker (via fillOrder)', async () => { // Construct Exchange parameters - const makerTokenId = erc721MakerTokenIds[0]; - const takerTokenId = erc721TakerTokenIds[1]; + const makerAssetId = erc721MakerTokenIds[0]; + const takerAssetId = erc721TakerTokenIds[1]; signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: new BigNumber(1), - takerTokenAmount: new BigNumber(1), - makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId), - takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId), + makerAssetAmount: new BigNumber(1), + takerAssetAmount: new BigNumber(1), + makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId), + takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId), }); // Verify pre-conditions - const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId); + const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId); expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress); - const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId); + const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId); expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress); // Call Exchange - const takerTokenFillAmount = signedOrder.takerTokenAmount; - const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }); + const takerAssetFillAmount = signedOrder.takerAssetAmount; + const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }); // Verify post-conditions - const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId); + const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId); expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress); - const newOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId); + const newOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId); expect(newOwnerTakerToken).to.be.bignumber.equal(makerAddress); }); - it('should throw when maker does not own the token with id makerTokenId', async () => { + it('should throw when maker does not own the token with id makerAssetId', async () => { // Construct Exchange parameters - const makerTokenId = erc721TakerTokenIds[0]; - const takerTokenId = erc721TakerTokenIds[1]; + const makerAssetId = erc721TakerTokenIds[0]; + const takerAssetId = erc721TakerTokenIds[1]; signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: new BigNumber(1), - takerTokenAmount: new BigNumber(1), - makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId), - takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId), + makerAssetAmount: new BigNumber(1), + takerAssetAmount: new BigNumber(1), + makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId), + takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId), }); // Verify pre-conditions - const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId); + const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId); expect(initialOwnerMakerToken).to.be.bignumber.not.equal(makerAddress); - const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId); + const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId); expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress); // Call Exchange - const takerTokenFillAmount = signedOrder.takerTokenAmount; + const takerAssetFillAmount = signedOrder.takerAssetAmount; return expect( - exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }), + exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }), ).to.be.rejectedWith(constants.REVERT); }); - it('should throw when taker does not own the token with id takerTokenId', async () => { + it('should throw when taker does not own the token with id takerAssetId', async () => { // Construct Exchange parameters - const makerTokenId = erc721MakerTokenIds[0]; - const takerTokenId = erc721MakerTokenIds[1]; + const makerAssetId = erc721MakerTokenIds[0]; + const takerAssetId = erc721MakerTokenIds[1]; signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: new BigNumber(1), - takerTokenAmount: new BigNumber(1), - makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId), - takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId), + makerAssetAmount: new BigNumber(1), + takerAssetAmount: new BigNumber(1), + makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId), + takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId), }); // Verify pre-conditions - const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId); + const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId); expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress); - const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId); + const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId); expect(initialOwnerTakerToken).to.be.bignumber.not.equal(takerAddress); // Call Exchange - const takerTokenFillAmount = signedOrder.takerTokenAmount; + const takerAssetFillAmount = signedOrder.takerAssetAmount; return expect( - exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }), + exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }), ).to.be.rejectedWith(constants.REVERT); }); - it('should throw when makerTokenAmount is greater than 1', async () => { + it('should throw when makerAssetAmount is greater than 1', async () => { // Construct Exchange parameters - const makerTokenId = erc721MakerTokenIds[0]; - const takerTokenId = erc721TakerTokenIds[0]; + const makerAssetId = erc721MakerTokenIds[0]; + const takerAssetId = erc721TakerTokenIds[0]; signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: new BigNumber(2), - takerTokenAmount: new BigNumber(1), - makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId), - takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId), + makerAssetAmount: new BigNumber(2), + takerAssetAmount: new BigNumber(1), + makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId), + takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId), }); // Verify pre-conditions - const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId); + const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId); expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress); - const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId); + const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId); expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress); // Call Exchange - const takerTokenFillAmount = signedOrder.takerTokenAmount; + const takerAssetFillAmount = signedOrder.takerAssetAmount; return expect( - exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }), + exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }), ).to.be.rejectedWith(constants.REVERT); }); - it('should throw when takerTokenAmount is greater than 1', async () => { + it('should throw when takerAssetAmount is greater than 1', async () => { // Construct Exchange parameters - const makerTokenId = erc721MakerTokenIds[0]; - const takerTokenId = erc721TakerTokenIds[0]; + const makerAssetId = erc721MakerTokenIds[0]; + const takerAssetId = erc721TakerTokenIds[0]; signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: new BigNumber(1), - takerTokenAmount: new BigNumber(500), - makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId), - takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId), + makerAssetAmount: new BigNumber(1), + takerAssetAmount: new BigNumber(500), + makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId), + takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId), }); // Verify pre-conditions - const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId); + const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId); expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress); - const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId); + const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId); expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress); // Call Exchange - const takerTokenFillAmount = signedOrder.takerTokenAmount; + const takerAssetFillAmount = signedOrder.takerAssetAmount; return expect( - exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }), + exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }), ).to.be.rejectedWith(constants.REVERT); }); it('should throw on partial fill', async () => { // Construct Exchange parameters - const makerTokenId = erc721MakerTokenIds[0]; - const takerTokenId = erc721TakerTokenIds[0]; + const makerAssetId = erc721MakerTokenIds[0]; + const takerAssetId = erc721TakerTokenIds[0]; signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: new BigNumber(1), - takerTokenAmount: new BigNumber(0), - makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId), - takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId), + makerAssetAmount: new BigNumber(1), + takerAssetAmount: new BigNumber(0), + makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId), + takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId), }); // Verify pre-conditions - const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId); + const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId); expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress); - const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId); + const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId); expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress); // Call Exchange - const takerTokenFillAmount = signedOrder.takerTokenAmount; + const takerAssetFillAmount = signedOrder.takerAssetAmount; return expect( - exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }), + exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }), ).to.be.rejectedWith(constants.REVERT); }); - it('should successfully fill order when makerToken is ERC721 and takerToken is ERC20', async () => { + it('should successfully fill order when makerAsset is ERC721 and takerAsset is ERC20', async () => { // Construct Exchange parameters - const makerTokenId = erc721MakerTokenIds[0]; + const makerAssetId = erc721MakerTokenIds[0]; signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: new BigNumber(1), - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), - makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId), + makerAssetAmount: new BigNumber(1), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), + makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId), takerAssetData: proxyUtils.encodeERC20ProxyData(defaultTakerTokenAddress), }); // Verify pre-conditions - const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId); + const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId); expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress); // Call Exchange balances = await dmyBalances.getAsync(); - const takerTokenFillAmount = signedOrder.takerTokenAmount; - await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }); + const takerAssetFillAmount = signedOrder.takerAssetAmount; + await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }); // Verify ERC721 token was transferred from Maker to Taker - const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId); + const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId); expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress); // Verify ERC20 tokens were transferred from Taker to Maker & fees were paid correctly const newBalances = await dmyBalances.getAsync(); expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount), + balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount), ); expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount), + balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount), ); expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( balances[makerAddress][zrx.address].minus(signedOrder.makerFee), @@ -995,32 +995,32 @@ describe('Exchange', () => { ); }); - it('should successfully fill order when makerToken is ERC20 and takerToken is ERC721', async () => { + it('should successfully fill order when makerAsset is ERC20 and takerAsset is ERC721', async () => { // Construct Exchange parameters - const takerTokenId = erc721TakerTokenIds[0]; + const takerAssetId = erc721TakerTokenIds[0]; signedOrder = orderFactory.newSignedOrder({ - takerTokenAmount: new BigNumber(1), - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), - takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId), + takerAssetAmount: new BigNumber(1), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), + takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId), makerAssetData: proxyUtils.encodeERC20ProxyData(defaultMakerTokenAddress), }); // Verify pre-conditions - const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId); + const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId); expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress); // Call Exchange balances = await dmyBalances.getAsync(); - const takerTokenFillAmount = signedOrder.takerTokenAmount; - await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }); + const takerAssetFillAmount = signedOrder.takerAssetAmount; + await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }); // Verify ERC721 token was transferred from Taker to Maker - const newOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId); + const newOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId); expect(newOwnerTakerToken).to.be.bignumber.equal(makerAddress); // Verify ERC20 tokens were transferred from Maker to Taker & fees were paid correctly const newBalances = await dmyBalances.getAsync(); expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultMakerTokenAddress].add(signedOrder.makerTokenAmount), + balances[takerAddress][defaultMakerTokenAddress].add(signedOrder.makerAssetAmount), ); expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultMakerTokenAddress].minus(signedOrder.makerTokenAmount), + balances[makerAddress][defaultMakerTokenAddress].minus(signedOrder.makerAssetAmount), ); expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( balances[makerAddress][zrx.address].minus(signedOrder.makerFee), diff --git a/packages/contracts/test/exchange/helpers.ts b/packages/contracts/test/exchange/helpers.ts index f758de1c9..dada8920b 100644 --- a/packages/contracts/test/exchange/helpers.ts +++ b/packages/contracts/test/exchange/helpers.ts @@ -54,8 +54,8 @@ describe('Exchange', () => { exchangeAddress: exchange.address, makerAddress, feeRecipientAddress, - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), makerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18), takerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18), makerAssetData: proxyUtils.encodeERC20ProxyData(rep.address), diff --git a/packages/contracts/test/exchange/wrapper.ts b/packages/contracts/test/exchange/wrapper.ts index e6e2d7060..9c16697bc 100644 --- a/packages/contracts/test/exchange/wrapper.ts +++ b/packages/contracts/test/exchange/wrapper.ts @@ -125,8 +125,8 @@ describe('Exchange', () => { exchangeAddress: exchange.address, makerAddress, feeRecipientAddress, - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), makerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18), takerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18), makerAssetData: proxyUtils.encodeERC20ProxyData(defaultMakerTokenAddress), @@ -169,39 +169,39 @@ describe('Exchange', () => { describe('fillOrKillOrder', () => { it('should transfer the correct amounts', async () => { const signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), }); - const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2); + const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2); await exWrapper.fillOrKillOrderAsync(signedOrder, takerAddress, { - takerTokenFillAmount, + takerAssetFillAmount, }); const newBalances = await dmyBalances.getAsync(); - const makerTokenFilledAmount = takerTokenFillAmount - .times(signedOrder.makerTokenAmount) - .dividedToIntegerBy(signedOrder.takerTokenAmount); + const makerAssetFilledAmount = takerAssetFillAmount + .times(signedOrder.makerAssetAmount) + .dividedToIntegerBy(signedOrder.takerAssetAmount); const makerFee = signedOrder.makerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); const takerFee = signedOrder.takerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount), + balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount), ); expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount), + balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount), ); expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( balances[makerAddress][zrx.address].minus(makerFee), ); expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount), + balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount), ); expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount), + balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount), ); expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( balances[takerAddress][zrx.address].minus(takerFee), @@ -221,11 +221,11 @@ describe('Exchange', () => { ); }); - it('should throw if entire takerTokenFillAmount not filled', async () => { + it('should throw if entire takerAssetFillAmount not filled', async () => { const signedOrder = orderFactory.newSignedOrder(); await exWrapper.fillOrderAsync(signedOrder, takerAddress, { - takerTokenFillAmount: signedOrder.takerTokenAmount.div(2), + takerAssetFillAmount: signedOrder.takerAssetAmount.div(2), }); return expect(exWrapper.fillOrKillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith( @@ -237,39 +237,39 @@ describe('Exchange', () => { describe('fillOrderNoThrow', () => { it('should transfer the correct amounts', async () => { const signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18), }); - const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2); + const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2); await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress, { - takerTokenFillAmount, + takerAssetFillAmount, }); const newBalances = await dmyBalances.getAsync(); - const makerTokenFilledAmount = takerTokenFillAmount - .times(signedOrder.makerTokenAmount) - .dividedToIntegerBy(signedOrder.takerTokenAmount); + const makerAssetFilledAmount = takerAssetFillAmount + .times(signedOrder.makerAssetAmount) + .dividedToIntegerBy(signedOrder.takerAssetAmount); const makerFee = signedOrder.makerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); const takerFee = signedOrder.takerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount), + balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount), ); expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount), + balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount), ); expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( balances[makerAddress][zrx.address].minus(makerFee), ); expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount), + balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount), ); expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount), + balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount), ); expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( balances[takerAddress][zrx.address].minus(takerFee), @@ -281,7 +281,7 @@ describe('Exchange', () => { it('should not change balances if maker balances are too low to fill order', async () => { const signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18), + makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18), }); await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress); @@ -291,7 +291,7 @@ describe('Exchange', () => { it('should not change balances if taker balances are too low to fill order', async () => { const signedOrder = orderFactory.newSignedOrder({ - takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18), + takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18), }); await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress); @@ -327,10 +327,10 @@ describe('Exchange', () => { expect(newBalances).to.be.deep.equal(balances); }); - it('should not change balances if makerTokenAddress is ZRX, makerTokenAmount + makerFee > maker balance', async () => { + it('should not change balances if makerAssetAddress is ZRX, makerAssetAmount + makerFee > maker balance', async () => { const makerZRXBalance = new BigNumber(balances[makerAddress][zrx.address]); const signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: makerZRXBalance, + makerAssetAmount: makerZRXBalance, makerFee: new BigNumber(1), makerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address), }); @@ -339,10 +339,10 @@ describe('Exchange', () => { expect(newBalances).to.be.deep.equal(balances); }); - it('should not change balances if makerTokenAddress is ZRX, makerTokenAmount + makerFee > maker allowance', async () => { + it('should not change balances if makerAssetAddress is ZRX, makerAssetAmount + makerFee > maker allowance', async () => { const makerZRXAllowance = await zrx.allowance.callAsync(makerAddress, erc20Proxy.address); const signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: new BigNumber(makerZRXAllowance), + makerAssetAmount: new BigNumber(makerZRXAllowance), makerFee: new BigNumber(1), makerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address), }); @@ -351,10 +351,10 @@ describe('Exchange', () => { expect(newBalances).to.be.deep.equal(balances); }); - it('should not change balances if takerTokenAddress is ZRX, takerTokenAmount + takerFee > taker balance', async () => { + it('should not change balances if takerAssetAddress is ZRX, takerAssetAmount + takerFee > taker balance', async () => { const takerZRXBalance = new BigNumber(balances[takerAddress][zrx.address]); const signedOrder = orderFactory.newSignedOrder({ - takerTokenAmount: takerZRXBalance, + takerAssetAmount: takerZRXBalance, takerFee: new BigNumber(1), takerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address), }); @@ -363,10 +363,10 @@ describe('Exchange', () => { expect(newBalances).to.be.deep.equal(balances); }); - it('should not change balances if takerTokenAddress is ZRX, takerTokenAmount + takerFee > taker allowance', async () => { + it('should not change balances if takerAssetAddress is ZRX, takerAssetAmount + takerFee > taker allowance', async () => { const takerZRXAllowance = await zrx.allowance.callAsync(takerAddress, erc20Proxy.address); const signedOrder = orderFactory.newSignedOrder({ - takerTokenAmount: new BigNumber(takerZRXAllowance), + takerAssetAmount: new BigNumber(takerZRXAllowance), takerFee: new BigNumber(1), takerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address), }); @@ -377,26 +377,26 @@ describe('Exchange', () => { it('should successfully exchange ERC721 tokens', async () => { // Construct Exchange parameters - const makerTokenId = erc721MakerTokenId; - const takerTokenId = erc721TakerTokenId; + const makerAssetId = erc721MakerTokenId; + const takerAssetId = erc721TakerTokenId; const signedOrder = orderFactory.newSignedOrder({ - makerTokenAmount: new BigNumber(1), - takerTokenAmount: new BigNumber(1), - makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId), - takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId), + makerAssetAmount: new BigNumber(1), + takerAssetAmount: new BigNumber(1), + makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId), + takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId), }); // Verify pre-conditions - const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId); + const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId); expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress); - const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId); + const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId); expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress); // Call Exchange - const takerTokenFillAmount = signedOrder.takerTokenAmount; - await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress, { takerTokenFillAmount }); + const takerAssetFillAmount = signedOrder.takerAssetAmount; + await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress, { takerAssetFillAmount }); // Verify post-conditions - const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId); + const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId); expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress); - const newOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId); + const newOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId); expect(newOwnerTakerToken).to.be.bignumber.equal(makerAddress); }); }); @@ -413,33 +413,33 @@ describe('Exchange', () => { describe('batchFillOrders', () => { it('should transfer the correct amounts', async () => { - const takerTokenFillAmounts: BigNumber[] = []; - const makerTokenAddress = rep.address; - const takerTokenAddress = dgd.address; + const takerAssetFillAmounts: BigNumber[] = []; + const makerAssetAddress = rep.address; + const takerAssetAddress = dgd.address; _.forEach(signedOrders, signedOrder => { - const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2); - const makerTokenFilledAmount = takerTokenFillAmount - .times(signedOrder.makerTokenAmount) - .dividedToIntegerBy(signedOrder.takerTokenAmount); + const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2); + const makerAssetFilledAmount = takerAssetFillAmount + .times(signedOrder.makerAssetAmount) + .dividedToIntegerBy(signedOrder.takerAssetAmount); const makerFee = signedOrder.makerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); const takerFee = signedOrder.takerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); - takerTokenFillAmounts.push(takerTokenFillAmount); - balances[makerAddress][makerTokenAddress] = balances[makerAddress][makerTokenAddress].minus( - makerTokenFilledAmount, + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); + takerAssetFillAmounts.push(takerAssetFillAmount); + balances[makerAddress][makerAssetAddress] = balances[makerAddress][makerAssetAddress].minus( + makerAssetFilledAmount, ); - balances[makerAddress][takerTokenAddress] = balances[makerAddress][takerTokenAddress].add( - takerTokenFillAmount, + balances[makerAddress][takerAssetAddress] = balances[makerAddress][takerAssetAddress].add( + takerAssetFillAmount, ); balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(makerFee); - balances[takerAddress][makerTokenAddress] = balances[takerAddress][makerTokenAddress].add( - makerTokenFilledAmount, + balances[takerAddress][makerAssetAddress] = balances[takerAddress][makerAssetAddress].add( + makerAssetFilledAmount, ); - balances[takerAddress][takerTokenAddress] = balances[takerAddress][takerTokenAddress].minus( - takerTokenFillAmount, + balances[takerAddress][takerAssetAddress] = balances[takerAddress][takerAssetAddress].minus( + takerAssetFillAmount, ); balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(takerFee); balances[feeRecipientAddress][zrx.address] = balances[feeRecipientAddress][zrx.address].add( @@ -448,7 +448,7 @@ describe('Exchange', () => { }); await exWrapper.batchFillOrdersAsync(signedOrders, takerAddress, { - takerTokenFillAmounts, + takerAssetFillAmounts, }); const newBalances = await dmyBalances.getAsync(); @@ -458,33 +458,33 @@ describe('Exchange', () => { describe('batchFillOrKillOrders', () => { it('should transfer the correct amounts', async () => { - const takerTokenFillAmounts: BigNumber[] = []; - const makerTokenAddress = rep.address; - const takerTokenAddress = dgd.address; + const takerAssetFillAmounts: BigNumber[] = []; + const makerAssetAddress = rep.address; + const takerAssetAddress = dgd.address; _.forEach(signedOrders, signedOrder => { - const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2); - const makerTokenFilledAmount = takerTokenFillAmount - .times(signedOrder.makerTokenAmount) - .dividedToIntegerBy(signedOrder.takerTokenAmount); + const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2); + const makerAssetFilledAmount = takerAssetFillAmount + .times(signedOrder.makerAssetAmount) + .dividedToIntegerBy(signedOrder.takerAssetAmount); const makerFee = signedOrder.makerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); const takerFee = signedOrder.takerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); - takerTokenFillAmounts.push(takerTokenFillAmount); - balances[makerAddress][makerTokenAddress] = balances[makerAddress][makerTokenAddress].minus( - makerTokenFilledAmount, + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); + takerAssetFillAmounts.push(takerAssetFillAmount); + balances[makerAddress][makerAssetAddress] = balances[makerAddress][makerAssetAddress].minus( + makerAssetFilledAmount, ); - balances[makerAddress][takerTokenAddress] = balances[makerAddress][takerTokenAddress].add( - takerTokenFillAmount, + balances[makerAddress][takerAssetAddress] = balances[makerAddress][takerAssetAddress].add( + takerAssetFillAmount, ); balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(makerFee); - balances[takerAddress][makerTokenAddress] = balances[takerAddress][makerTokenAddress].add( - makerTokenFilledAmount, + balances[takerAddress][makerAssetAddress] = balances[takerAddress][makerAssetAddress].add( + makerAssetFilledAmount, ); - balances[takerAddress][takerTokenAddress] = balances[takerAddress][takerTokenAddress].minus( - takerTokenFillAmount, + balances[takerAddress][takerAssetAddress] = balances[takerAddress][takerAssetAddress].minus( + takerAssetFillAmount, ); balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(takerFee); balances[feeRecipientAddress][zrx.address] = balances[feeRecipientAddress][zrx.address].add( @@ -493,7 +493,7 @@ describe('Exchange', () => { }); await exWrapper.batchFillOrKillOrdersAsync(signedOrders, takerAddress, { - takerTokenFillAmounts, + takerAssetFillAmounts, }); const newBalances = await dmyBalances.getAsync(); @@ -501,17 +501,17 @@ describe('Exchange', () => { }); it('should throw if a single signedOrder does not fill the expected amount', async () => { - const takerTokenFillAmounts: BigNumber[] = []; + const takerAssetFillAmounts: BigNumber[] = []; _.forEach(signedOrders, signedOrder => { - const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2); - takerTokenFillAmounts.push(takerTokenFillAmount); + const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2); + takerAssetFillAmounts.push(takerAssetFillAmount); }); await exWrapper.fillOrKillOrderAsync(signedOrders[0], takerAddress); return expect( exWrapper.batchFillOrKillOrdersAsync(signedOrders, takerAddress, { - takerTokenFillAmounts, + takerAssetFillAmounts, }), ).to.be.rejectedWith(constants.REVERT); }); @@ -519,33 +519,33 @@ describe('Exchange', () => { describe('batchFillOrdersNoThrow', async () => { it('should transfer the correct amounts', async () => { - const takerTokenFillAmounts: BigNumber[] = []; - const makerTokenAddress = rep.address; - const takerTokenAddress = dgd.address; + const takerAssetFillAmounts: BigNumber[] = []; + const makerAssetAddress = rep.address; + const takerAssetAddress = dgd.address; _.forEach(signedOrders, signedOrder => { - const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2); - const makerTokenFilledAmount = takerTokenFillAmount - .times(signedOrder.makerTokenAmount) - .dividedToIntegerBy(signedOrder.takerTokenAmount); + const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2); + const makerAssetFilledAmount = takerAssetFillAmount + .times(signedOrder.makerAssetAmount) + .dividedToIntegerBy(signedOrder.takerAssetAmount); const makerFee = signedOrder.makerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); const takerFee = signedOrder.takerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); - takerTokenFillAmounts.push(takerTokenFillAmount); - balances[makerAddress][makerTokenAddress] = balances[makerAddress][makerTokenAddress].minus( - makerTokenFilledAmount, + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); + takerAssetFillAmounts.push(takerAssetFillAmount); + balances[makerAddress][makerAssetAddress] = balances[makerAddress][makerAssetAddress].minus( + makerAssetFilledAmount, ); - balances[makerAddress][takerTokenAddress] = balances[makerAddress][takerTokenAddress].add( - takerTokenFillAmount, + balances[makerAddress][takerAssetAddress] = balances[makerAddress][takerAssetAddress].add( + takerAssetFillAmount, ); balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(makerFee); - balances[takerAddress][makerTokenAddress] = balances[takerAddress][makerTokenAddress].add( - makerTokenFilledAmount, + balances[takerAddress][makerAssetAddress] = balances[takerAddress][makerAssetAddress].add( + makerAssetFilledAmount, ); - balances[takerAddress][takerTokenAddress] = balances[takerAddress][takerTokenAddress].minus( - takerTokenFillAmount, + balances[takerAddress][takerAssetAddress] = balances[takerAddress][takerAssetAddress].minus( + takerAssetFillAmount, ); balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(takerFee); balances[feeRecipientAddress][zrx.address] = balances[feeRecipientAddress][zrx.address].add( @@ -554,7 +554,7 @@ describe('Exchange', () => { }); await exWrapper.batchFillOrdersNoThrowAsync(signedOrders, takerAddress, { - takerTokenFillAmounts, + takerAssetFillAmounts, }); const newBalances = await dmyBalances.getAsync(); @@ -562,9 +562,9 @@ describe('Exchange', () => { }); it('should not throw if an order is invalid and fill the remaining orders', async () => { - const takerTokenFillAmounts: BigNumber[] = []; - const makerTokenAddress = rep.address; - const takerTokenAddress = dgd.address; + const takerAssetFillAmounts: BigNumber[] = []; + const makerAssetAddress = rep.address; + const takerAssetAddress = dgd.address; const invalidOrder = { ...signedOrders[0], @@ -572,31 +572,31 @@ describe('Exchange', () => { }; const validOrders = signedOrders.slice(1); - takerTokenFillAmounts.push(invalidOrder.takerTokenAmount.div(2)); + takerAssetFillAmounts.push(invalidOrder.takerAssetAmount.div(2)); _.forEach(validOrders, signedOrder => { - const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2); - const makerTokenFilledAmount = takerTokenFillAmount - .times(signedOrder.makerTokenAmount) - .dividedToIntegerBy(signedOrder.takerTokenAmount); + const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2); + const makerAssetFilledAmount = takerAssetFillAmount + .times(signedOrder.makerAssetAmount) + .dividedToIntegerBy(signedOrder.takerAssetAmount); const makerFee = signedOrder.makerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); const takerFee = signedOrder.takerFee - .times(makerTokenFilledAmount) - .dividedToIntegerBy(signedOrder.makerTokenAmount); - takerTokenFillAmounts.push(takerTokenFillAmount); - balances[makerAddress][makerTokenAddress] = balances[makerAddress][makerTokenAddress].minus( - makerTokenFilledAmount, + .times(makerAssetFilledAmount) + .dividedToIntegerBy(signedOrder.makerAssetAmount); + takerAssetFillAmounts.push(takerAssetFillAmount); + balances[makerAddress][makerAssetAddress] = balances[makerAddress][makerAssetAddress].minus( + makerAssetFilledAmount, ); - balances[makerAddress][takerTokenAddress] = balances[makerAddress][takerTokenAddress].add( - takerTokenFillAmount, + balances[makerAddress][takerAssetAddress] = balances[makerAddress][takerAssetAddress].add( + takerAssetFillAmount, ); balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(makerFee); - balances[takerAddress][makerTokenAddress] = balances[takerAddress][makerTokenAddress].add( - makerTokenFilledAmount, + balances[takerAddress][makerAssetAddress] = balances[takerAddress][makerAssetAddress].add( + makerAssetFilledAmount, ); - balances[takerAddress][takerTokenAddress] = balances[takerAddress][takerTokenAddress].minus( - takerTokenFillAmount, + balances[takerAddress][takerAssetAddress] = balances[takerAddress][takerAssetAddress].minus( + takerAssetFillAmount, ); balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(takerFee); balances[feeRecipientAddress][zrx.address] = balances[feeRecipientAddress][zrx.address].add( @@ -606,7 +606,7 @@ describe('Exchange', () => { const newOrders = [invalidOrder, ...validOrders]; await exWrapper.batchFillOrdersNoThrowAsync(newOrders, takerAddress, { - takerTokenFillAmounts, + takerAssetFillAmounts, }); const newBalances = await dmyBalances.getAsync(); @@ -615,35 +615,35 @@ describe('Exchange', () => { }); describe('marketSellOrders', () => { - it('should stop when the entire takerTokenFillAmount is filled', async () => { - const takerTokenFillAmount = signedOrders[0].takerTokenAmount.plus( - signedOrders[1].takerTokenAmount.div(2), + it('should stop when the entire takerAssetFillAmount is filled', async () => { + const takerAssetFillAmount = signedOrders[0].takerAssetAmount.plus( + signedOrders[1].takerAssetAmount.div(2), ); await exWrapper.marketSellOrdersAsync(signedOrders, takerAddress, { - takerTokenFillAmount, + takerAssetFillAmount, }); const newBalances = await dmyBalances.getAsync(); - const makerTokenFilledAmount = signedOrders[0].makerTokenAmount.add( - signedOrders[1].makerTokenAmount.dividedToIntegerBy(2), + const makerAssetFilledAmount = signedOrders[0].makerAssetAmount.add( + signedOrders[1].makerAssetAmount.dividedToIntegerBy(2), ); const makerFee = signedOrders[0].makerFee.add(signedOrders[1].makerFee.dividedToIntegerBy(2)); const takerFee = signedOrders[0].takerFee.add(signedOrders[1].takerFee.dividedToIntegerBy(2)); expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount), + balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount), ); expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount), + balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount), ); expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( balances[makerAddress][zrx.address].minus(makerFee), ); expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount), + balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount), ); expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount), + balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount), ); expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( balances[takerAddress][zrx.address].minus(takerFee), @@ -653,24 +653,24 @@ describe('Exchange', () => { ); }); - it('should fill all signedOrders if cannot fill entire takerTokenFillAmount', async () => { - const takerTokenFillAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18); + it('should fill all signedOrders if cannot fill entire takerAssetFillAmount', async () => { + const takerAssetFillAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18); _.forEach(signedOrders, signedOrder => { balances[makerAddress][defaultMakerTokenAddress] = balances[makerAddress][ defaultMakerTokenAddress - ].minus(signedOrder.makerTokenAmount); + ].minus(signedOrder.makerAssetAmount); balances[makerAddress][defaultTakerTokenAddress] = balances[makerAddress][ defaultTakerTokenAddress - ].add(signedOrder.takerTokenAmount); + ].add(signedOrder.takerAssetAmount); balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus( signedOrder.makerFee, ); balances[takerAddress][defaultMakerTokenAddress] = balances[takerAddress][ defaultMakerTokenAddress - ].add(signedOrder.makerTokenAmount); + ].add(signedOrder.makerAssetAmount); balances[takerAddress][defaultTakerTokenAddress] = balances[takerAddress][ defaultTakerTokenAddress - ].minus(signedOrder.takerTokenAmount); + ].minus(signedOrder.takerAssetAmount); balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus( signedOrder.takerFee, ); @@ -679,14 +679,14 @@ describe('Exchange', () => { ); }); await exWrapper.marketSellOrdersAsync(signedOrders, takerAddress, { - takerTokenFillAmount, + takerAssetFillAmount, }); const newBalances = await dmyBalances.getAsync(); expect(newBalances).to.be.deep.equal(balances); }); - it('should throw when an signedOrder does not use the same takerTokenAddress', async () => { + it('should throw when an signedOrder does not use the same takerAssetAddress', async () => { signedOrders = [ orderFactory.newSignedOrder(), orderFactory.newSignedOrder({ takerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address) }), @@ -695,42 +695,42 @@ describe('Exchange', () => { return expect( exWrapper.marketSellOrdersAsync(signedOrders, takerAddress, { - takerTokenFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18), + takerAssetFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18), }), ).to.be.rejectedWith(constants.REVERT); }); }); describe('marketSellOrdersNoThrow', () => { - it('should stop when the entire takerTokenFillAmount is filled', async () => { - const takerTokenFillAmount = signedOrders[0].takerTokenAmount.plus( - signedOrders[1].takerTokenAmount.div(2), + it('should stop when the entire takerAssetFillAmount is filled', async () => { + const takerAssetFillAmount = signedOrders[0].takerAssetAmount.plus( + signedOrders[1].takerAssetAmount.div(2), ); await exWrapper.marketSellOrdersNoThrowAsync(signedOrders, takerAddress, { - takerTokenFillAmount, + takerAssetFillAmount, }); const newBalances = await dmyBalances.getAsync(); - const makerTokenFilledAmount = signedOrders[0].makerTokenAmount.add( - signedOrders[1].makerTokenAmount.dividedToIntegerBy(2), + const makerAssetFilledAmount = signedOrders[0].makerAssetAmount.add( + signedOrders[1].makerAssetAmount.dividedToIntegerBy(2), ); const makerFee = signedOrders[0].makerFee.add(signedOrders[1].makerFee.dividedToIntegerBy(2)); const takerFee = signedOrders[0].takerFee.add(signedOrders[1].takerFee.dividedToIntegerBy(2)); expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount), + balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount), ); expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount), + balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount), ); expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal( balances[makerAddress][zrx.address].minus(makerFee), ); expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount), + balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount), ); expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount), + balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount), ); expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( balances[takerAddress][zrx.address].minus(takerFee), @@ -740,24 +740,24 @@ describe('Exchange', () => { ); }); - it('should fill all signedOrders if cannot fill entire takerTokenFillAmount', async () => { - const takerTokenFillAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18); + it('should fill all signedOrders if cannot fill entire takerAssetFillAmount', async () => { + const takerAssetFillAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18); _.forEach(signedOrders, signedOrder => { balances[makerAddress][defaultMakerTokenAddress] = balances[makerAddress][ defaultMakerTokenAddress - ].minus(signedOrder.makerTokenAmount); + ].minus(signedOrder.makerAssetAmount); balances[makerAddress][defaultTakerTokenAddress] = balances[makerAddress][ defaultTakerTokenAddress - ].add(signedOrder.takerTokenAmount); + ].add(signedOrder.takerAssetAmount); balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus( signedOrder.makerFee, ); balances[takerAddress][defaultMakerTokenAddress] = balances[takerAddress][ defaultMakerTokenAddress - ].add(signedOrder.makerTokenAmount); + ].add(signedOrder.makerAssetAmount); balances[takerAddress][defaultTakerTokenAddress] = balances[takerAddress][ defaultTakerTokenAddress - ].minus(signedOrder.takerTokenAmount); + ].minus(signedOrder.takerAssetAmount); balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus( signedOrder.takerFee, ); @@ -766,14 +766,14 @@ describe('Exchange', () => { ); }); await exWrapper.marketSellOrdersNoThrowAsync(signedOrders, takerAddress, { - takerTokenFillAmount, + takerAssetFillAmount, }); const newBalances = await dmyBalances.getAsync(); expect(newBalances).to.be.deep.equal(balances); }); - it('should throw when a signedOrder does not use the same takerTokenAddress', async () => { + it('should throw when a signedOrder does not use the same takerAssetAddress', async () => { signedOrders = [ orderFactory.newSignedOrder(), orderFactory.newSignedOrder({ takerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address) }), @@ -782,30 +782,30 @@ describe('Exchange', () => { return expect( exWrapper.marketSellOrdersNoThrowAsync(signedOrders, takerAddress, { - takerTokenFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18), + takerAssetFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18), }), ).to.be.rejectedWith(constants.REVERT); }); }); describe('marketBuyOrders', () => { - it('should stop when the entire makerTokenFillAmount is filled', async () => { - const makerTokenFillAmount = signedOrders[0].makerTokenAmount.plus( - signedOrders[1].makerTokenAmount.div(2), + it('should stop when the entire makerAssetFillAmount is filled', async () => { + const makerAssetFillAmount = signedOrders[0].makerAssetAmount.plus( + signedOrders[1].makerAssetAmount.div(2), ); await exWrapper.marketBuyOrdersAsync(signedOrders, takerAddress, { - makerTokenFillAmount, + makerAssetFillAmount, }); const newBalances = await dmyBalances.getAsync(); - const makerAmountBought = signedOrders[0].takerTokenAmount.add( - signedOrders[1].takerTokenAmount.dividedToIntegerBy(2), + const makerAmountBought = signedOrders[0].takerAssetAmount.add( + signedOrders[1].takerAssetAmount.dividedToIntegerBy(2), ); const makerFee = signedOrders[0].makerFee.add(signedOrders[1].makerFee.dividedToIntegerBy(2)); const takerFee = signedOrders[0].takerFee.add(signedOrders[1].takerFee.dividedToIntegerBy(2)); expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFillAmount), + balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFillAmount), ); expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( balances[makerAddress][defaultTakerTokenAddress].add(makerAmountBought), @@ -817,7 +817,7 @@ describe('Exchange', () => { balances[takerAddress][defaultTakerTokenAddress].minus(makerAmountBought), ); expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFillAmount), + balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFillAmount), ); expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( balances[takerAddress][zrx.address].minus(takerFee), @@ -827,24 +827,24 @@ describe('Exchange', () => { ); }); - it('should fill all signedOrders if cannot fill entire makerTokenFillAmount', async () => { - const makerTokenFillAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18); + it('should fill all signedOrders if cannot fill entire makerAssetFillAmount', async () => { + const makerAssetFillAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18); _.forEach(signedOrders, signedOrder => { balances[makerAddress][defaultMakerTokenAddress] = balances[makerAddress][ defaultMakerTokenAddress - ].minus(signedOrder.makerTokenAmount); + ].minus(signedOrder.makerAssetAmount); balances[makerAddress][defaultTakerTokenAddress] = balances[makerAddress][ defaultTakerTokenAddress - ].add(signedOrder.takerTokenAmount); + ].add(signedOrder.takerAssetAmount); balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus( signedOrder.makerFee, ); balances[takerAddress][defaultMakerTokenAddress] = balances[takerAddress][ defaultMakerTokenAddress - ].add(signedOrder.makerTokenAmount); + ].add(signedOrder.makerAssetAmount); balances[takerAddress][defaultTakerTokenAddress] = balances[takerAddress][ defaultTakerTokenAddress - ].minus(signedOrder.takerTokenAmount); + ].minus(signedOrder.takerAssetAmount); balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus( signedOrder.takerFee, ); @@ -853,14 +853,14 @@ describe('Exchange', () => { ); }); await exWrapper.marketBuyOrdersAsync(signedOrders, takerAddress, { - makerTokenFillAmount, + makerAssetFillAmount, }); const newBalances = await dmyBalances.getAsync(); expect(newBalances).to.be.deep.equal(balances); }); - it('should throw when an signedOrder does not use the same makerTokenAddress', async () => { + it('should throw when an signedOrder does not use the same makerAssetAddress', async () => { signedOrders = [ orderFactory.newSignedOrder(), orderFactory.newSignedOrder({ makerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address) }), @@ -869,30 +869,30 @@ describe('Exchange', () => { return expect( exWrapper.marketBuyOrdersAsync(signedOrders, takerAddress, { - makerTokenFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18), + makerAssetFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18), }), ).to.be.rejectedWith(constants.REVERT); }); }); describe('marketBuyOrdersNoThrow', () => { - it('should stop when the entire makerTokenFillAmount is filled', async () => { - const makerTokenFillAmount = signedOrders[0].makerTokenAmount.plus( - signedOrders[1].makerTokenAmount.div(2), + it('should stop when the entire makerAssetFillAmount is filled', async () => { + const makerAssetFillAmount = signedOrders[0].makerAssetAmount.plus( + signedOrders[1].makerAssetAmount.div(2), ); await exWrapper.marketBuyOrdersNoThrowAsync(signedOrders, takerAddress, { - makerTokenFillAmount, + makerAssetFillAmount, }); const newBalances = await dmyBalances.getAsync(); - const makerAmountBought = signedOrders[0].takerTokenAmount.add( - signedOrders[1].takerTokenAmount.dividedToIntegerBy(2), + const makerAmountBought = signedOrders[0].takerAssetAmount.add( + signedOrders[1].takerAssetAmount.dividedToIntegerBy(2), ); const makerFee = signedOrders[0].makerFee.add(signedOrders[1].makerFee.dividedToIntegerBy(2)); const takerFee = signedOrders[0].takerFee.add(signedOrders[1].takerFee.dividedToIntegerBy(2)); expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFillAmount), + balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFillAmount), ); expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal( balances[makerAddress][defaultTakerTokenAddress].add(makerAmountBought), @@ -904,7 +904,7 @@ describe('Exchange', () => { balances[takerAddress][defaultTakerTokenAddress].minus(makerAmountBought), ); expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal( - balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFillAmount), + balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFillAmount), ); expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal( balances[takerAddress][zrx.address].minus(takerFee), @@ -914,24 +914,24 @@ describe('Exchange', () => { ); }); - it('should fill all signedOrders if cannot fill entire takerTokenFillAmount', async () => { - const takerTokenFillAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18); + it('should fill all signedOrders if cannot fill entire takerAssetFillAmount', async () => { + const takerAssetFillAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18); _.forEach(signedOrders, signedOrder => { balances[makerAddress][defaultMakerTokenAddress] = balances[makerAddress][ defaultMakerTokenAddress - ].minus(signedOrder.makerTokenAmount); + ].minus(signedOrder.makerAssetAmount); balances[makerAddress][defaultTakerTokenAddress] = balances[makerAddress][ defaultTakerTokenAddress - ].add(signedOrder.takerTokenAmount); + ].add(signedOrder.takerAssetAmount); balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus( signedOrder.makerFee, ); balances[takerAddress][defaultMakerTokenAddress] = balances[takerAddress][ defaultMakerTokenAddress - ].add(signedOrder.makerTokenAmount); + ].add(signedOrder.makerAssetAmount); balances[takerAddress][defaultTakerTokenAddress] = balances[takerAddress][ defaultTakerTokenAddress - ].minus(signedOrder.takerTokenAmount); + ].minus(signedOrder.takerAssetAmount); balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus( signedOrder.takerFee, ); @@ -940,14 +940,14 @@ describe('Exchange', () => { ); }); await exWrapper.marketSellOrdersNoThrowAsync(signedOrders, takerAddress, { - takerTokenFillAmount, + takerAssetFillAmount, }); const newBalances = await dmyBalances.getAsync(); expect(newBalances).to.be.deep.equal(balances); }); - it('should throw when a signedOrder does not use the same makerTokenAddress', async () => { + it('should throw when a signedOrder does not use the same makerAssetAddress', async () => { signedOrders = [ orderFactory.newSignedOrder(), orderFactory.newSignedOrder({ makerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address) }), @@ -956,7 +956,7 @@ describe('Exchange', () => { return expect( exWrapper.marketBuyOrdersNoThrowAsync(signedOrders, takerAddress, { - makerTokenFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18), + makerAssetFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18), }), ).to.be.rejectedWith(constants.REVERT); }); @@ -964,11 +964,11 @@ describe('Exchange', () => { describe('batchCancelOrders', () => { it('should be able to cancel multiple signedOrders', async () => { - const takerTokenCancelAmounts = _.map(signedOrders, signedOrder => signedOrder.takerTokenAmount); + const takerAssetCancelAmounts = _.map(signedOrders, signedOrder => signedOrder.takerAssetAmount); await exWrapper.batchCancelOrdersAsync(signedOrders, makerAddress); await exWrapper.batchFillOrdersAsync(signedOrders, takerAddress, { - takerTokenFillAmounts: takerTokenCancelAmounts, + takerAssetFillAmounts: takerAssetCancelAmounts, }); const newBalances = await dmyBalances.getAsync(); expect(balances).to.be.deep.equal(newBalances); -- cgit v1.2.3