diff options
Diffstat (limited to 'packages/contracts')
15 files changed, 656 insertions, 656 deletions
diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/IExchange.sol b/packages/contracts/src/contracts/current/protocol/Exchange/IExchange.sol index 3af51e915..0550d6c4b 100644 --- a/packages/contracts/src/contracts/current/protocol/Exchange/IExchange.sol +++ b/packages/contracts/src/contracts/current/protocol/Exchange/IExchange.sol @@ -37,8 +37,8 @@ contract IExchange { address indexed feeRecipient, bytes makerAssetData, bytes takerAssetData, - uint256 makerTokenFilledAmount, - uint256 takerTokenFilledAmount, + uint256 makerAssetFilledAmount, + uint256 takerAssetFilledAmount, uint256 makerFeePaid, uint256 takerFeePaid, bytes32 indexed orderHash @@ -49,8 +49,8 @@ contract IExchange { address indexed feeRecipient, bytes makerAssetData, bytes takerAssetData, - uint256 makerTokenCancelledAmount, - uint256 takerTokenCancelledAmount, + uint256 makerAssetCancelledAmount, + uint256 takerAssetCancelledAmount, bytes32 indexed orderHash ); @@ -100,8 +100,8 @@ contract IExchange { returns (bool isError); /// @dev Calculates Keccak-256 hash of order with specified parameters. - /// @param orderAddresses Array of order's maker, taker, makerToken, takerToken, and feeRecipient. - /// @param orderValues Array of order's makerTokenAmount, takerTokenAmount, makerFee, takerFee, expirationTimestampInSec, and salt. + /// @param orderAddresses Array of order's maker, taker, makerAsset, takerAsset, and feeRecipient. + /// @param orderValues Array of order's makerAssetAmount, takerAssetAmount, makerFee, takerFee, expirationTimestampInSec, and salt. /// @return Keccak-256 hash of order. function getOrderHash(address[5] orderAddresses, uint256[6] orderValues) public view @@ -124,34 +124,34 @@ contract IExchange { returns (bool isValid); /// @dev Fills the input order. - /// @param orderAddresses Array of order's maker, taker, makerToken, takerToken, and feeRecipient. - /// @param orderValues Array of order's makerTokenAmount, takerTokenAmount, makerFee, takerFee, expirationTimestampInSec, and salt. - /// @param takerTokenFillAmount Desired amount of takerToken to fill. + /// @param orderAddresses Array of order's maker, taker, makerAsset, takerAsset, and feeRecipient. + /// @param orderValues Array of order's makerAssetAmount, takerAssetAmount, makerFee, takerFee, expirationTimestampInSec, and salt. + /// @param takerAssetFillAmount Desired amount of takerAsset to fill. /// @param v ECDSA signature parameter v. /// @param r ECDSA signature parameters r. /// @param s ECDSA signature parameters s. - /// @return Total amount of takerToken filled in trade. + /// @return Total amount of takerAsset filled in trade. function fillOrder( address[5] orderAddresses, uint256[6] orderValues, - uint256 takerTokenFillAmount, + uint256 takerAssetFillAmount, uint8 v, bytes32 r, bytes32 s) public - returns (uint256 takerTokenFilledAmount); + returns (uint256 takerAssetFilledAmount); /// @dev Cancels the input order. - /// @param orderAddresses Array of order's maker, taker, makerToken, takerToken, and feeRecipient. - /// @param orderValues Array of order's makerTokenAmount, takerTokenAmount, makerFee, takerFee, expirationTimestampInSec, and salt. - /// @param takerTokenCancelAmount Desired amount of takerToken to cancel in order. - /// @return Amount of takerToken cancelled. + /// @param orderAddresses Array of order's maker, taker, makerAsset, takerAsset, and feeRecipient. + /// @param orderValues Array of order's makerAssetAmount, takerAssetAmount, makerFee, takerFee, expirationTimestampInSec, and salt. + /// @param takerAssetCancelAmount Desired amount of takerAsset to cancel in order. + /// @return Amount of takerAsset cancelled. function cancelOrder( address[5] orderAddresses, uint256[6] orderValues, - uint256 takerTokenCancelAmount) + uint256 takerAssetCancelAmount) public - returns (uint256 takerTokenCancelledAmount); + returns (uint256 takerAssetCancelledAmount); /// @dev Cancels all orders for a specified maker up to a certain time. /// @param salt Orders created with a salt less or equal to this value will be cancelled. @@ -159,51 +159,51 @@ contract IExchange { external; /// @dev Fills an order with specified parameters and ECDSA signature. Throws if specified amount not filled entirely. - /// @param orderAddresses Array of order's maker, taker, makerToken, takerToken, and feeRecipient. - /// @param orderValues Array of order's makerTokenAmount, takerTokenAmount, makerFee, takerFee, expirationTimestampInSec, and salt. - /// @param takerTokenFillAmount Desired amount of takerToken to fill. + /// @param orderAddresses Array of order's maker, taker, makerAsset, takerAsset, and feeRecipient. + /// @param orderValues Array of order's makerAssetAmount, takerAssetAmount, makerFee, takerFee, expirationTimestampInSec, and salt. + /// @param takerAssetFillAmount Desired amount of takerAsset to fill. /// @param v ECDSA signature parameter v. /// @param r ECDSA signature parameters r. /// @param s ECDSA signature parameters s. function fillOrKillOrder( address[5] orderAddresses, uint256[6] orderValues, - uint256 takerTokenFillAmount, + uint256 takerAssetFillAmount, uint8 v, bytes32 r, bytes32 s) public; /// @dev Fills an order with specified parameters and ECDSA signature. Returns false if the transaction would otherwise revert. - /// @param orderAddresses Array of order's maker, taker, makerToken, takerToken, and feeRecipient. - /// @param orderValues Array of order's makerTokenAmount, takerTokenAmount, makerFee, takerFee, expirationTimestampInSec, and salt. - /// @param takerTokenFillAmount Desired amount of takerToken to fill. + /// @param orderAddresses Array of order's maker, taker, makerAsset, takerAsset, and feeRecipient. + /// @param orderValues Array of order's makerAssetAmount, takerAssetAmount, makerFee, takerFee, expirationTimestampInSec, and salt. + /// @param takerAssetFillAmount Desired amount of takerAsset to fill. /// @param v ECDSA signature parameter v. /// @param r ECDSA signature parameters r. /// @param s ECDSA signature parameters s. /// @return Success if the transaction did not revert. - /// @return Total amount of takerToken filled in trade. + /// @return Total amount of takerAsset filled in trade. function fillOrderNoThrow( address[5] orderAddresses, uint256[6] orderValues, - uint256 takerTokenFillAmount, + uint256 takerAssetFillAmount, uint8 v, bytes32 r, bytes32 s) public - returns (bool success, uint256 takerTokenFilledAmount); + returns (bool success, uint256 takerAssetFilledAmount); /// @dev Synchronously executes multiple calls of fillOrder in a single transaction. /// @param orderAddresses Array of address arrays containing individual order addresses. /// @param orderValues Array of uint256 arrays containing individual order values. - /// @param takerTokenFillAmounts Array of desired amounts of takerToken to fill in orders. + /// @param takerAssetFillAmounts Array of desired amounts of takerAsset to fill in orders. /// @param v Array ECDSA signature v parameters. /// @param r Array of ECDSA signature r parameters. /// @param s Array of ECDSA signature s parameters. function batchFillOrders( address[5][] orderAddresses, uint256[6][] orderValues, - uint256[] takerTokenFillAmounts, + uint256[] takerAssetFillAmounts, uint8[] v, bytes32[] r, bytes32[] s) @@ -212,14 +212,14 @@ contract IExchange { /// @dev Synchronously executes multiple calls of fillOrKill in a single transaction. /// @param orderAddresses Array of address arrays containing individual order addresses. /// @param orderValues Array of uint256 arrays containing individual order values. - /// @param takerTokenFillAmounts Array of desired amounts of takerToken to fill in orders. + /// @param takerAssetFillAmounts Array of desired amounts of takerAsset to fill in orders. /// @param v Array ECDSA signature v parameters. /// @param r Array of ECDSA signature r parameters. /// @param s Array of ECDSA signature s parameters. function batchFillOrKillOrders( address[5][] orderAddresses, uint256[6][] orderValues, - uint256[] takerTokenFillAmounts, + uint256[] takerAssetFillAmounts, uint8[] v, bytes32[] r, bytes32[] s) @@ -228,49 +228,49 @@ contract IExchange { /// @dev Synchronously executes multiple calls of fillOrderNoThrow in a single transaction. /// @param orderAddresses Array of address arrays containing individual order addresses. /// @param orderValues Array of uint256 arrays containing individual order values. - /// @param takerTokenFillAmounts Array of desired amounts of takerToken to fill in orders. + /// @param takerAssetFillAmounts Array of desired amounts of takerAsset to fill in orders. /// @param v Array ECDSA signature v parameters. /// @param r Array of ECDSA signature r parameters. /// @param s Array of ECDSA signature s parameters. function batchFillOrdersNoThrow( address[5][] orderAddresses, uint256[6][] orderValues, - uint256[] takerTokenFillAmounts, + uint256[] takerAssetFillAmounts, uint8[] v, bytes32[] r, bytes32[] s) external; - /// @dev Synchronously executes multiple fill orders in a single transaction until total takerTokenFillAmount filled. + /// @dev Synchronously executes multiple fill orders in a single transaction until total takerAssetFillAmount filled. /// @param orderAddresses Array of address arrays containing individual order addresses. /// @param orderValues Array of uint256 arrays containing individual order values. - /// @param takerTokenFillAmount Desired total amount of takerToken to fill in orders. + /// @param takerAssetFillAmount Desired total amount of takerAsset to fill in orders. /// @param v Array ECDSA signature v parameters. /// @param r Array of ECDSA signature r parameters. /// @param s Array of ECDSA signature s parameters. - /// @return Total amount of takerTokenFillAmount filled in orders. + /// @return Total amount of takerAssetFillAmount filled in orders. function marketFillOrders( address[5][] orderAddresses, uint256[6][] orderValues, - uint256 takerTokenFillAmount, + uint256 takerAssetFillAmount, uint8[] v, bytes32[] r, bytes32[] s) external returns (uint256 totalTakerTokenFilledAmount); - /// @dev Synchronously executes multiple calls of fillOrderNoThrow in a single transaction until total takerTokenFillAmount filled. + /// @dev Synchronously executes multiple calls of fillOrderNoThrow in a single transaction until total takerAssetFillAmount filled. /// @param orderAddresses Array of address arrays containing individual order addresses. /// @param orderValues Array of uint256 arrays containing individual order values. - /// @param takerTokenFillAmount Desired total amount of takerToken to fill in orders. + /// @param takerAssetFillAmount Desired total amount of takerAsset to fill in orders. /// @param v Array ECDSA signature v parameters. /// @param r Array of ECDSA signature r parameters. /// @param s Array of ECDSA signature s parameters. - /// @return Total amount of takerTokenFillAmount filled in orders. + /// @return Total amount of takerAssetFillAmount filled in orders. function marketFillOrdersNoThrow( address[5][] orderAddresses, uint256[6][] orderValues, - uint256 takerTokenFillAmount, + uint256 takerAssetFillAmount, uint8[] v, bytes32[] r, bytes32[] s) @@ -280,10 +280,10 @@ contract IExchange { /// @dev Synchronously cancels multiple orders in a single transaction. /// @param orderAddresses Array of address arrays containing individual order addresses. /// @param orderValues Array of uint256 arrays containing individual order values. - /// @param takerTokenCancelAmounts Array of desired amounts of takerToken to cancel in orders. + /// @param takerAssetCancelAmounts Array of desired amounts of takerAsset to cancel in orders. function batchCancelOrders( address[5][] orderAddresses, uint256[6][] orderValues, - uint256[] takerTokenCancelAmounts) + uint256[] takerAssetCancelAmounts) external; } diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/LibOrder.sol b/packages/contracts/src/contracts/current/protocol/Exchange/LibOrder.sol index d47a0fbbe..61a4a382d 100644 --- a/packages/contracts/src/contracts/current/protocol/Exchange/LibOrder.sol +++ b/packages/contracts/src/contracts/current/protocol/Exchange/LibOrder.sol @@ -26,8 +26,8 @@ contract LibOrder { "address makerAddress", "address takerAddress", "address feeRecipientAddress", - "uint256 makerTokenAmount", - "uint256 takerTokenAmount", + "uint256 makerAssetAmount", + "uint256 takerAssetAmount", "uint256 makerFee", "uint256 takerFee", "uint256 expirationTimeSeconds", @@ -40,8 +40,8 @@ contract LibOrder { address makerAddress; address takerAddress; address feeRecipientAddress; - uint256 makerTokenAmount; - uint256 takerTokenAmount; + uint256 makerAssetAmount; + uint256 takerAssetAmount; uint256 makerFee; uint256 takerFee; uint256 expirationTimeSeconds; @@ -66,8 +66,8 @@ contract LibOrder { order.makerAddress, order.takerAddress, order.feeRecipientAddress, - order.makerTokenAmount, - order.takerTokenAmount, + order.makerAssetAmount, + order.takerAssetAmount, order.makerFee, order.takerFee, order.expirationTimeSeconds, diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/MixinExchangeCore.sol b/packages/contracts/src/contracts/current/protocol/Exchange/MixinExchangeCore.sol index ec1bd57ce..10985d6d3 100644 --- a/packages/contracts/src/contracts/current/protocol/Exchange/MixinExchangeCore.sol +++ b/packages/contracts/src/contracts/current/protocol/Exchange/MixinExchangeCore.sol @@ -39,7 +39,7 @@ contract MixinExchangeCore is LibErrors, LibPartialAmount { - // Mapping of orderHash => amount of takerToken already bought by maker + // Mapping of orderHash => amount of takerAsset already bought by maker mapping (bytes32 => uint256) public filled; // Mapping of orderHash => cancelled @@ -55,8 +55,8 @@ contract MixinExchangeCore is address indexed feeRecipientAddress, bytes makerAssetData, bytes takerAssetData, - uint256 makerTokenFilledAmount, - uint256 takerTokenFilledAmount, + uint256 makerAssetFilledAmount, + uint256 takerAssetFilledAmount, uint256 makerFeePaid, uint256 takerFeePaid, bytes32 indexed orderHash @@ -81,12 +81,12 @@ contract MixinExchangeCore is /// @dev Fills the input order. /// @param order Order struct containing order specifications. - /// @param takerTokenFillAmount Desired amount of takerToken to sell. + /// @param takerAssetFillAmount Desired amount of takerAsset to sell. /// @param signature Proof that order has been created by maker. /// @return Amounts filled and fees paid by maker and taker. function fillOrder( Order memory order, - uint256 takerTokenFillAmount, + uint256 takerAssetFillAmount, bytes memory signature) public returns (FillResults memory fillResults) @@ -109,8 +109,8 @@ contract MixinExchangeCore is // Validate order and maker only if first time seen // TODO: Read filled and cancelled only once if (filled[orderHash] == 0) { - require(order.makerTokenAmount > 0); - require(order.takerTokenAmount > 0); + require(order.makerAssetAmount > 0); + require(order.takerAssetAmount > 0); require(isValidSignature(orderHash, order.makerAddress, signature)); } @@ -118,7 +118,7 @@ contract MixinExchangeCore is if (order.takerAddress != address(0)) { require(order.takerAddress == msg.sender); } - require(takerTokenFillAmount > 0); + require(takerAssetFillAmount > 0); // Validate order expiration if (block.timestamp >= order.expirationTimeSeconds) { @@ -127,26 +127,26 @@ contract MixinExchangeCore is } // Validate order availability - uint256 remainingTakerTokenFillAmount = safeSub(order.takerTokenAmount, filled[orderHash]); + uint256 remainingTakerTokenFillAmount = safeSub(order.takerAssetAmount, filled[orderHash]); if (remainingTakerTokenFillAmount == 0) { emit ExchangeError(uint8(Errors.ORDER_FULLY_FILLED), orderHash); return fillResults; } // Validate fill order rounding - fillResults.takerTokenFilledAmount = min256(takerTokenFillAmount, remainingTakerTokenFillAmount); - if (isRoundingError(fillResults.takerTokenFilledAmount, order.takerTokenAmount, order.makerTokenAmount)) { + fillResults.takerAssetFilledAmount = min256(takerAssetFillAmount, remainingTakerTokenFillAmount); + if (isRoundingError(fillResults.takerAssetFilledAmount, order.takerAssetAmount, order.makerAssetAmount)) { emit ExchangeError(uint8(Errors.ROUNDING_ERROR_TOO_LARGE), orderHash); - fillResults.takerTokenFilledAmount = 0; + fillResults.takerAssetFilledAmount = 0; return fillResults; } // Update state - filled[orderHash] = safeAdd(filled[orderHash], fillResults.takerTokenFilledAmount); + filled[orderHash] = safeAdd(filled[orderHash], fillResults.takerAssetFilledAmount); // Settle order - (fillResults.makerTokenFilledAmount, fillResults.makerFeePaid, fillResults.takerFeePaid) = - settleOrder(order, msg.sender, fillResults.takerTokenFilledAmount); + (fillResults.makerAssetFilledAmount, fillResults.makerFeePaid, fillResults.takerFeePaid) = + settleOrder(order, msg.sender, fillResults.takerAssetFilledAmount); // Log order emit Fill( @@ -155,8 +155,8 @@ contract MixinExchangeCore is order.feeRecipientAddress, order.makerAssetData, order.takerAssetData, - fillResults.makerTokenFilledAmount, - fillResults.takerTokenFilledAmount, + fillResults.makerAssetFilledAmount, + fillResults.takerAssetFilledAmount, fillResults.makerFeePaid, fillResults.takerFeePaid, orderHash @@ -176,8 +176,8 @@ contract MixinExchangeCore is bytes32 orderHash = getOrderHash(order); // Validate the order - require(order.makerTokenAmount > 0); - require(order.takerTokenAmount > 0); + require(order.makerAssetAmount > 0); + require(order.takerAssetAmount > 0); require(order.makerAddress == msg.sender); if (block.timestamp >= order.expirationTimeSeconds) { diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/MixinSettlementProxy.sol b/packages/contracts/src/contracts/current/protocol/Exchange/MixinSettlementProxy.sol index 718572d50..5fff2cd60 100644 --- a/packages/contracts/src/contracts/current/protocol/Exchange/MixinSettlementProxy.sol +++ b/packages/contracts/src/contracts/current/protocol/Exchange/MixinSettlementProxy.sol @@ -57,30 +57,30 @@ contract MixinSettlementProxy is function settleOrder( Order memory order, address takerAddress, - uint256 takerTokenFilledAmount) + uint256 takerAssetFilledAmount) internal returns ( - uint256 makerTokenFilledAmount, + uint256 makerAssetFilledAmount, uint256 makerFeePaid, uint256 takerFeePaid ) { - makerTokenFilledAmount = getPartialAmount(takerTokenFilledAmount, order.takerTokenAmount, order.makerTokenAmount); + makerAssetFilledAmount = getPartialAmount(takerAssetFilledAmount, order.takerAssetAmount, order.makerAssetAmount); ASSET_PROXY_DISPATCHER.transferFrom( order.makerAssetData, order.makerAddress, takerAddress, - makerTokenFilledAmount + makerAssetFilledAmount ); ASSET_PROXY_DISPATCHER.transferFrom( order.takerAssetData, takerAddress, order.makerAddress, - takerTokenFilledAmount + takerAssetFilledAmount ); if (order.feeRecipientAddress != address(0)) { if (order.makerFee > 0) { - makerFeePaid = getPartialAmount(takerTokenFilledAmount, order.takerTokenAmount, order.makerFee); + makerFeePaid = getPartialAmount(takerAssetFilledAmount, order.takerAssetAmount, order.makerFee); ASSET_PROXY_DISPATCHER.transferFrom( ZRX_PROXY_DATA, order.makerAddress, @@ -89,7 +89,7 @@ contract MixinSettlementProxy is ); } if (order.takerFee > 0) { - takerFeePaid = getPartialAmount(takerTokenFilledAmount, order.takerTokenAmount, order.takerFee); + takerFeePaid = getPartialAmount(takerAssetFilledAmount, order.takerAssetAmount, order.takerFee); ASSET_PROXY_DISPATCHER.transferFrom( ZRX_PROXY_DATA, takerAddress, @@ -98,6 +98,6 @@ contract MixinSettlementProxy is ); } } - return (makerTokenFilledAmount, makerFeePaid, takerFeePaid); + return (makerAssetFilledAmount, makerFeePaid, takerFeePaid); } } diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/MixinWrapperFunctions.sol b/packages/contracts/src/contracts/current/protocol/Exchange/MixinWrapperFunctions.sol index 027fcd87f..caa391aed 100644 --- a/packages/contracts/src/contracts/current/protocol/Exchange/MixinWrapperFunctions.sol +++ b/packages/contracts/src/contracts/current/protocol/Exchange/MixinWrapperFunctions.sol @@ -31,35 +31,35 @@ contract MixinWrapperFunctions is LibBytes, LibPartialAmount { - /// @dev Fills the input order. Reverts if exact takerTokenFillAmount not filled. + /// @dev Fills the input order. Reverts if exact takerAssetFillAmount not filled. /// @param order Order struct containing order specifications. - /// @param takerTokenFillAmount Desired amount of takerToken to sell. + /// @param takerAssetFillAmount Desired amount of takerAsset to sell. /// @param signature Proof that order has been created by maker. function fillOrKillOrder( Order memory order, - uint256 takerTokenFillAmount, + uint256 takerAssetFillAmount, bytes memory signature) public returns (FillResults memory fillResults) { fillResults = fillOrder( order, - takerTokenFillAmount, + takerAssetFillAmount, signature ); - require(fillResults.takerTokenFilledAmount == takerTokenFillAmount); + require(fillResults.takerAssetFilledAmount == takerAssetFillAmount); return fillResults; } /// @dev Fills an order with specified parameters and ECDSA signature. /// Returns false if the transaction would otherwise revert. /// @param order Order struct containing order specifications. - /// @param takerTokenFillAmount Desired amount of takerToken to sell. + /// @param takerAssetFillAmount Desired amount of takerAsset to sell. /// @param signature Proof that order has been created by maker. /// @return Amounts filled and fees paid by maker and taker. function fillOrderNoThrow( Order memory order, - uint256 takerTokenFillAmount, + uint256 takerAssetFillAmount, bytes memory signature) public returns (FillResults memory fillResults) @@ -73,14 +73,14 @@ contract MixinWrapperFunctions is // | Header | 0x00 | 4 | function selector | // | Params | | 3 * 32 | function parameters: | // | | 0x00 | | 1. offset to order (*) | - // | | 0x20 | | 2. takerTokenFillAmount | + // | | 0x20 | | 2. takerAssetFillAmount | // | | 0x40 | | 3. offset to signature (*) | // | Data | | 11 * 32 | order: | // | | 0x000 | | 1. makerAddress | // | | 0x020 | | 2. takerAddress | // | | 0x040 | | 3. feeRecipientAddress | - // | | 0x060 | | 4. makerTokenAmount | - // | | 0x080 | | 5. takerTokenAmount | + // | | 0x060 | | 4. makerAssetAmount | + // | | 0x080 | | 5. takerAssetAmount | // | | 0x0A0 | | 6. makerFeeAmount | // | | 0x0C0 | | 7. takerFeeAmount | // | | 0x0E0 | | 8. expirationTimeSeconds | @@ -150,8 +150,8 @@ contract MixinWrapperFunctions is mstore(dataAreaEnd, mload(sourceOffset)) // makerAddress mstore(add(dataAreaEnd, 0x20), mload(add(sourceOffset, 0x20))) // takerAddress mstore(add(dataAreaEnd, 0x40), mload(add(sourceOffset, 0x40))) // feeRecipientAddress - mstore(add(dataAreaEnd, 0x60), mload(add(sourceOffset, 0x60))) // makerTokenAmount - mstore(add(dataAreaEnd, 0x80), mload(add(sourceOffset, 0x80))) // takerTokenAmount + mstore(add(dataAreaEnd, 0x60), mload(add(sourceOffset, 0x60))) // makerAssetAmount + mstore(add(dataAreaEnd, 0x80), mload(add(sourceOffset, 0x80))) // takerAssetAmount mstore(add(dataAreaEnd, 0xA0), mload(add(sourceOffset, 0xA0))) // makerFeeAmount mstore(add(dataAreaEnd, 0xC0), mload(add(sourceOffset, 0xC0))) // takerFeeAmount mstore(add(dataAreaEnd, 0xE0), mload(add(sourceOffset, 0xE0))) // expirationTimeSeconds @@ -199,8 +199,8 @@ contract MixinWrapperFunctions is sourceOffset := add(sourceOffset, 0x20) } - /////// Write takerTokenFillAmount /////// - mstore(paramsAreaOffset, takerTokenFillAmount) + /////// Write takerAssetFillAmount /////// + mstore(paramsAreaOffset, takerAssetFillAmount) paramsAreaOffset := add(paramsAreaOffset, 0x20) /////// Write signature /////// @@ -252,18 +252,18 @@ contract MixinWrapperFunctions is /// @dev Synchronously executes multiple calls of fillOrder. /// @param orders Array of order specifications. - /// @param takerTokenFillAmounts Array of desired amounts of takerToken to sell in orders. + /// @param takerAssetFillAmounts Array of desired amounts of takerAsset to sell in orders. /// @param signatures Proofs that orders have been created by makers. function batchFillOrders( Order[] memory orders, - uint256[] memory takerTokenFillAmounts, + uint256[] memory takerAssetFillAmounts, bytes[] memory signatures) public { for (uint256 i = 0; i < orders.length; i++) { fillOrder( orders[i], - takerTokenFillAmounts[i], + takerAssetFillAmounts[i], signatures[i] ); } @@ -271,18 +271,18 @@ contract MixinWrapperFunctions is /// @dev Synchronously executes multiple calls of fillOrKill. /// @param orders Array of order specifications. - /// @param takerTokenFillAmounts Array of desired amounts of takerToken to sell in orders. + /// @param takerAssetFillAmounts Array of desired amounts of takerAsset to sell in orders. /// @param signatures Proofs that orders have been created by makers. function batchFillOrKillOrders( Order[] memory orders, - uint256[] memory takerTokenFillAmounts, + uint256[] memory takerAssetFillAmounts, bytes[] memory signatures) public { for (uint256 i = 0; i < orders.length; i++) { fillOrKillOrder( orders[i], - takerTokenFillAmounts[i], + takerAssetFillAmounts[i], signatures[i] ); } @@ -291,31 +291,31 @@ contract MixinWrapperFunctions is /// @dev Fills an order with specified parameters and ECDSA signature. /// Returns false if the transaction would otherwise revert. /// @param orders Array of order specifications. - /// @param takerTokenFillAmounts Array of desired amounts of takerToken to sell in orders. + /// @param takerAssetFillAmounts Array of desired amounts of takerAsset to sell in orders. /// @param signatures Proofs that orders have been created by makers. function batchFillOrdersNoThrow( Order[] memory orders, - uint256[] memory takerTokenFillAmounts, + uint256[] memory takerAssetFillAmounts, bytes[] memory signatures) public { for (uint256 i = 0; i < orders.length; i++) { fillOrderNoThrow( orders[i], - takerTokenFillAmounts[i], + takerAssetFillAmounts[i], signatures[i] ); } } - /// @dev Synchronously executes multiple calls of fillOrder until total amount of takerToken is sold by taker. + /// @dev Synchronously executes multiple calls of fillOrder until total amount of takerAsset is sold by taker. /// @param orders Array of order specifications. - /// @param takerTokenFillAmount Desired amount of takerToken to sell. + /// @param takerAssetFillAmount Desired amount of takerAsset to sell. /// @param signatures Proofs that orders have been created by makers. /// @return Amounts filled and fees paid by makers and taker. function marketSellOrders( Order[] memory orders, - uint256 takerTokenFillAmount, + uint256 takerAssetFillAmount, bytes[] memory signatures) public returns (FillResults memory totalFillResults) @@ -325,10 +325,10 @@ contract MixinWrapperFunctions is // Token being sold by taker must be the same for each order require(areBytesEqual(orders[i].takerAssetData, orders[0].takerAssetData)); - // Calculate the remaining amount of takerToken to sell - uint256 remainingTakerTokenFillAmount = safeSub(takerTokenFillAmount, totalFillResults.takerTokenFilledAmount); + // Calculate the remaining amount of takerAsset to sell + uint256 remainingTakerTokenFillAmount = safeSub(takerAssetFillAmount, totalFillResults.takerAssetFilledAmount); - // Attempt to sell the remaining amount of takerToken + // Attempt to sell the remaining amount of takerAsset FillResults memory singleFillResults = fillOrder( orders[i], remainingTakerTokenFillAmount, @@ -338,23 +338,23 @@ contract MixinWrapperFunctions is // Update amounts filled and fees paid by maker and taker addFillResults(totalFillResults, singleFillResults); - // Stop execution if the entire amount of takerToken has been sold - if (totalFillResults.takerTokenFilledAmount == takerTokenFillAmount) { + // Stop execution if the entire amount of takerAsset has been sold + if (totalFillResults.takerAssetFilledAmount == takerAssetFillAmount) { break; } } return totalFillResults; } - /// @dev Synchronously executes multiple calls of fillOrder until total amount of takerToken is sold by taker. + /// @dev Synchronously executes multiple calls of fillOrder until total amount of takerAsset is sold by taker. /// Returns false if the transaction would otherwise revert. /// @param orders Array of order specifications. - /// @param takerTokenFillAmount Desired amount of takerToken to sell. + /// @param takerAssetFillAmount Desired amount of takerAsset to sell. /// @param signatures Proofs that orders have been signed by makers. /// @return Amounts filled and fees paid by makers and taker. function marketSellOrdersNoThrow( Order[] memory orders, - uint256 takerTokenFillAmount, + uint256 takerAssetFillAmount, bytes[] memory signatures) public returns (FillResults memory totalFillResults) @@ -364,10 +364,10 @@ contract MixinWrapperFunctions is // Token being sold by taker must be the same for each order require(areBytesEqual(orders[i].takerAssetData, orders[0].takerAssetData)); - // Calculate the remaining amount of takerToken to sell - uint256 remainingTakerTokenFillAmount = safeSub(takerTokenFillAmount, totalFillResults.takerTokenFilledAmount); + // Calculate the remaining amount of takerAsset to sell + uint256 remainingTakerTokenFillAmount = safeSub(takerAssetFillAmount, totalFillResults.takerAssetFilledAmount); - // Attempt to sell the remaining amount of takerToken + // Attempt to sell the remaining amount of takerAsset FillResults memory singleFillResults = fillOrderNoThrow( orders[i], remainingTakerTokenFillAmount, @@ -377,22 +377,22 @@ contract MixinWrapperFunctions is // Update amounts filled and fees paid by maker and taker addFillResults(totalFillResults, singleFillResults); - // Stop execution if the entire amount of takerToken has been sold - if (totalFillResults.takerTokenFilledAmount == takerTokenFillAmount) { + // Stop execution if the entire amount of takerAsset has been sold + if (totalFillResults.takerAssetFilledAmount == takerAssetFillAmount) { break; } } return totalFillResults; } - /// @dev Synchronously executes multiple calls of fillOrder until total amount of makerToken is bought by taker. + /// @dev Synchronously executes multiple calls of fillOrder until total amount of makerAsset is bought by taker. /// @param orders Array of order specifications. - /// @param makerTokenFillAmount Desired amount of makerToken to buy. + /// @param makerAssetFillAmount Desired amount of makerAsset to buy. /// @param signatures Proofs that orders have been signed by makers. /// @return Amounts filled and fees paid by makers and taker. function marketBuyOrders( Order[] memory orders, - uint256 makerTokenFillAmount, + uint256 makerAssetFillAmount, bytes[] memory signatures) public returns (FillResults memory totalFillResults) @@ -402,18 +402,18 @@ contract MixinWrapperFunctions is // Token being bought by taker must be the same for each order require(areBytesEqual(orders[i].makerAssetData, orders[0].makerAssetData)); - // Calculate the remaining amount of makerToken to buy - uint256 remainingMakerTokenFillAmount = safeSub(makerTokenFillAmount, totalFillResults.makerTokenFilledAmount); + // Calculate the remaining amount of makerAsset to buy + uint256 remainingMakerTokenFillAmount = safeSub(makerAssetFillAmount, totalFillResults.makerAssetFilledAmount); - // Convert the remaining amount of makerToken to buy into remaining amount - // of takerToken to sell, assuming entire amount can be sold in the current order + // Convert the remaining amount of makerAsset to buy into remaining amount + // of takerAsset to sell, assuming entire amount can be sold in the current order uint256 remainingTakerTokenFillAmount = getPartialAmount( - orders[i].takerTokenAmount, - orders[i].makerTokenAmount, + orders[i].takerAssetAmount, + orders[i].makerAssetAmount, remainingMakerTokenFillAmount ); - // Attempt to sell the remaining amount of takerToken + // Attempt to sell the remaining amount of takerAsset FillResults memory singleFillResults = fillOrder( orders[i], remainingTakerTokenFillAmount, @@ -423,8 +423,8 @@ contract MixinWrapperFunctions is // Update amounts filled and fees paid by maker and taker addFillResults(totalFillResults, singleFillResults); - // Stop execution if the entire amount of makerToken has been bought - if (totalFillResults.makerTokenFilledAmount == makerTokenFillAmount) { + // Stop execution if the entire amount of makerAsset has been bought + if (totalFillResults.makerAssetFilledAmount == makerAssetFillAmount) { break; } } @@ -434,12 +434,12 @@ contract MixinWrapperFunctions is /// @dev Synchronously executes multiple fill orders in a single transaction until total amount is bought by taker. /// Returns false if the transaction would otherwise revert. /// @param orders Array of order specifications. - /// @param makerTokenFillAmount Desired amount of makerToken to buy. + /// @param makerAssetFillAmount Desired amount of makerAsset to buy. /// @param signatures Proofs that orders have been signed by makers. /// @return Amounts filled and fees paid by makers and taker. function marketBuyOrdersNoThrow( Order[] memory orders, - uint256 makerTokenFillAmount, + uint256 makerAssetFillAmount, bytes[] memory signatures) public returns (FillResults memory totalFillResults) @@ -449,18 +449,18 @@ contract MixinWrapperFunctions is // Token being bought by taker must be the same for each order require(areBytesEqual(orders[i].makerAssetData, orders[0].makerAssetData)); - // Calculate the remaining amount of makerToken to buy - uint256 remainingMakerTokenFillAmount = safeSub(makerTokenFillAmount, totalFillResults.makerTokenFilledAmount); + // Calculate the remaining amount of makerAsset to buy + uint256 remainingMakerTokenFillAmount = safeSub(makerAssetFillAmount, totalFillResults.makerAssetFilledAmount); - // Convert the remaining amount of makerToken to buy into remaining amount - // of takerToken to sell, assuming entire amount can be sold in the current order + // Convert the remaining amount of makerAsset to buy into remaining amount + // of takerAsset to sell, assuming entire amount can be sold in the current order uint256 remainingTakerTokenFillAmount = getPartialAmount( - orders[i].takerTokenAmount, - orders[i].makerTokenAmount, + orders[i].takerAssetAmount, + orders[i].makerAssetAmount, remainingMakerTokenFillAmount ); - // Attempt to sell the remaining amount of takerToken + // Attempt to sell the remaining amount of takerAsset FillResults memory singleFillResults = fillOrderNoThrow( orders[i], remainingTakerTokenFillAmount, @@ -470,8 +470,8 @@ contract MixinWrapperFunctions is // Update amounts filled and fees paid by maker and taker addFillResults(totalFillResults, singleFillResults); - // Stop execution if the entire amount of makerToken has been bought - if (totalFillResults.makerTokenFilledAmount == makerTokenFillAmount) { + // Stop execution if the entire amount of makerAsset has been bought + if (totalFillResults.makerAssetFilledAmount == makerAssetFillAmount) { break; } } @@ -496,8 +496,8 @@ contract MixinWrapperFunctions is internal pure { - totalFillResults.makerTokenFilledAmount = safeAdd(totalFillResults.makerTokenFilledAmount, singleFillResults.makerTokenFilledAmount); - totalFillResults.takerTokenFilledAmount = safeAdd(totalFillResults.takerTokenFilledAmount, singleFillResults.takerTokenFilledAmount); + totalFillResults.makerAssetFilledAmount = safeAdd(totalFillResults.makerAssetFilledAmount, singleFillResults.makerAssetFilledAmount); + totalFillResults.takerAssetFilledAmount = safeAdd(totalFillResults.takerAssetFilledAmount, singleFillResults.takerAssetFilledAmount); totalFillResults.makerFeePaid = safeAdd(totalFillResults.makerFeePaid, singleFillResults.makerFeePaid); totalFillResults.takerFeePaid = safeAdd(totalFillResults.takerFeePaid, singleFillResults.takerFeePaid); } diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MExchangeCore.sol b/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MExchangeCore.sol index d2ec4da04..9a7f80109 100644 --- a/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MExchangeCore.sol +++ b/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MExchangeCore.sol @@ -24,15 +24,15 @@ import "../LibOrder.sol"; contract MExchangeCore is LibOrder { struct FillResults { - uint256 makerTokenFilledAmount; - uint256 takerTokenFilledAmount; + uint256 makerAssetFilledAmount; + uint256 takerAssetFilledAmount; uint256 makerFeePaid; uint256 takerFeePaid; } function fillOrder( Order memory order, - uint256 takerTokenFillAmount, + uint256 takerAssetFillAmount, bytes memory signature) public returns (FillResults memory fillResults); diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MSettlement.sol b/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MSettlement.sol index a9911c8ce..172138f2d 100644 --- a/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MSettlement.sol +++ b/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MSettlement.sol @@ -26,10 +26,10 @@ contract MSettlement is LibOrder { function settleOrder( Order memory order, address takerAddress, - uint256 takerTokenFilledAmount) + uint256 takerAssetFilledAmount) internal returns ( - uint256 makerTokenFilledAmount, + uint256 makerAssetFilledAmount, uint256 makerFeePaid, uint256 takerFeePaid ); diff --git a/packages/contracts/src/utils/exchange_wrapper.ts b/packages/contracts/src/utils/exchange_wrapper.ts index cda012aa9..927513fe3 100644 --- a/packages/contracts/src/utils/exchange_wrapper.ts +++ b/packages/contracts/src/utils/exchange_wrapper.ts @@ -22,12 +22,12 @@ export class ExchangeWrapper { public async fillOrderAsync( signedOrder: SignedOrder, from: string, - opts: { takerTokenFillAmount?: BigNumber } = {}, + opts: { takerAssetFillAmount?: BigNumber } = {}, ): Promise<TransactionReceiptWithDecodedLogs> { - const params = orderUtils.createFill(signedOrder, opts.takerTokenFillAmount); + const params = orderUtils.createFill(signedOrder, opts.takerAssetFillAmount); const txHash = await this._exchange.fillOrder.sendTransactionAsync( params.order, - params.takerTokenFillAmount, + params.takerAssetFillAmount, params.signature, { from }, ); @@ -43,12 +43,12 @@ export class ExchangeWrapper { public async fillOrKillOrderAsync( signedOrder: SignedOrder, from: string, - opts: { takerTokenFillAmount?: BigNumber } = {}, + opts: { takerAssetFillAmount?: BigNumber } = {}, ): Promise<TransactionReceiptWithDecodedLogs> { - const params = orderUtils.createFill(signedOrder, opts.takerTokenFillAmount); + const params = orderUtils.createFill(signedOrder, opts.takerAssetFillAmount); const txHash = await this._exchange.fillOrKillOrder.sendTransactionAsync( params.order, - params.takerTokenFillAmount, + params.takerAssetFillAmount, params.signature, { from }, ); @@ -58,12 +58,12 @@ export class ExchangeWrapper { public async fillOrderNoThrowAsync( signedOrder: SignedOrder, from: string, - opts: { takerTokenFillAmount?: BigNumber } = {}, + opts: { takerAssetFillAmount?: BigNumber } = {}, ): Promise<TransactionReceiptWithDecodedLogs> { - const params = orderUtils.createFill(signedOrder, opts.takerTokenFillAmount); + const params = orderUtils.createFill(signedOrder, opts.takerAssetFillAmount); const txHash = await this._exchange.fillOrderNoThrow.sendTransactionAsync( params.order, - params.takerTokenFillAmount, + params.takerAssetFillAmount, params.signature, { from }, ); @@ -73,12 +73,12 @@ export class ExchangeWrapper { public async batchFillOrdersAsync( orders: SignedOrder[], from: string, - opts: { takerTokenFillAmounts?: BigNumber[] } = {}, + opts: { takerAssetFillAmounts?: BigNumber[] } = {}, ): Promise<TransactionReceiptWithDecodedLogs> { - const params = formatters.createBatchFill(orders, opts.takerTokenFillAmounts); + const params = formatters.createBatchFill(orders, opts.takerAssetFillAmounts); const txHash = await this._exchange.batchFillOrders.sendTransactionAsync( params.orders, - params.takerTokenFillAmounts, + params.takerAssetFillAmounts, params.signatures, { from }, ); @@ -88,12 +88,12 @@ export class ExchangeWrapper { public async batchFillOrKillOrdersAsync( orders: SignedOrder[], from: string, - opts: { takerTokenFillAmounts?: BigNumber[] } = {}, + opts: { takerAssetFillAmounts?: BigNumber[] } = {}, ): Promise<TransactionReceiptWithDecodedLogs> { - const params = formatters.createBatchFill(orders, opts.takerTokenFillAmounts); + const params = formatters.createBatchFill(orders, opts.takerAssetFillAmounts); const txHash = await this._exchange.batchFillOrKillOrders.sendTransactionAsync( params.orders, - params.takerTokenFillAmounts, + params.takerAssetFillAmounts, params.signatures, { from }, ); @@ -103,12 +103,12 @@ export class ExchangeWrapper { public async batchFillOrdersNoThrowAsync( orders: SignedOrder[], from: string, - opts: { takerTokenFillAmounts?: BigNumber[] } = {}, + opts: { takerAssetFillAmounts?: BigNumber[] } = {}, ): Promise<TransactionReceiptWithDecodedLogs> { - const params = formatters.createBatchFill(orders, opts.takerTokenFillAmounts); + const params = formatters.createBatchFill(orders, opts.takerAssetFillAmounts); const txHash = await this._exchange.batchFillOrdersNoThrow.sendTransactionAsync( params.orders, - params.takerTokenFillAmounts, + params.takerAssetFillAmounts, params.signatures, { from }, ); @@ -118,12 +118,12 @@ export class ExchangeWrapper { public async marketSellOrdersAsync( orders: SignedOrder[], from: string, - opts: { takerTokenFillAmount: BigNumber }, + opts: { takerAssetFillAmount: BigNumber }, ): Promise<TransactionReceiptWithDecodedLogs> { - const params = formatters.createMarketSellOrders(orders, opts.takerTokenFillAmount); + const params = formatters.createMarketSellOrders(orders, opts.takerAssetFillAmount); const txHash = await this._exchange.marketSellOrders.sendTransactionAsync( params.orders, - params.takerTokenFillAmount, + params.takerAssetFillAmount, params.signatures, { from }, ); @@ -133,12 +133,12 @@ export class ExchangeWrapper { public async marketSellOrdersNoThrowAsync( orders: SignedOrder[], from: string, - opts: { takerTokenFillAmount: BigNumber }, + opts: { takerAssetFillAmount: BigNumber }, ): Promise<TransactionReceiptWithDecodedLogs> { - const params = formatters.createMarketSellOrders(orders, opts.takerTokenFillAmount); + const params = formatters.createMarketSellOrders(orders, opts.takerAssetFillAmount); const txHash = await this._exchange.marketSellOrdersNoThrow.sendTransactionAsync( params.orders, - params.takerTokenFillAmount, + params.takerAssetFillAmount, params.signatures, { from }, ); @@ -148,12 +148,12 @@ export class ExchangeWrapper { public async marketBuyOrdersAsync( orders: SignedOrder[], from: string, - opts: { makerTokenFillAmount: BigNumber }, + opts: { makerAssetFillAmount: BigNumber }, ): Promise<TransactionReceiptWithDecodedLogs> { - const params = formatters.createMarketBuyOrders(orders, opts.makerTokenFillAmount); + const params = formatters.createMarketBuyOrders(orders, opts.makerAssetFillAmount); const txHash = await this._exchange.marketBuyOrders.sendTransactionAsync( params.orders, - params.makerTokenFillAmount, + params.makerAssetFillAmount, params.signatures, { from }, ); @@ -163,12 +163,12 @@ export class ExchangeWrapper { public async marketBuyOrdersNoThrowAsync( orders: SignedOrder[], from: string, - opts: { makerTokenFillAmount: BigNumber }, + opts: { makerAssetFillAmount: BigNumber }, ): Promise<TransactionReceiptWithDecodedLogs> { - const params = formatters.createMarketBuyOrders(orders, opts.makerTokenFillAmount); + const params = formatters.createMarketBuyOrders(orders, opts.makerAssetFillAmount); const txHash = await this._exchange.marketBuyOrdersNoThrow.sendTransactionAsync( params.orders, - params.makerTokenFillAmount, + params.makerAssetFillAmount, params.signatures, { from }, ); diff --git a/packages/contracts/src/utils/formatters.ts b/packages/contracts/src/utils/formatters.ts index fce10c448..e706c15b5 100644 --- a/packages/contracts/src/utils/formatters.ts +++ b/packages/contracts/src/utils/formatters.ts @@ -5,27 +5,27 @@ import { orderUtils } from './order_utils'; import { BatchCancelOrders, BatchFillOrders, MarketBuyOrders, MarketSellOrders, SignedOrder } from './types'; export const formatters = { - createBatchFill(signedOrders: SignedOrder[], takerTokenFillAmounts: BigNumber[] = []) { + createBatchFill(signedOrders: SignedOrder[], takerAssetFillAmounts: BigNumber[] = []) { const batchFill: BatchFillOrders = { orders: [], signatures: [], - takerTokenFillAmounts, + takerAssetFillAmounts, }; _.forEach(signedOrders, signedOrder => { const orderStruct = orderUtils.getOrderStruct(signedOrder); batchFill.orders.push(orderStruct); batchFill.signatures.push(signedOrder.signature); - if (takerTokenFillAmounts.length < signedOrders.length) { - batchFill.takerTokenFillAmounts.push(signedOrder.takerTokenAmount); + if (takerAssetFillAmounts.length < signedOrders.length) { + batchFill.takerAssetFillAmounts.push(signedOrder.takerAssetAmount); } }); return batchFill; }, - createMarketSellOrders(signedOrders: SignedOrder[], takerTokenFillAmount: BigNumber) { + createMarketSellOrders(signedOrders: SignedOrder[], takerAssetFillAmount: BigNumber) { const marketSellOrders: MarketSellOrders = { orders: [], signatures: [], - takerTokenFillAmount, + takerAssetFillAmount, }; _.forEach(signedOrders, signedOrder => { const orderStruct = orderUtils.getOrderStruct(signedOrder); @@ -34,11 +34,11 @@ export const formatters = { }); return marketSellOrders; }, - createMarketBuyOrders(signedOrders: SignedOrder[], makerTokenFillAmount: BigNumber) { + createMarketBuyOrders(signedOrders: SignedOrder[], makerAssetFillAmount: BigNumber) { const marketBuyOrders: MarketBuyOrders = { orders: [], signatures: [], - makerTokenFillAmount, + makerAssetFillAmount, }; _.forEach(signedOrders, signedOrder => { const orderStruct = orderUtils.getOrderStruct(signedOrder); diff --git a/packages/contracts/src/utils/order_utils.ts b/packages/contracts/src/utils/order_utils.ts index 18892b4d4..52eb44941 100644 --- a/packages/contracts/src/utils/order_utils.ts +++ b/packages/contracts/src/utils/order_utils.ts @@ -7,18 +7,18 @@ import { crypto } from './crypto'; import { OrderStruct, SignatureType, SignedOrder, UnsignedOrder } from './types'; export const orderUtils = { - createFill: (signedOrder: SignedOrder, takerTokenFillAmount?: BigNumber) => { + createFill: (signedOrder: SignedOrder, takerAssetFillAmount?: BigNumber) => { const fill = { order: orderUtils.getOrderStruct(signedOrder), - takerTokenFillAmount: takerTokenFillAmount || signedOrder.takerTokenAmount, + takerAssetFillAmount: takerAssetFillAmount || signedOrder.takerAssetAmount, signature: signedOrder.signature, }; return fill; }, - createCancel(signedOrder: SignedOrder, takerTokenCancelAmount?: BigNumber) { + createCancel(signedOrder: SignedOrder, takerAssetCancelAmount?: BigNumber) { const cancel = { order: orderUtils.getOrderStruct(signedOrder), - takerTokenCancelAmount: takerTokenCancelAmount || signedOrder.takerTokenAmount, + takerAssetCancelAmount: takerAssetCancelAmount || signedOrder.takerAssetAmount, }; return cancel; }, @@ -27,8 +27,8 @@ export const orderUtils = { makerAddress: signedOrder.makerAddress, takerAddress: signedOrder.takerAddress, feeRecipientAddress: signedOrder.feeRecipientAddress, - makerTokenAmount: signedOrder.makerTokenAmount, - takerTokenAmount: signedOrder.takerTokenAmount, + makerAssetAmount: signedOrder.makerAssetAmount, + takerAssetAmount: signedOrder.takerAssetAmount, makerFee: signedOrder.makerFee, takerFee: signedOrder.takerFee, expirationTimeSeconds: signedOrder.expirationTimeSeconds, @@ -44,8 +44,8 @@ export const orderUtils = { 'address makerAddress', 'address takerAddress', 'address feeRecipientAddress', - 'uint256 makerTokenAmount', - 'uint256 takerTokenAmount', + 'uint256 makerAssetAmount', + 'uint256 takerAssetAmount', 'uint256 makerFee', 'uint256 takerFee', 'uint256 expirationTimeSeconds', @@ -58,8 +58,8 @@ export const orderUtils = { order.makerAddress, order.takerAddress, order.feeRecipientAddress, - order.makerTokenAmount, - order.takerTokenAmount, + order.makerAssetAmount, + order.takerAssetAmount, order.makerFee, order.takerFee, order.expirationTimeSeconds, diff --git a/packages/contracts/src/utils/types.ts b/packages/contracts/src/utils/types.ts index 69792b846..8bc9641fc 100644 --- a/packages/contracts/src/utils/types.ts +++ b/packages/contracts/src/utils/types.ts @@ -14,19 +14,19 @@ export interface SubmissionContractEventArgs { export interface BatchFillOrders { orders: OrderStruct[]; signatures: string[]; - takerTokenFillAmounts: BigNumber[]; + takerAssetFillAmounts: BigNumber[]; } export interface MarketSellOrders { orders: OrderStruct[]; signatures: string[]; - takerTokenFillAmount: BigNumber; + takerAssetFillAmount: BigNumber; } export interface MarketBuyOrders { orders: OrderStruct[]; signatures: string[]; - makerTokenFillAmount: BigNumber; + makerAssetFillAmount: BigNumber; } export interface BatchCancelOrders { @@ -47,10 +47,10 @@ export interface DefaultOrderParams { exchangeAddress: string; makerAddress: string; feeRecipientAddress: string; - makerTokenAddress: string; - takerTokenAddress: string; - makerTokenAmount: BigNumber; - takerTokenAmount: BigNumber; + makerAssetAddress: string; + takerAssetAddress: string; + makerAssetAmount: BigNumber; + takerAssetAmount: BigNumber; makerFee: BigNumber; takerFee: BigNumber; makerAssetData: string; @@ -137,8 +137,8 @@ export interface OrderStruct { makerAddress: string; takerAddress: string; feeRecipientAddress: string; - makerTokenAmount: BigNumber; - takerTokenAmount: BigNumber; + makerAssetAmount: BigNumber; + takerAssetAmount: BigNumber; makerFee: BigNumber; takerFee: BigNumber; expirationTimeSeconds: BigNumber; diff --git a/packages/contracts/test/asset_proxy_dispatcher/proxies.ts b/packages/contracts/test/asset_proxy_dispatcher/proxies.ts index 8b4f3faed..2b0d80338 100644 --- a/packages/contracts/test/asset_proxy_dispatcher/proxies.ts +++ b/packages/contracts/test/asset_proxy_dispatcher/proxies.ts @@ -34,7 +34,7 @@ describe('Asset Transfer Proxies', () => { let dmyBalances: Balances; let erc20Proxy: ERC20ProxyContract; let erc721Proxy: ERC721ProxyContract; - const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010'); + const makerAssetId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010'); const testAddressPaddedWithZeros = '0x0000000000000000056000000000000000000010'; const INITIAL_BALANCE = new BigNumber(10000); @@ -82,7 +82,7 @@ describe('Asset Transfer Proxies', () => { await erc721Token.setApprovalForAll.sendTransactionAsync(erc721Proxy.address, true, { from: takerAddress, }); - await erc721Token.mint.sendTransactionAsync(makerAddress, makerTokenId, { from: tokenOwner }); + await erc721Token.mint.sendTransactionAsync(makerAddress, makerAssetId, { from: tokenOwner }); }); beforeEach(async () => { await blockchainLifecycle.startAsync(); @@ -170,9 +170,9 @@ describe('Asset Transfer Proxies', () => { describe('Transfer Proxy - ERC721', () => { it('should successfully transfer tokens', async () => { // Construct metadata for ERC721 proxy - const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId); + const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId); // Verify pre-condition - const ownerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId); + const ownerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId); expect(ownerMakerToken).to.be.bignumber.equal(makerAddress); // Perform a transfer from makerAddress to takerAddress const balances = await dmyBalances.getAsync(); @@ -185,15 +185,15 @@ describe('Asset Transfer Proxies', () => { { from: assetProxyDispatcherAddress }, ); // Verify transfer was successful - const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId); + const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId); expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress); }); it('should throw if transferring 0 amount of a token', async () => { // Construct metadata for ERC721 proxy - const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId); + const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId); // Verify pre-condition - const ownerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId); + const ownerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId); expect(ownerMakerToken).to.be.bignumber.equal(makerAddress); // Perform a transfer from makerAddress to takerAddress const balances = await dmyBalances.getAsync(); @@ -211,9 +211,9 @@ describe('Asset Transfer Proxies', () => { it('should throw if transferring > 1 amount of a token', async () => { // Construct metadata for ERC721 proxy - const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId); + const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId); // Verify pre-condition - const ownerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId); + const ownerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId); expect(ownerMakerToken).to.be.bignumber.equal(makerAddress); // Perform a transfer from makerAddress to takerAddress const balances = await dmyBalances.getAsync(); @@ -231,7 +231,7 @@ describe('Asset Transfer Proxies', () => { it('should throw if allowances are too low', async () => { // Construct metadata for ERC721 proxy - const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId); + const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId); // Remove transfer approval for makerAddress. await erc721Token.setApprovalForAll.sendTransactionAsync(erc721Proxy.address, false, { from: makerAddress, @@ -247,7 +247,7 @@ describe('Asset Transfer Proxies', () => { it('should throw if requesting address is not authorized', async () => { // Construct metadata for ERC721 proxy - const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId); + const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId); // Perform a transfer from makerAddress to takerAddress const amount = new BigNumber(1); return expect( 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<FillContractEventArgs>; - 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<FillContractEventArgs>; 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<FillContractEventArgs>; 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); |