crowetic/protocol
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename token => asset

Browse Source
This commit is contained in:
Amir Bandeali
2018-04-21 16:55:03 -07:00
parent 63abf34664
commit 3335fc7baf
15 changed files with 656 additions and 656 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
packages/contracts/src/contracts/current/protocol/Exchange/IExchange.sol
View File

@@ -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;
}

12
packages/contracts/src/contracts/current/protocol/Exchange/LibOrder.sol
View File

@@ -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,

38
packages/contracts/src/contracts/current/protocol/Exchange/MixinExchangeCore.sol
View File

@@ -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) {

16
packages/contracts/src/contracts/current/protocol/Exchange/MixinSettlementProxy.sol
View File

@@ -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);
}
}

128
packages/contracts/src/contracts/current/protocol/Exchange/MixinWrapperFunctions.sol
View File

@@ -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);
}

6
packages/contracts/src/contracts/current/protocol/Exchange/mixins/MExchangeCore.sol
View File

@@ -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);

4
packages/contracts/src/contracts/current/protocol/Exchange/mixins/MSettlement.sol
View File

@@ -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
);

60
packages/contracts/src/utils/exchange_wrapper.ts
View File

@@ -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 },
);

16
packages/contracts/src/utils/formatters.ts
View File

@@ -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);

20
packages/contracts/src/utils/order_utils.ts
View File

@@ -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,

18
packages/contracts/src/utils/types.ts
View File

@@ -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;

22
packages/contracts/test/asset_proxy_dispatcher/proxies.ts
View File

@@ -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(

442
packages/contracts/test/exchange/core.ts
View File

@@ -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),

4
packages/contracts/test/exchange/helpers.ts
View File

@@ -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),

438
packages/contracts/test/exchange/wrapper.ts
View File

@@ -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);