chore: Rename price to amount. Encode parameters in makerAssetData

2 files changed, 149 insertions, 134 deletions

diff --git a/packages/contracts/contracts/extensions/DutchAuction/DutchAuction.sol b/packages/contracts/contracts/extensions/DutchAuction/DutchAuction.sol
index bb75fc188..a304184f1 100644
--- a/packages/contracts/contracts/extensions/DutchAuction/DutchAuction.sol
+++ b/packages/contracts/contracts/extensions/DutchAuction/DutchAuction.sol
@@ -32,12 +32,12 @@ contract DutchAuction {
     IExchange internal EXCHANGE;
 
     struct AuctionDetails {
-        uint256 beginTime;    // Auction begin time in seconds
-        uint256 endTime;      // Auction end time in seconds
-        uint256 beginPrice;   // Auction begin price
-        uint256 endPrice;     // Auction end price
-        uint256 currentPrice; // Current auction price at block.timestamp
-        uint256 currentTime;  // block.timestamp
+        uint256 beginTimeSeconds;    // Auction begin time in seconds
+        uint256 endTimeSeconds;      // Auction end time in seconds
+        uint256 beginAmount;         // Auction begin amount
+        uint256 endAmount;           // Auction end amount
+        uint256 currentAmount;       // Current auction amount at block.timestamp
+        uint256 currentTimeSeconds;  // block.timestamp
     }
 
     constructor (address _exchange)
@@ -46,35 +46,15 @@ contract DutchAuction {
         EXCHANGE = IExchange(_exchange);
     }
 
-    /// @dev Packs the begin time and price parameters of an auction into uint256.
-    ///      This is stored as the salt value of the sale order.
-    /// @param beginTime Begin time of the auction (32 bits)
-    /// @param beginPrice Starting price of the auction (224 bits)
-    /// @return Encoded Auction Parameters packed into a uint256
-    function encodeParameters(
-        uint256 beginTime,
-        uint256 beginPrice
-    )
-        external
-        view
-        returns (uint256 encodedParameters)
-    {
-        require(beginTime <= 2**32, "INVALID_BEGIN_TIME");
-        require(beginPrice <= 2**224, "INVALID_BEGIN_PRICE");
-        encodedParameters = beginTime;
-        encodedParameters |= beginPrice<<32;
-        return encodedParameters;
-    }
-
-    /// @dev Performs a match of the two orders at the price point given the current block time and the auction
-    ///      start time (encoded in the salt).
-    ///      The Sellers order is a signed order at the lowest price at the end of the auction. Excess from the match
+    /// @dev Performs a match of the two orders at the amount given: the current block time, the auction
+    ///      start time and the auction begin amount.
+    ///      The Sellers order is a signed order at the lowest amount at the end of the auction. Excess from the match
     ///      is transferred to the seller.
     /// @param buyOrder The Buyer's order
     /// @param sellOrder The Seller's order
     /// @param buySignature Proof that order was created by the left maker.
     /// @param sellSignature Proof that order was created by the right maker.
-    /// @return matchedFillResults Amounts filled and fees paid by maker and taker of matched orders.
+    /// @return matchedFillResults amounts filled and fees paid by maker and taker of matched orders.
     function matchOrders(
         LibOrder.Order memory buyOrder,
         LibOrder.Order memory sellOrder,
@@ -86,13 +66,13 @@ contract DutchAuction {
     {
         AuctionDetails memory auctionDetails = getAuctionDetails(sellOrder);
         // Ensure the auction has not yet started
-        require(auctionDetails.currentTime >= auctionDetails.beginTime, "AUCTION_NOT_STARTED");
+        require(auctionDetails.currentTimeSeconds >= auctionDetails.beginTimeSeconds, "AUCTION_NOT_STARTED");
         // Ensure the auction has not expired. This will fail later in 0x but we can save gas by failing early
-        require(sellOrder.expirationTimeSeconds > auctionDetails.currentTime, "AUCTION_EXPIRED");
+        require(sellOrder.expirationTimeSeconds > auctionDetails.currentTimeSeconds, "AUCTION_EXPIRED");
         // Ensure the auction goes from high to low
-        require(auctionDetails.beginPrice > auctionDetails.endPrice, "INVALID_PRICE");
-        // Validate the buyer amount is greater than the current auction price
-        require(buyOrder.makerAssetAmount >= auctionDetails.currentPrice, "INVALID_PRICE");
+        require(auctionDetails.beginAmount > auctionDetails.endAmount, "INVALID_AMOUNT");
+        // Validate the buyer amount is greater than the current auction amount
+        require(buyOrder.makerAssetAmount >= auctionDetails.currentAmount, "INVALID_AMOUNT");
         // Match orders, maximally filling `buyOrder`
         matchedFillResults = EXCHANGE.matchOrders(
             buyOrder,
@@ -103,6 +83,7 @@ contract DutchAuction {
         // Return any spread to the seller
         uint256 leftMakerAssetSpreadAmount = matchedFillResults.leftMakerAssetSpreadAmount;
         if (leftMakerAssetSpreadAmount > 0) {
+            // Assume auction is for ERC20
             bytes memory assetData = sellOrder.takerAssetData;
             address token = assetData.readAddress(16);
             address makerAddress = sellOrder.makerAddress;
@@ -111,21 +92,6 @@ contract DutchAuction {
         return matchedFillResults;
     }
 
-    /// @dev Decodes the packed parameters into beginTime and beginPrice.
-    /// @param encodedParameters the encoded parameters
-    /// @return beginTime and beginPrice decoded
-    function decodeParameters(
-        uint256 encodedParameters
-    )
-        public
-        view
-        returns (uint256 beginTime, uint256 beginPrice)
-    {
-        beginTime = encodedParameters & 0x00000000000000000000000fffffffff;
-        beginPrice = encodedParameters>>32;
-        return (beginTime, beginPrice);
-    }
-
     /// @dev Calculates the Auction Details for the given order
     /// @param order The sell order
     /// @return AuctionDetails
@@ -135,28 +101,30 @@ contract DutchAuction {
         public
         returns (AuctionDetails memory auctionDetails)
     {
-        // solhint-disable-next-line indent
-        (uint256 auctionBeginTimeSeconds, uint256 auctionBeginPrice) = decodeParameters(order.salt);
-        require(order.expirationTimeSeconds > auctionBeginTimeSeconds, "INVALID_BEGIN_TIME");
+        uint256 makerAssetDataLength = order.makerAssetData.length;
+        // We assume auctionBeginTimeSeconds and auctionBeginAmount are appended to the makerAssetData
+        uint256 auctionBeginTimeSeconds = order.makerAssetData.readUint256(makerAssetDataLength-64);
+        uint256 auctionBeginAmount = order.makerAssetData.readUint256(makerAssetDataLength-32);
+        // require(order.expirationTimeSeconds > auctionBeginTimeSeconds, "INVALID_BEGIN_TIME");
         uint256 auctionDurationSeconds = order.expirationTimeSeconds-auctionBeginTimeSeconds;
-        uint256 minPrice = order.takerAssetAmount;
+        uint256 minAmount = order.takerAssetAmount;
         // solhint-disable-next-line not-rely-on-time
         uint256 timestamp = block.timestamp;
-        auctionDetails.beginTime = auctionBeginTimeSeconds;
-        auctionDetails.endTime = order.expirationTimeSeconds;
-        auctionDetails.beginPrice = auctionBeginPrice;
-        auctionDetails.endPrice = minPrice;
-        auctionDetails.currentTime = timestamp;
+        auctionDetails.beginTimeSeconds = auctionBeginTimeSeconds;
+        auctionDetails.endTimeSeconds = order.expirationTimeSeconds;
+        auctionDetails.beginAmount = auctionBeginAmount;
+        auctionDetails.endAmount = minAmount;
+        auctionDetails.currentTimeSeconds = timestamp;
 
         uint256 remainingDurationSeconds = order.expirationTimeSeconds-timestamp;
-        uint256 priceDelta = auctionBeginPrice-minPrice;
-        uint256 currentPrice = minPrice + (remainingDurationSeconds*priceDelta/auctionDurationSeconds);
-        // If the auction has not yet begun the current price is the auctionBeginPrice
-        currentPrice = timestamp < auctionBeginTimeSeconds ? auctionBeginPrice : currentPrice;
-        // If the auction has ended the current price is the minPrice
+        uint256 amountDelta = auctionBeginAmount-minAmount;
+        uint256 currentAmount = minAmount + (remainingDurationSeconds*amountDelta/auctionDurationSeconds);
+        // If the auction has not yet begun the current amount is the auctionBeginAmount
+        currentAmount = timestamp < auctionBeginTimeSeconds ? auctionBeginAmount : currentAmount;
+        // If the auction has ended the current amount is the minAmount
         // auction end time is guaranteed by 0x Exchange to fail due to the order expiration
-        currentPrice = timestamp >= order.expirationTimeSeconds ? minPrice : currentPrice;
-        auctionDetails.currentPrice = currentPrice;
+        currentAmount = timestamp >= order.expirationTimeSeconds ? minAmount : currentAmount;
+        auctionDetails.currentAmount = currentAmount;
         return auctionDetails;
     }
 }
diff --git a/packages/contracts/test/extensions/dutch_auction.ts b/packages/contracts/test/extensions/dutch_auction.ts
index 6a1e3ed45..4ad5cfa19 100644
--- a/packages/contracts/test/extensions/dutch_auction.ts
+++ b/packages/contracts/test/extensions/dutch_auction.ts
@@ -1,9 +1,11 @@
 import { BlockchainLifecycle } from '@0x/dev-utils';
-import { assetDataUtils } from '@0x/order-utils';
+import { assetDataUtils, generatePseudoRandomSalt } from '@0x/order-utils';
 import { SignedOrder } from '@0x/types';
 import { BigNumber } from '@0x/utils';
 import { Web3Wrapper } from '@0x/web3-wrapper';
 import * as chai from 'chai';
+import ethAbi = require('ethereumjs-abi');
+import * as ethUtil from 'ethereumjs-util';
 
 import { DummyERC20TokenContract } from '../../generated-wrappers/dummy_erc20_token';
 import { DummyERC721TokenContract } from '../../generated-wrappers/dummy_erc721_token';
@@ -26,6 +28,7 @@ chaiSetup.configure();
 const expect = chai.expect;
 const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 const DECIMALS_DEFAULT = 18;
+const ZERO = Web3Wrapper.toBaseUnitAmount(new BigNumber(0), DECIMALS_DEFAULT);
 
 describe.only(ContractName.DutchAuction, () => {
     let makerAddress: string;
@@ -34,13 +37,11 @@ describe.only(ContractName.DutchAuction, () => {
     let feeRecipientAddress: string;
     let defaultMakerAssetAddress: string;
 
-    let weth: DummyERC20TokenContract;
     let zrxToken: DummyERC20TokenContract;
     let erc20TokenA: DummyERC20TokenContract;
     let erc721Token: DummyERC721TokenContract;
     let dutchAuctionContract: DutchAuctionContract;
     let wethContract: WETH9Contract;
-    let exchangeWrapper: ExchangeWrapper;
 
     let sellerOrderFactory: OrderFactory;
     let buyerOrderFactory: OrderFactory;
@@ -48,11 +49,10 @@ describe.only(ContractName.DutchAuction, () => {
     let erc20Balances: ERC20BalancesByOwner;
     let tenMinutesInSeconds: number;
     let currentBlockTimestamp: number;
-    let auctionBeginTime: BigNumber;
-    let auctionEndTime: BigNumber;
-    let auctionBeginPrice: BigNumber;
-    let auctionEndPrice: BigNumber;
-    let encodedParams: BigNumber;
+    let auctionBeginTimeSeconds: BigNumber;
+    let auctionEndTimeSeconds: BigNumber;
+    let auctionBeginAmount: BigNumber;
+    let auctionEndAmount: BigNumber;
     let sellOrder: SignedOrder;
     let buyOrder: SignedOrder;
     let erc721MakerAssetIds: BigNumber[];
@@ -60,7 +60,7 @@ describe.only(ContractName.DutchAuction, () => {
         const timestampBefore = await getLatestBlockTimestampAsync();
         await web3Wrapper.increaseTimeAsync(5);
         const timestampAfter = await getLatestBlockTimestampAsync();
-        // HACK send some transactions
+        // HACK send some transactions when a time increase isn't supported
         if (timestampAfter === timestampBefore) {
             await web3Wrapper.sendTransactionAsync({ to: makerAddress, from: makerAddress, value: new BigNumber(1) });
             await web3Wrapper.sendTransactionAsync({ to: makerAddress, from: makerAddress, value: new BigNumber(1) });
@@ -70,6 +70,20 @@ describe.only(ContractName.DutchAuction, () => {
         }
     }
 
+    function extendMakerAssetData(makerAssetData: string, beginTimeSeconds: BigNumber, beginAmount: BigNumber): string {
+        return ethUtil.bufferToHex(
+            Buffer.concat([
+                ethUtil.toBuffer(makerAssetData),
+                ethUtil.toBuffer(
+                    (ethAbi as any).rawEncode(
+                        ['uint256', 'uint256'],
+                        [beginTimeSeconds.toString(), beginAmount.toString()],
+                    ),
+                ),
+            ]),
+        );
+    }
+
     before(async () => {
         await blockchainLifecycle.startAsync();
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
@@ -93,8 +107,7 @@ describe.only(ContractName.DutchAuction, () => {
         erc721MakerAssetIds = erc721Balances[makerAddress][erc721Token.address];
 
         wethContract = await WETH9Contract.deployFrom0xArtifactAsync(artifacts.WETH9, provider, txDefaults);
-        weth = new DummyERC20TokenContract(wethContract.abi, wethContract.address, provider);
-        erc20Wrapper.addDummyTokenContract(weth);
+        erc20Wrapper.addDummyTokenContract(wethContract as any);
 
         const zrxAssetData = assetDataUtils.encodeERC20AssetData(zrxToken.address);
         const exchangeInstance = await ExchangeContract.deployFrom0xArtifactAsync(
@@ -103,9 +116,8 @@ describe.only(ContractName.DutchAuction, () => {
             txDefaults,
             zrxAssetData,
         );
-        exchangeWrapper = new ExchangeWrapper(exchangeInstance, provider);
+        const exchangeWrapper = new ExchangeWrapper(exchangeInstance, provider);
         await exchangeWrapper.registerAssetProxyAsync(erc20Proxy.address, owner);
-
         await exchangeWrapper.registerAssetProxyAsync(erc721Proxy.address, owner);
 
         await erc20Proxy.addAuthorizedAddress.sendTransactionAsync(exchangeInstance.address, {
@@ -151,28 +163,30 @@ describe.only(ContractName.DutchAuction, () => {
         tenMinutesInSeconds = 10 * 60;
         currentBlockTimestamp = await getLatestBlockTimestampAsync();
         // Default auction begins 10 minutes ago
-        auctionBeginTime = new BigNumber(currentBlockTimestamp).minus(tenMinutesInSeconds);
+        auctionBeginTimeSeconds = new BigNumber(currentBlockTimestamp).minus(tenMinutesInSeconds);
         // Default auction ends 10 from now
-        auctionEndTime = new BigNumber(currentBlockTimestamp).plus(tenMinutesInSeconds);
-        auctionBeginPrice = Web3Wrapper.toBaseUnitAmount(new BigNumber(10), DECIMALS_DEFAULT);
-        auctionEndPrice = Web3Wrapper.toBaseUnitAmount(new BigNumber(1), DECIMALS_DEFAULT);
-        encodedParams = await dutchAuctionContract.encodeParameters.callAsync(auctionBeginTime, auctionBeginPrice);
-        const zero = Web3Wrapper.toBaseUnitAmount(new BigNumber(0), DECIMALS_DEFAULT);
+        auctionEndTimeSeconds = new BigNumber(currentBlockTimestamp).plus(tenMinutesInSeconds);
+        auctionBeginAmount = Web3Wrapper.toBaseUnitAmount(new BigNumber(10), DECIMALS_DEFAULT);
+        auctionEndAmount = Web3Wrapper.toBaseUnitAmount(new BigNumber(1), DECIMALS_DEFAULT);
 
         // Default sell order and buy order are exact mirrors
         const sellerDefaultOrderParams = {
-            salt: encodedParams, // Set the encoded params as the salt for the seller order
+            salt: generatePseudoRandomSalt(),
             exchangeAddress: exchangeInstance.address,
             makerAddress,
             feeRecipientAddress,
             senderAddress: dutchAuctionContract.address,
-            makerAssetData: assetDataUtils.encodeERC20AssetData(defaultMakerAssetAddress),
+            makerAssetData: extendMakerAssetData(
+                assetDataUtils.encodeERC20AssetData(defaultMakerAssetAddress),
+                auctionBeginTimeSeconds,
+                auctionBeginAmount,
+            ),
             takerAssetData: assetDataUtils.encodeERC20AssetData(defaultTakerAssetAddress),
             makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), DECIMALS_DEFAULT),
-            takerAssetAmount: auctionEndPrice,
-            expirationTimeSeconds: auctionEndTime,
-            makerFee: zero,
-            takerFee: zero,
+            takerAssetAmount: auctionEndAmount,
+            expirationTimeSeconds: auctionEndTimeSeconds,
+            makerFee: ZERO,
+            takerFee: ZERO,
         };
         // Default buy order is for the auction begin price
         const buyerDefaultOrderParams = {
@@ -180,12 +194,9 @@ describe.only(ContractName.DutchAuction, () => {
             makerAddress: takerAddress,
             makerAssetData: sellerDefaultOrderParams.takerAssetData,
             takerAssetData: sellerDefaultOrderParams.makerAssetData,
-            makerAssetAmount: auctionBeginPrice,
-            takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), DECIMALS_DEFAULT),
+            makerAssetAmount: auctionBeginAmount,
+            takerAssetAmount: sellerDefaultOrderParams.makerAssetAmount,
         };
-
-        encodedParams = await dutchAuctionContract.encodeParameters.callAsync(auctionBeginTime, auctionBeginPrice);
-
         const makerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
         const takerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(takerAddress)];
         sellerOrderFactory = new OrderFactory(makerPrivateKey, sellerDefaultOrderParams);
@@ -204,35 +215,33 @@ describe.only(ContractName.DutchAuction, () => {
         await blockchainLifecycle.revertAsync();
     });
     describe('matchOrders', () => {
-        it('should encode and decode parameters', async () => {
-            encodedParams = await dutchAuctionContract.encodeParameters.callAsync(auctionBeginTime, auctionBeginPrice);
-            const [decodedBegin, decodedBeginPrice] = await dutchAuctionContract.decodeParameters.callAsync(
-                encodedParams,
-            );
-            expect(decodedBegin).to.be.bignumber.equal(auctionBeginTime);
-            expect(decodedBeginPrice).to.be.bignumber.equal(auctionBeginPrice);
-        });
         it('should be worth the begin price at the begining of the auction', async () => {
-            auctionBeginTime = new BigNumber(currentBlockTimestamp + 2);
-            encodedParams = await dutchAuctionContract.encodeParameters.callAsync(auctionBeginTime, auctionBeginPrice);
+            auctionBeginTimeSeconds = new BigNumber(currentBlockTimestamp + 2);
             sellOrder = await sellerOrderFactory.newSignedOrderAsync({
-                salt: encodedParams,
+                makerAssetData: extendMakerAssetData(
+                    assetDataUtils.encodeERC20AssetData(defaultMakerAssetAddress),
+                    auctionBeginTimeSeconds,
+                    auctionBeginAmount,
+                ),
             });
             const auctionDetails = await dutchAuctionContract.getAuctionDetails.callAsync(sellOrder);
-            expect(auctionDetails.currentPrice).to.be.bignumber.equal(auctionBeginPrice);
-            expect(auctionDetails.beginPrice).to.be.bignumber.equal(auctionBeginPrice);
+            expect(auctionDetails.currentAmount).to.be.bignumber.equal(auctionBeginAmount);
+            expect(auctionDetails.beginAmount).to.be.bignumber.equal(auctionBeginAmount);
         });
         it('should be be worth the end price at the end of the auction', async () => {
-            auctionBeginTime = new BigNumber(currentBlockTimestamp - 1000);
-            auctionEndTime = new BigNumber(currentBlockTimestamp - 100);
-            encodedParams = await dutchAuctionContract.encodeParameters.callAsync(auctionBeginTime, auctionBeginPrice);
+            auctionBeginTimeSeconds = new BigNumber(currentBlockTimestamp - 1000);
+            auctionEndTimeSeconds = new BigNumber(currentBlockTimestamp - 100);
             sellOrder = await sellerOrderFactory.newSignedOrderAsync({
-                salt: encodedParams,
-                expirationTimeSeconds: auctionEndTime,
+                makerAssetData: extendMakerAssetData(
+                    assetDataUtils.encodeERC20AssetData(defaultMakerAssetAddress),
+                    auctionBeginTimeSeconds,
+                    auctionBeginAmount,
+                ),
+                expirationTimeSeconds: auctionEndTimeSeconds,
             });
             const auctionDetails = await dutchAuctionContract.getAuctionDetails.callAsync(sellOrder);
-            expect(auctionDetails.currentPrice).to.be.bignumber.equal(auctionEndPrice);
-            expect(auctionDetails.beginPrice).to.be.bignumber.equal(auctionBeginPrice);
+            expect(auctionDetails.currentAmount).to.be.bignumber.equal(auctionEndAmount);
+            expect(auctionDetails.beginAmount).to.be.bignumber.equal(auctionBeginAmount);
         });
         it('should match orders and send excess to seller', async () => {
             const txHash = await dutchAuctionContract.matchOrders.sendTransactionAsync(
@@ -246,23 +255,23 @@ describe.only(ContractName.DutchAuction, () => {
             );
             await web3Wrapper.awaitTransactionSuccessAsync(txHash);
             const newBalances = await erc20Wrapper.getBalancesAsync();
-            expect(newBalances[dutchAuctionContract.address][weth.address]).to.be.bignumber.equal(
+            expect(newBalances[dutchAuctionContract.address][wethContract.address]).to.be.bignumber.equal(
                 constants.ZERO_AMOUNT,
             );
-            expect(newBalances[makerAddress][weth.address]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][weth.address].plus(buyOrder.makerAssetAmount),
+            expect(newBalances[makerAddress][wethContract.address]).to.be.bignumber.equal(
+                erc20Balances[makerAddress][wethContract.address].plus(buyOrder.makerAssetAmount),
             );
         });
         it('should have valid getAuctionDetails at a block in the future', async () => {
             let auctionDetails = await dutchAuctionContract.getAuctionDetails.callAsync(sellOrder);
-            const beforePrice = auctionDetails.currentPrice;
+            const beforeAmount = auctionDetails.currentAmount;
             await increaseTimeAsync();
             auctionDetails = await dutchAuctionContract.getAuctionDetails.callAsync(sellOrder);
-            const currentPrice = auctionDetails.currentPrice;
-            expect(beforePrice).to.be.bignumber.greaterThan(currentPrice);
+            const currentAmount = auctionDetails.currentAmount;
+            expect(beforeAmount).to.be.bignumber.greaterThan(currentAmount);
 
             buyOrder = await buyerOrderFactory.newSignedOrderAsync({
-                makerAssetAmount: currentPrice,
+                makerAssetAmount: currentAmount,
             });
             const txHash = await dutchAuctionContract.matchOrders.sendTransactionAsync(
                 buyOrder,
@@ -275,16 +284,14 @@ describe.only(ContractName.DutchAuction, () => {
             );
             await web3Wrapper.awaitTransactionSuccessAsync(txHash);
             const newBalances = await erc20Wrapper.getBalancesAsync();
-            expect(newBalances[makerAddress][weth.address]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][weth.address].plus(currentPrice),
+            expect(newBalances[makerAddress][wethContract.address]).to.be.bignumber.equal(
+                erc20Balances[makerAddress][wethContract.address].plus(currentAmount),
             );
         });
         it('should revert when auction expires', async () => {
-            auctionEndTime = new BigNumber(currentBlockTimestamp - 100);
-            encodedParams = await dutchAuctionContract.encodeParameters.callAsync(auctionBeginTime, auctionBeginPrice);
+            auctionEndTimeSeconds = new BigNumber(currentBlockTimestamp - 100);
             sellOrder = await sellerOrderFactory.newSignedOrderAsync({
-                salt: encodedParams,
-                expirationTimeSeconds: auctionEndTime,
+                expirationTimeSeconds: auctionEndTimeSeconds,
             });
             return expectTransactionFailedAsync(
                 dutchAuctionContract.matchOrders.sendTransactionAsync(
@@ -314,7 +321,43 @@ describe.only(ContractName.DutchAuction, () => {
                         from: takerAddress,
                     },
                 ),
-                'INVALID_PRICE' as any,
+                'INVALID_AMOUNT' as any,
+            );
+        });
+        it('cannot match an expired auction', async () => {
+            auctionBeginTimeSeconds = new BigNumber(currentBlockTimestamp - 1000);
+            auctionEndTimeSeconds = new BigNumber(currentBlockTimestamp - 100);
+            sellOrder = await sellerOrderFactory.newSignedOrderAsync({
+                expirationTimeSeconds: auctionEndTimeSeconds,
+            });
+            return expectTransactionFailedAsync(
+                dutchAuctionContract.matchOrders.sendTransactionAsync(
+                    buyOrder,
+                    sellOrder,
+                    buyOrder.signature,
+                    sellOrder.signature,
+                    {
+                        from: takerAddress,
+                    },
+                ),
+                'AUCTION_EXPIRED' as any,
+            );
+        });
+        it('auction begin amount must be higher than final amount ', async () => {
+            sellOrder = await sellerOrderFactory.newSignedOrderAsync({
+                takerAssetAmount: auctionBeginAmount.plus(1),
+            });
+            return expectTransactionFailedAsync(
+                dutchAuctionContract.matchOrders.sendTransactionAsync(
+                    buyOrder,
+                    sellOrder,
+                    buyOrder.signature,
+                    sellOrder.signature,
+                    {
+                        from: takerAddress,
+                    },
+                ),
+                'INVALID_AMOUNT' as any,
             );
         });
         describe('ERC721', () => {
@@ -322,11 +365,15 @@ describe.only(ContractName.DutchAuction, () => {
                 const makerAssetId = erc721MakerAssetIds[0];
                 sellOrder = await sellerOrderFactory.newSignedOrderAsync({
                     makerAssetAmount: new BigNumber(1),
-                    makerAssetData: assetDataUtils.encodeERC721AssetData(erc721Token.address, makerAssetId),
+                    makerAssetData: extendMakerAssetData(
+                        assetDataUtils.encodeERC721AssetData(erc721Token.address, makerAssetId),
+                        auctionBeginTimeSeconds,
+                        auctionBeginAmount,
+                    ),
                 });
                 buyOrder = await buyerOrderFactory.newSignedOrderAsync({
                     takerAssetAmount: new BigNumber(1),
-                    takerAssetData: assetDataUtils.encodeERC721AssetData(erc721Token.address, makerAssetId),
+                    takerAssetData: sellOrder.makerAssetData,
                 });
                 const txHash = await dutchAuctionContract.matchOrders.sendTransactionAsync(
                     buyOrder,
@@ -339,8 +386,8 @@ describe.only(ContractName.DutchAuction, () => {
                 );
                 await web3Wrapper.awaitTransactionSuccessAsync(txHash);
                 const newBalances = await erc20Wrapper.getBalancesAsync();
-                expect(newBalances[makerAddress][weth.address]).to.be.bignumber.equal(
-                    erc20Balances[makerAddress][weth.address].plus(buyOrder.makerAssetAmount),
+                expect(newBalances[makerAddress][wethContract.address]).to.be.bignumber.equal(
+                    erc20Balances[makerAddress][wethContract.address].plus(buyOrder.makerAssetAmount),
                 );
                 const newOwner = await erc721Token.ownerOf.callAsync(makerAssetId);
                 expect(newOwner).to.be.bignumber.equal(takerAddress);