diff --git a/contracts/core/exchange-wrappers/KyberNetworkWrapper.sol b/contracts/core/exchange-wrappers/KyberNetworkWrapper.sol index 042d01c82..463249173 100644 --- a/contracts/core/exchange-wrappers/KyberNetworkWrapper.sol +++ b/contracts/core/exchange-wrappers/KyberNetworkWrapper.sol @@ -33,8 +33,8 @@ import { LibBytes } from "../../external/0x/LibBytes.sol"; contract KyberNetworkWrapper is Authorizable { - using SafeMath for uint256; using LibBytes for bytes; + using SafeMath for uint256; /* ============ State Variables ============ */ @@ -79,16 +79,20 @@ contract KyberNetworkWrapper is * We currently pass change back to the issuance order maker, exploring how it can safely be passed to the taker. * * - * @param _maker Address of issuance order signer to conform to IExchangeWrapper - * @param _ Unused address of fillOrder caller to conform to IExchangeWrapper - * @param _tradeCount Amount of trades in exchange request - * @param _tradesData Byte string containing (multiple) Kyber trades - * @return address[] Array of token addresses traded for - * @return uint256[] Array of token amounts traded for + * @param _maker Address of issuance order signer to conform to IExchangeWrapper + * -- Unused address of fillOrder caller to conform to IExchangeWrapper -- + * @param _makerToken Address of maker token used in exchange orders + * @param _makerAssetAmount Amount of issuance order maker token to use on this exchange + * @param _tradeCount Amount of trades in exchange request + * @param _tradesData Byte string containing (multiple) Kyber trades + * @return address[] Array of token addresses traded for + * @return uint256[] Array of token amounts traded for */ function exchange( address _maker, - address _, + address, + address _makerToken, + uint256 _makerAssetAmount, uint256 _tradeCount, bytes _tradesData ) @@ -96,88 +100,86 @@ contract KyberNetworkWrapper is onlyAuthorized returns (address[], uint256[]) { - address[] memory takerTokens = new address[](_tradeCount); - uint256[] memory takerAmounts = new uint256[](_tradeCount); + // Ensure the issuance order maker token is allowed to be transferred by KyberNetworkProxy as the source token + ERC20.ensureAllowance( + _makerToken, + address(this), + kyberNetworkProxy, + _makerAssetAmount + ); + + address[] memory componentTokensReceived = new address[](_tradeCount); + uint256[] memory componentTokensAmounts = new uint256[](_tradeCount); - uint256 scannedBytes = 0; + // Parse and execute the trade at the current offset via the KyberNetworkProxy, each kyber trade is 160 bytes for (uint256 i = 0; i < _tradeCount; i++) { - // Parse Kyber trade of current offset - KyberTrade memory trade = parseKyberTrade( + (componentTokensReceived[i], componentTokensAmounts[i]) = tradeOnKyberReserve( _tradesData, - scannedBytes + i.mul(160) ); + } - // Execute the trade via the KyberNetworkProxy - takerTokens[i] = trade.destinationToken; - takerAmounts[i] = tradeOnKyberReserve( - trade, - _maker + // Transfer any unused or remainder maker token back to the issuance order user + uint remainderSourceToken = ERC20.balanceOf(_makerToken, this); + if (remainderSourceToken > 0) { + ERC20.transfer( + _makerToken, + _maker, + remainderSourceToken ); - - // Update current bytes - scannedBytes = scannedBytes.add(160); } return ( - takerTokens, - takerAmounts + componentTokensReceived, + componentTokensAmounts ); } /* ============ Private ============ */ /** - * Executes Kyber trade + * Parses and executes Kyber trade * - * @param _trade Kyber trade parameter struct - * @param _maker Address of issuance order maker to pass change to - * @return address Address of set component to trade for - * @return uint256 Amount of set component received in trade + * @param _tradesData Kyber trade parameter struct + * @param _offset Start of current Kyber trade to execute + * @return address Address of set component to trade for + * @return uint256 Amount of set component received in trade */ function tradeOnKyberReserve( - KyberTrade memory _trade, - address _maker + bytes _tradesData, + uint256 _offset ) private - returns (uint256) + returns (address, uint256) { - // Ensure the source token is allowed to be transferred by KyberNetworkProxy - ERC20.ensureAllowance( - _trade.sourceToken, - address(this), - kyberNetworkProxy, - _trade.sourceTokenQuantity + // Parse Kyber trade at the current offset + KyberTrade memory trade = parseKyberTrade( + _tradesData, + _offset ); uint256 destinationTokenQuantity = KyberNetworkProxyInterface(kyberNetworkProxy).trade( - _trade.sourceToken, - _trade.sourceTokenQuantity, - _trade.destinationToken, + trade.sourceToken, + trade.sourceTokenQuantity, + trade.destinationToken, address(this), - _trade.maxDestinationQuantity, - _trade.minimumConversionRate, + trade.maxDestinationQuantity, + trade.minimumConversionRate, 0 ); - // Transfer any unused issuance order maker token back to user - uint remainderSourceToken = ERC20.balanceOf(_trade.sourceToken, this); - if (remainderSourceToken > 0) { - ERC20.transfer( - _trade.sourceToken, - _maker, - remainderSourceToken - ); - } - - // Ensure the maker token is allowed to be transferred by Set TransferProxy + // Ensure the destination token is allowed to be transferred by Set TransferProxy ERC20.ensureAllowance( - _trade.destinationToken, + trade.destinationToken, address(this), setTransferProxy, destinationTokenQuantity ); - return destinationTokenQuantity; + return ( + trade.destinationToken, + destinationTokenQuantity + ); } /* diff --git a/contracts/core/exchange-wrappers/TakerWalletWrapper.sol b/contracts/core/exchange-wrappers/TakerWalletWrapper.sol index b7446580a..56346263b 100644 --- a/contracts/core/exchange-wrappers/TakerWalletWrapper.sol +++ b/contracts/core/exchange-wrappers/TakerWalletWrapper.sol @@ -33,6 +33,7 @@ import { LibBytes } from "../../external/0x/LibBytes.sol"; contract TakerWalletWrapper is Authorizable { + using LibBytes for bytes; using SafeMath for uint256; /* ============ State Variables ============ */ @@ -62,18 +63,22 @@ contract TakerWalletWrapper is * IExchange interface delegate method. * Parses taker wallet orders and transfers tokens from taker's wallet. * - * @param _ Unused address of issuance order signer to conform to IExchangeWrapper - * @param _taker Taker wallet address - * @param _orderCount Amount of orders in exchange request - * @param _ordersData Encoded taker wallet order data - * @return address[] Array of token addresses executed in orders - * @return uint256[] Array of token amounts executed in orders + * -- Unused address of issuance order signer to conform to IExchangeWrapper -- + * @param _taker Taker wallet to transfer components from + * -- Unused address of maker token used in exchange orders -- + * -- Unused amount of issuance order maker token to use on this exchange -- + * @param _orderCount Amount of orders in exchange request + * @param _transfersData Encoded taker wallet order data + * @return address[] Array of token addresses executed in orders + * @return uint256[] Array of token amounts executed in orders */ function exchange( - address _, + address, address _taker, + address, + uint256, uint256 _orderCount, - bytes _ordersData + bytes _transfersData ) public onlyAuthorized @@ -82,37 +87,17 @@ contract TakerWalletWrapper is address[] memory takerTokens = new address[](_orderCount); uint256[] memory takerTokenAmounts = new uint256[](_orderCount); - uint256 scannedBytes = 32; - while (scannedBytes < _ordersData.length) { - - // Read the next transfer order - address takerToken; - uint256 takerTokenAmount; - assembly { - takerToken := mload(add(_ordersData, scannedBytes)) - takerTokenAmount := mload(add(_ordersData, add(scannedBytes, 32))) - } - - // Transfer from taker's wallet to this wrapper - ITransferProxy(transferProxy).transfer( - takerToken, - takerTokenAmount, - _taker, - address(this) - ); - - // Ensure allowance of transfer from this wrapper to TransferProxy - ERC20Wrapper.ensureAllowance( - takerToken, - address(this), - transferProxy, - takerTokenAmount - ); - + uint256 scannedBytes = 0; + while (scannedBytes < _transfersData.length) { // Record taker token and amount to return values uint256 orderCount = scannedBytes >> 6; - takerTokens[orderCount] = takerToken; - takerTokenAmounts[orderCount] = takerTokenAmount; + + // Transfer the tokens from the taker + (takerTokens[orderCount], takerTokenAmounts[orderCount]) = transferFromTaker( + _taker, + scannedBytes, + _transfersData + ); // Update scanned bytes with length of each transfer request (64) scannedBytes = scannedBytes.add(64); @@ -120,4 +105,52 @@ contract TakerWalletWrapper is return (takerTokens, takerTokenAmounts); } + + /* ============ Private ============ */ + + /** + * Parses and executes transfer from the issuance order taker's wallet + * + * @param _taker Taker wallet to transfer components from + * @param _offset Offset to start scanning for current transfer + * @param _transfersData Byte array of (multiple) taker wallet transfers + * @return address Address of token transferred + * @return uint256 Amount of the token transferred + */ + function transferFromTaker( + address _taker, + uint256 _offset, + bytes _transfersData + ) + private + returns (address, uint256) + { + uint256 transferDataStart = _offset.add(32); + + // Read the next transfer + address takerToken; + uint256 takerTokenAmount; + assembly { + takerToken := mload(add(_transfersData, transferDataStart)) + takerTokenAmount := mload(add(_transfersData, add(transferDataStart, 32))) + } + + // Transfer from taker's wallet to this wrapper + ITransferProxy(transferProxy).transfer( + takerToken, + takerTokenAmount, + _taker, + address(this) + ); + + // Ensure the component token is allowed to be transferred by Set TransferProxy + ERC20Wrapper.ensureAllowance( + takerToken, + address(this), + transferProxy, + takerTokenAmount + ); + + return (takerToken, takerTokenAmount); + } } diff --git a/contracts/core/exchange-wrappers/ZeroExExchangeWrapper.sol b/contracts/core/exchange-wrappers/ZeroExExchangeWrapper.sol index 6f4e0c159..b8219be72 100644 --- a/contracts/core/exchange-wrappers/ZeroExExchangeWrapper.sol +++ b/contracts/core/exchange-wrappers/ZeroExExchangeWrapper.sol @@ -36,8 +36,8 @@ import { ZeroExOrderDataHandler as OrderHandler } from "./lib/ZeroExOrderDataHan contract ZeroExExchangeWrapper is Authorizable { - using SafeMath for uint256; using LibBytes for bytes; + using SafeMath for uint256; /* ============ State Variables ============ */ @@ -71,20 +71,24 @@ contract ZeroExExchangeWrapper is /** * IExchangeWrapper interface delegate method. - * Parses 0x exchange orders and transfers tokens from taker's wallet. + * Parses 0x exchange orders and executes them for Set component tokens * * TODO: We are currently assuming no taker fee. Add in taker fee going forward * - * @param _maker Unused address of issuance order signer to conform to IExchangeWrapper - * @param _taker Unused address of fillOrder caller to conform to IExchangeWrapper - * @param _orderCount Amount of orders in exchange request - * @param _ordersData Byte string containing (multiple) 0x wrapper orders - * @return address[] Array of token addresses executed in orders - * @return uint256[] Array of token amounts executed in orders + * -- Unused address of issuance order signer to conform to IExchangeWrapper -- + * -- Unused address of fillOrder caller to conform to IExchangeWrapper -- + * @param _makerToken Address of maker token used in exchange orders + * @param _makerAssetAmount Amount of issuance order maker token to use on this exchange + * @param _orderCount Amount of orders in exchange request + * @param _ordersData Byte string containing (multiple) 0x wrapper orders + * @return address[] Array of Set component token addresses executed in orders + * @return uint256[] Array of Set component token amounts executed in orders */ function exchange( - address _maker, - address _taker, + address, + address, + address _makerToken, + uint256 _makerAssetAmount, uint256 _orderCount, bytes _ordersData ) @@ -92,96 +96,93 @@ contract ZeroExExchangeWrapper is onlyAuthorized returns (address[], uint256[]) { - address[] memory takerTokens = new address[](_orderCount); - uint256[] memory takerAmounts = new uint256[](_orderCount); + // Ensure the taker token is allowed to be transferred by ZeroEx Proxy + ERC20.ensureAllowance( + _makerToken, + address(this), + zeroExProxy, + _makerAssetAmount + ); + + address[] memory componentTokensReceived = new address[](_orderCount); + uint256[] memory componentTokensAmounts = new uint256[](_orderCount); uint256 scannedBytes = 0; for (uint256 i = 0; i < _orderCount; i++) { - // Parse header of current wrapper order - OrderHandler.OrderHeader memory header = OrderHandler.parseOrderHeader( - _ordersData, - scannedBytes - ); - - // Helper reduce math, keeping the position of the start of the next 0x order body - uint256 orderBodyStart = scannedBytes.add(header.signatureLength).add(160); - - // Grab signature of current wrapper order after the header of length 160 and before the start of the body - bytes memory signature = _ordersData.slice( - scannedBytes.add(160), - orderBodyStart - ); - // Parse 0x order of current wrapper order - ZeroExOrder.Order memory order = OrderHandler.parseZeroExOrder( + // Fill the order via the 0x exchange + uint256 bytesScanned; + (componentTokensReceived[i], componentTokensAmounts[i], bytesScanned) = fillZeroExOrder( _ordersData, - header, - orderBodyStart + scannedBytes ); - // Fill the order via the 0x exchange - (takerTokens[i], takerAmounts[i]) = fillZeroExOrder( - order, - signature, - header + ERC20.ensureAllowance( + componentTokensReceived[i], + address(this), + setTransferProxy, + componentTokensAmounts[i] ); // Update current bytes - scannedBytes = orderBodyStart.add(header.orderLength); + scannedBytes = bytesScanned; } return ( - takerTokens, - takerAmounts + componentTokensReceived, + componentTokensAmounts ); } /* ============ Private ============ */ /** - * Executes 0x order from signed order data + * Parses and executes 0x order from orders data bytes * - * @param _order 0x order struct - * @param _signature Signature for order - * @param _header Struct containing wrapper order header data for order - * @return address Address of set component (0x makerToken) in 0x order - * @return uint256 Amount of 0x order makerTokenAmount received + * @param _ordersData Byte string containing (multiple) 0x wrapper orders + * @param _offset Start of current 0x order to fill + * @return address Address of set component (0x makerToken) in 0x order + * @return uint256 Amount of 0x order makerTokenAmount received */ function fillZeroExOrder( - ZeroExOrder.Order memory _order, - bytes memory _signature, - OrderHandler.OrderHeader memory _header + bytes _ordersData, + uint256 _offset ) private - returns (address, uint256) + returns (address, uint256, uint256) { - // Ensure the taker token is allowed to be transferred by ZeroEx Proxy - address takerToken = OrderHandler.parseERC20TokenAddress(_order.takerAssetData); - ERC20.ensureAllowance( - takerToken, - address(this), - zeroExProxy, - _order.takerAssetAmount + // Parse header of current wrapper order + OrderHandler.OrderHeader memory header = OrderHandler.parseOrderHeader( + _ordersData, + _offset ); - ZeroExFillResults.FillResults memory fillResults = ZeroExExchange(zeroExExchange).fillOrKillOrder( - _order, - _header.fillAmount, - _signature + // Helper to reduce math, keeping the position of the start of the next 0x order body + uint256 orderBodyStart = _offset.add(header.signatureLength).add(160); + + // Grab signature of current wrapper order after the header of length 160 and before the start of the body + bytes memory signature = _ordersData.slice( + _offset.add(160), + orderBodyStart ); - // Ensure the maker token is allowed to be transferred by Set TransferProxy - address makerToken = OrderHandler.parseERC20TokenAddress(_order.makerAssetData); - ERC20.ensureAllowance( - makerToken, - address(this), - setTransferProxy, - _order.makerAssetAmount + // Parse 0x order of current wrapper order + ZeroExOrder.Order memory order = OrderHandler.parseZeroExOrder( + _ordersData, + header, + orderBodyStart + ); + + ZeroExFillResults.FillResults memory fillResults = ZeroExExchange(zeroExExchange).fillOrKillOrder( + order, + header.fillAmount, + signature ); return ( - makerToken, - fillResults.makerAssetFilledAmount + OrderHandler.parseERC20TokenAddress(order.makerAssetData), + fillResults.makerAssetFilledAmount, + orderBodyStart.add(header.orderLength) ); } } diff --git a/contracts/core/extensions/CoreIssuanceOrder.sol b/contracts/core/extensions/CoreIssuanceOrder.sol index 75b903ec4..b980a538c 100644 --- a/contracts/core/extensions/CoreIssuanceOrder.sol +++ b/contracts/core/extensions/CoreIssuanceOrder.sol @@ -292,6 +292,8 @@ contract CoreIssuanceOrder is (componentFillTokens, componentFillAmounts) = IExchangeWrapper(exchange).exchange( _makerAddress, msg.sender, + _makerTokenAddress, + header.makerTokenAmount, header.orderCount, bodyData ); diff --git a/contracts/core/interfaces/IExchangeWrapper.sol b/contracts/core/interfaces/IExchangeWrapper.sol index 9731bf167..04efe80f9 100644 --- a/contracts/core/interfaces/IExchangeWrapper.sol +++ b/contracts/core/interfaces/IExchangeWrapper.sol @@ -32,13 +32,18 @@ interface IExchangeWrapper { * * @param _maker Issuance order maker * @param _taker Issuance order taker + * @param _makerToken Address of maker token used in exchange orders + * @param _makerAssetAmount Amount of issuance order maker token to use on this exchange * @param _orderCount Expected number of orders to execute * @param _orderData Arbitrary bytes data for any information to pass to the exchange - * @return address[], uint256[] The taker token addresses and the associated quantities + * @return address[] The addresses of required components + * @return uint256[] The quantities of required components retrieved by the wrapper */ function exchange( address _maker, address _taker, + address _makerToken, + uint256 _makerAssetAmount, uint256 _orderCount, bytes _orderData ) diff --git a/package.json b/package.json index 1c92c4e1b..1d70d560f 100644 --- a/package.json +++ b/package.json @@ -89,7 +89,7 @@ "husky": "^0.14.3", "lint-staged": "^7.2.0", "module-alias": "^2.1.0", - "set-protocol-utils": "^0.3.33", + "set-protocol-utils": "^0.3.37", "sol-trace-set": "^0.0.1", "solium": "^1.1.7", "tiny-promisify": "^1.0.0", diff --git a/test/core/exchange-wrappers/kyberNetworkWrapper.spec.ts b/test/core/exchange-wrappers/kyberNetworkWrapper.spec.ts index 641c43cf8..6fff992c3 100644 --- a/test/core/exchange-wrappers/kyberNetworkWrapper.spec.ts +++ b/test/core/exchange-wrappers/kyberNetworkWrapper.spec.ts @@ -1,7 +1,6 @@ require('module-alias/register'); import * as chai from 'chai'; -import * as ethUtil from 'ethereumjs-util'; import * as setProtocolUtils from 'set-protocol-utils'; import { BigNumber } from 'bignumber.js'; import { Address, Bytes, KyberTrade } from 'set-protocol-utils'; @@ -23,8 +22,7 @@ import { expectRevertError } from '@utils/tokenAssertions'; BigNumberSetup.configure(); ChaiSetup.configure(); const { expect } = chai; -const { SetProtocolTestUtils: SetTestUtils, SetProtocolUtils: SetUtils } = setProtocolUtils; -const setUtils = new SetUtils(web3); +const { SetProtocolTestUtils: SetTestUtils } = setProtocolUtils; const blockchain = new Blockchain(web3); @@ -64,6 +62,8 @@ contract('KyberNetworkWrapper', accounts => { let subjectCaller: Address; let subjectMaker: Address; let subjectTaker: Address; + let subjectMakerTokenAddress: Address; + let subjectMakerTokenAmount: BigNumber; let subjectTradesCount: BigNumber; let subjectTradesData: Bytes; @@ -107,14 +107,18 @@ contract('KyberNetworkWrapper', accounts => { subjectCaller = authorizedAddress; subjectMaker = issuanceOrderMakerAccount; subjectTaker = takerAccount; + subjectMakerTokenAddress = sourceToken.address; + subjectMakerTokenAmount = sourceTokenQuantity; subjectTradesCount = new BigNumber(1); - subjectTradesData = ethUtil.bufferToHex(setUtils.kyberTradeToBuffer(kyberTrade)); + subjectTradesData = SetTestUtils.kyberTradeToBytes(kyberTrade); }); async function subject(): Promise { return kyberNetworkWrapper.exchange.sendTransactionAsync( subjectMaker, subjectTaker, + subjectMakerTokenAddress, + subjectMakerTokenAmount, subjectTradesCount, subjectTradesData, { from: subjectCaller, gas: DEFAULT_GAS }, diff --git a/test/core/exchange-wrappers/lib/zeroExOrderDataHandlerMock.spec.ts b/test/core/exchange-wrappers/lib/zeroExOrderDataHandlerMock.spec.ts index d1c53fd4f..f32e69729 100644 --- a/test/core/exchange-wrappers/lib/zeroExOrderDataHandlerMock.spec.ts +++ b/test/core/exchange-wrappers/lib/zeroExOrderDataHandlerMock.spec.ts @@ -58,7 +58,7 @@ contract('ZeroExOrderDataHandlerMock', accounts => { await blockchain.saveSnapshotAsync(); zeroExExchangeWrapper = await libraryMockWrapper.deployZeroExOrderDataHandlerLibraryAsync(); - zeroExOrder = SetUtils.generateZeroExOrder( + zeroExOrder = SetTestUtils.generateZeroExOrder( senderAddress || senderAccount, makerAddress || ownerAccount, takerAddress || takerAccount, @@ -71,7 +71,7 @@ contract('ZeroExOrderDataHandlerMock', accounts => { salt || SetUtils.generateSalt(), SetTestUtils.ZERO_EX_EXCHANGE_ADDRESS, feeRecipientAddress, - expirationTimeSeconds || SetUtils.generateTimestamp(10), + expirationTimeSeconds || SetTestUtils.generateTimestamp(10), ); makerAssetData = assetDataUtils.encodeERC20AssetData(makerTokenAddress); @@ -80,7 +80,7 @@ contract('ZeroExOrderDataHandlerMock', accounts => { signature = '0x0012034334393842'; fillAmount = ether(1); - zeroExWrapperOrderData = SetUtils.generateZeroExExchangeWrapperOrder(zeroExOrder, signature, fillAmount); + zeroExWrapperOrderData = SetTestUtils.generateZeroExExchangeWrapperOrder(zeroExOrder, signature, fillAmount); }); afterEach(async () => { @@ -113,7 +113,7 @@ contract('ZeroExOrderDataHandlerMock', accounts => { it('correctly parses the zeroEx order length', async () => { const [, parsedOrderLength] = await subject(); - const expectedLength = SetUtils.numBytesFromBuffer(SetUtils.zeroExOrderToBuffer(zeroExOrder)); + const expectedLength = SetUtils.numBytesFromBuffer(SetTestUtils.zeroExOrderToBuffer(zeroExOrder)); expect(parsedOrderLength).to.bignumber.equal(expectedLength); }); @@ -178,7 +178,7 @@ contract('ZeroExOrderDataHandlerMock', accounts => { takerFee = ether(1); makerAssetAmount = ether(1); takerAssetAmount = ether(1); - expirationTimeSeconds = SetUtils.generateTimestamp(10); + expirationTimeSeconds = SetTestUtils.generateTimestamp(10); salt = SetUtils.generateSalt(); }); diff --git a/test/core/exchange-wrappers/takerWalletWrapper.spec.ts b/test/core/exchange-wrappers/takerWalletWrapper.spec.ts index 43f29da97..b0329bdab 100644 --- a/test/core/exchange-wrappers/takerWalletWrapper.spec.ts +++ b/test/core/exchange-wrappers/takerWalletWrapper.spec.ts @@ -2,6 +2,7 @@ require('module-alias/register'); import * as _ from 'lodash'; import * as chai from 'chai'; +import * as setProtocolUtils from 'set-protocol-utils'; import { BigNumber } from 'bignumber.js'; import { Address, Bytes } from 'set-protocol-utils'; @@ -26,8 +27,10 @@ import { expectRevertError } from '@utils/tokenAssertions'; BigNumberSetup.configure(); ChaiSetup.configure(); +const { SetProtocolUtils: SetUtils } = setProtocolUtils; const { expect } = chai; const blockchain = new Blockchain(web3); +const { ZERO } = SetUtils.CONSTANTS; contract('TakerWalletWrapper', accounts => { @@ -69,6 +72,10 @@ contract('TakerWalletWrapper', accounts => { describe('#exchange', async () => { let subjectCaller: Address; + let subjectMakerAccount: Address; + let subjectTakerAccount: Address; + let subjectMakerTokenAddress: Address; + let subjectMakerTokenAmount: BigNumber; let subjectOrderCount: BigNumber; let subjectTakerOrdersData: Bytes; @@ -81,14 +88,20 @@ contract('TakerWalletWrapper', accounts => { const transferAmounts = _.map(components, token => transferAmount); subjectCaller = authorizedAddress; + subjectMakerAccount = makerAccount; + subjectTakerAccount = takerAccount; + subjectMakerTokenAddress = componentToken.address; + subjectMakerTokenAmount = ZERO; subjectOrderCount = new BigNumber(componentAddresses.length); subjectTakerOrdersData = generateTakerWalletOrders(componentAddresses, transferAmounts); }); async function subject(): Promise { return takerWalletWrapper.exchange.sendTransactionAsync( - makerAccount, - takerAccount, + subjectMakerAccount, + subjectTakerAccount, + subjectMakerTokenAddress, + subjectMakerTokenAmount, subjectOrderCount, subjectTakerOrdersData, { from: subjectCaller, gas: DEFAULT_GAS }, diff --git a/test/core/exchange-wrappers/zeroExExchangeWrapper.spec.ts b/test/core/exchange-wrappers/zeroExExchangeWrapper.spec.ts index ad3c47d0c..a0d9e5868 100644 --- a/test/core/exchange-wrappers/zeroExExchangeWrapper.spec.ts +++ b/test/core/exchange-wrappers/zeroExExchangeWrapper.spec.ts @@ -93,6 +93,8 @@ contract('ZeroExExchangeWrapper', accounts => { describe('#exchange', async () => { let subjectMakerAccount: Address; let subjectTakerAccount: Address; + let subjectMakerTokenAddress: Address; + let subjectMakerTokenAmount: BigNumber; let subjectOrderCount: BigNumber; let subjectOrderData: Bytes; @@ -120,9 +122,9 @@ contract('ZeroExExchangeWrapper', accounts => { takerAssetAmount = takerAssetAmount || ether(10); salt = salt || SetUtils.generateSalt(); feeRecipientAddress = feeRecipientAddress || NULL_ADDRESS; - expirationTimeSeconds = expirationTimeSeconds || SetUtils.generateTimestamp(10); + expirationTimeSeconds = expirationTimeSeconds || SetTestUtils.generateTimestamp(10); - zeroExOrder = SetUtils.generateZeroExOrder( + zeroExOrder = SetTestUtils.generateZeroExOrder( senderAddress, makerAddress, takerAddress, @@ -140,7 +142,7 @@ contract('ZeroExExchangeWrapper', accounts => { const zeroExOrderFillAmount = takerAssetAmount; const zeroExOrderSignature = await setUtils.signZeroExOrderAsync(zeroExOrder); - zeroExExchangeWrapperOrder = SetUtils.generateZeroExExchangeWrapperOrder( + zeroExExchangeWrapperOrder = SetTestUtils.generateZeroExExchangeWrapperOrder( zeroExOrder, zeroExOrderSignature, zeroExOrderFillAmount @@ -148,6 +150,8 @@ contract('ZeroExExchangeWrapper', accounts => { subjectMakerAccount = issuanceOrderMakerAccount; subjectTakerAccount = issuanceOrderAndZeroExOrderTakerAccount; + subjectMakerTokenAddress = zeroExOrderTakerToken.address; + subjectMakerTokenAmount = takerAssetAmount; subjectOrderCount = new BigNumber(1); subjectOrderData = zeroExExchangeWrapperOrder; }); @@ -156,8 +160,11 @@ contract('ZeroExExchangeWrapper', accounts => { return zeroExExchangeWrapper.exchange.sendTransactionAsync( subjectMakerAccount, subjectTakerAccount, + subjectMakerTokenAddress, + subjectMakerTokenAmount, subjectOrderCount, - subjectOrderData + subjectOrderData, + { from: deployerAccount }, ); } @@ -191,7 +198,7 @@ contract('ZeroExExchangeWrapper', accounts => { context('when the order is already expired', async() => { before(async () => { - expirationTimeSeconds = SetUtils.generateTimestamp(0); + expirationTimeSeconds = SetTestUtils.generateTimestamp(0); }); after(async () => { @@ -210,7 +217,7 @@ contract('ZeroExExchangeWrapper', accounts => { const zeroExOrderFillAmount = takerAssetAmount; const zeroExOrderSignature = await setUtils.signZeroExOrderAsync(differentZeroExOrder); - subjectOrderData = SetUtils.generateZeroExExchangeWrapperOrder( + subjectOrderData = SetTestUtils.generateZeroExExchangeWrapperOrder( zeroExOrder, zeroExOrderSignature, zeroExOrderFillAmount @@ -226,7 +233,7 @@ contract('ZeroExExchangeWrapper', accounts => { beforeEach(async () => { const zeroExOrderFillAmount = takerAssetAmount.add(ether(1)); const zeroExOrderSignature = await setUtils.signZeroExOrderAsync(zeroExOrder); - subjectOrderData = SetUtils.generateZeroExExchangeWrapperOrder( + subjectOrderData = SetTestUtils.generateZeroExExchangeWrapperOrder( zeroExOrder, zeroExOrderSignature, zeroExOrderFillAmount @@ -256,7 +263,7 @@ contract('ZeroExExchangeWrapper', accounts => { secondZeroExOrderMakerAssetAmount = ether(100); secondZeroExOrderTakerAssetAmount = ether(20); - secondZeroExOrder = SetUtils.generateZeroExOrder( + secondZeroExOrder = SetTestUtils.generateZeroExOrder( NULL_ADDRESS, secondZeroExOrderMakerAccount, NULL_ADDRESS, @@ -269,17 +276,17 @@ contract('ZeroExExchangeWrapper', accounts => { SetUtils.generateSalt(), SetTestUtils.ZERO_EX_EXCHANGE_ADDRESS, NULL_ADDRESS, - SetUtils.generateTimestamp(10), + SetTestUtils.generateTimestamp(10), ); const zeroExOrderFillAmount = secondZeroExOrderTakerAssetAmount; const zeroExOrderSignature = await setUtils.signZeroExOrderAsync(secondZeroExOrder); - const secondZeroExExchangeWrapperOrder = SetUtils.generateZeroExExchangeWrapperOrder( + const secondZeroExExchangeWrapperOrder = SetTestUtils.generateZeroExExchangeWrapperOrder( secondZeroExOrder, zeroExOrderSignature, zeroExOrderFillAmount ); - subjectOrderData = SetUtils.concatBytes([zeroExExchangeWrapperOrder, secondZeroExExchangeWrapperOrder]); + subjectOrderData = SetTestUtils.concatBytes([zeroExExchangeWrapperOrder, secondZeroExExchangeWrapperOrder]); }); it('should receipt the correct amounts of taker tokens and set allowances on ZeroEx/Set proxies', async () => { @@ -321,6 +328,8 @@ contract('ZeroExExchangeWrapper', accounts => { return zeroExExchangeWrapper.exchange.callAsync( subjectMakerAccount, subjectTakerAccount, + subjectMakerTokenAddress, + subjectMakerTokenAmount, subjectOrderCount, subjectOrderData, { from: deployerAccount }, diff --git a/test/core/extensions/coreIssuanceOrder.spec.ts b/test/core/extensions/coreIssuanceOrder.spec.ts index 8db2c755e..80ce9527e 100644 --- a/test/core/extensions/coreIssuanceOrder.spec.ts +++ b/test/core/extensions/coreIssuanceOrder.spec.ts @@ -3,6 +3,7 @@ require('module-alias/register'); import * as _ from 'lodash'; import * as ABIDecoder from 'abi-decoder'; import * as chai from 'chai'; +import * as ethUtil from 'ethereumjs-util'; import * as setProtocolUtils from 'set-protocol-utils'; import { Address, @@ -105,7 +106,7 @@ contract('CoreIssuanceOrder', accounts => { let naturalUnit: BigNumber; let setToken: SetTokenContract; - let order: IssuanceOrder; + let issuanceOrder: IssuanceOrder; let issuanceOrderSetAddress: Address; let issuanceOrderQuantity: BigNumber; let issuanceOrderMakerAddress: Address; @@ -113,11 +114,11 @@ contract('CoreIssuanceOrder', accounts => { let issuanceOrderMakerRelayerFee: BigNumber; let issuanceOrderTakerRelayerFee: BigNumber; let issuanceOrderExpiration: BigNumber; + let issuanceOrderRequiredComponents: Address[]; + let issuanceOrderRequiredComponentAmounts: BigNumber[]; let orderHash: string; let zeroExOrder: ZeroExSignedFillOrder; - let makerTokenAmountToUseOnZeroExOrderAsFillAmount: BigNumber; - let makerTokenAmountToUseAcrossLiqudityOrders: BigNumber; let takerWalletOrder: TakerWalletOrder; let takerWalletOrderComponentAmount: BigNumber; @@ -165,11 +166,11 @@ contract('CoreIssuanceOrder', accounts => { ); const quantity = issuanceOrderQuantity || ether(4); - const requiredComponents = [firstComponent.address, secondComponent.address]; - const requiredComponentAmounts = _.map(componentUnits, unit => unit.mul(quantity).div(naturalUnit)); + issuanceOrderRequiredComponents = [firstComponent.address, secondComponent.address]; + issuanceOrderRequiredComponentAmounts = _.map(componentUnits, unit => unit.mul(quantity).div(naturalUnit)); // Property: Value | Default | Property - order = { + issuanceOrder = { setAddress: issuanceOrderSetAddress || setToken.address, // setAddress makerAddress: issuanceOrderMakerAddress || issuanceOrderMaker, // makerAddress makerToken: makerToken.address, // makerToken @@ -177,64 +178,61 @@ contract('CoreIssuanceOrder', accounts => { relayerToken: relayerToken.address, // relayerToken quantity: quantity || ether(4), // quantity makerTokenAmount: issuanceOrderMakerTokenAmount || ether(10), // makerTokenAmount - expiration: issuanceOrderExpiration || SetUtils.generateTimestamp(10000), // expiration + expiration: issuanceOrderExpiration || SetTestUtils.generateTimestamp(10000), // expiration makerRelayerFee: issuanceOrderMakerRelayerFee || ether(3), // makerRelayerFee takerRelayerFee: issuanceOrderTakerRelayerFee || ZERO, // takerRelayerFee - requiredComponents: requiredComponents, // requiredComponents - requiredComponentAmounts: requiredComponentAmounts, // requiredComponentAmounts + requiredComponents: issuanceOrderRequiredComponents, // requiredComponents + requiredComponentAmounts: issuanceOrderRequiredComponentAmounts, // requiredComponentAmounts salt: SetUtils.generateSalt(), // salt } as IssuanceOrder; - orderHash = SetUtils.hashOrderHex(order); + orderHash = SetUtils.hashOrderHex(issuanceOrder); const signature = await setUtils.signMessage(orderHash, issuanceOrderMaker, false); takerWalletOrder = { takerTokenAddress: firstComponent.address, - takerTokenAmount: takerWalletOrderComponentAmount || requiredComponentAmounts[0], + takerTokenAmount: takerWalletOrderComponentAmount || issuanceOrderRequiredComponentAmounts[0], } as TakerWalletOrder; - const zeroExOrderTakerAssetAmount = order.makerTokenAmount.div(4); + const zeroExOrderTakerAssetAmount = issuanceOrder.makerTokenAmount.div(4); zeroExOrder = await setUtils.generateZeroExSignedFillOrder( - NULL_ADDRESS, // senderAddress - zeroExOrderMaker, // makerAddress - NULL_ADDRESS, // takerAddress - ZERO, // makerFee - ZERO, // takerFee - requiredComponentAmounts[1], // makerAssetAmount - zeroExOrderTakerAssetAmount, // takerAssetAmount - secondComponent.address, // makerAssetAddress - makerToken.address, // takerAssetAddress - SetUtils.generateSalt(), // salt - SetTestUtils.ZERO_EX_EXCHANGE_ADDRESS, // exchangeAddress - NULL_ADDRESS, // feeRecipientAddress - SetUtils.generateTimestamp(10000), // expirationTimeSeconds - makerTokenAmountToUseOnZeroExOrderAsFillAmount || zeroExOrderTakerAssetAmount, // amount of zeroExOrder to fill + NULL_ADDRESS, // senderAddress + zeroExOrderMaker, // makerAddress + NULL_ADDRESS, // takerAddress + ZERO, // makerFee + ZERO, // takerFee + issuanceOrderRequiredComponentAmounts[1], // makerAssetAmount + zeroExOrderTakerAssetAmount, // takerAssetAmount + secondComponent.address, // makerAssetAddress + makerToken.address, // takerAssetAddress + SetUtils.generateSalt(), // salt + SetTestUtils.ZERO_EX_EXCHANGE_ADDRESS, // exchangeAddress + NULL_ADDRESS, // feeRecipientAddress + SetTestUtils.generateTimestamp(10000), // expirationTimeSeconds + zeroExOrderTakerAssetAmount, // amount of zeroExOrder to fill ); subjectAddresses = [ - order.setAddress, - order.makerAddress, - order.makerToken, - order.relayerAddress, - order.relayerToken, + issuanceOrder.setAddress, + issuanceOrder.makerAddress, + issuanceOrder.makerToken, + issuanceOrder.relayerAddress, + issuanceOrder.relayerToken, ]; subjectValues = [ - order.quantity, - order.makerTokenAmount, - order.expiration, - order.makerRelayerFee, - order.takerRelayerFee, - order.salt, + issuanceOrder.quantity, + issuanceOrder.makerTokenAmount, + issuanceOrder.expiration, + issuanceOrder.makerRelayerFee, + issuanceOrder.takerRelayerFee, + issuanceOrder.salt, ]; - subjectRequiredComponents = order.requiredComponents; - subjectRequiredComponentAmounts = order.requiredComponentAmounts; - subjectQuantityToFill = order.quantity; + subjectRequiredComponents = issuanceOrder.requiredComponents; + subjectRequiredComponentAmounts = issuanceOrder.requiredComponentAmounts; + subjectQuantityToFill = issuanceOrder.quantity; subjectVSignature = new BigNumber(signature.v); subjectSigBytes = [signature.r, signature.s]; - subjectExchangeOrdersData = setUtils.generateSerializedOrders( - makerTokenAmountToUseAcrossLiqudityOrders || zeroExOrderTakerAssetAmount, - [zeroExOrder, takerWalletOrder] - ); + subjectExchangeOrdersData = setUtils.generateSerializedOrders([zeroExOrder, takerWalletOrder]); subjectCaller = issuanceOrderTaker; }); @@ -258,7 +256,7 @@ contract('CoreIssuanceOrder', accounts => { await subject(); - const fullMakerTokenAmount = order.makerTokenAmount; + const fullMakerTokenAmount = issuanceOrder.makerTokenAmount; const expectedNewBalance = existingBalance.sub(fullMakerTokenAmount); await assertTokenBalanceAsync(makerToken, expectedNewBalance, issuanceOrderMaker); }); @@ -269,18 +267,18 @@ contract('CoreIssuanceOrder', accounts => { await subject(); - const netMakerToTaker = order.makerTokenAmount.sub(zeroExOrder.fillAmount); + const netMakerToTaker = issuanceOrder.makerTokenAmount.sub(zeroExOrder.fillAmount); const expectedNewBalance = existingBalance.plus(netMakerToTaker); await assertTokenBalanceAsync(makerToken, expectedNewBalance, subjectCaller); }); it('transfers the fees to the relayer', async () => { - await assertTokenBalanceAsync(relayerToken, ZERO, relayerAccount); + await assertTokenBalanceAsync(relayerToken, ZERO, issuanceOrder.relayerAddress); await subject(); - const expectedNewBalance = ether(3); - await assertTokenBalanceAsync(relayerToken, expectedNewBalance, relayerAccount); + const expectedNewBalance = issuanceOrder.makerRelayerFee.add(issuanceOrder.takerRelayerFee); + await assertTokenBalanceAsync(relayerToken, expectedNewBalance, issuanceOrder.relayerAddress); }); it('mints the correct quantity of the set for the maker', async () => { @@ -302,8 +300,8 @@ contract('CoreIssuanceOrder', accounts => { }); it('emits correct LogFill event', async () => { - const makerTokenEarnedByOrderTaker = order.makerTokenAmount.sub(zeroExOrder.fillAmount); - const relayerTokenEarnedByRelayer = order.makerRelayerFee.add(order.takerRelayerFee); + const makerTokenEarnedByOrderTaker = issuanceOrder.makerTokenAmount.sub(zeroExOrder.fillAmount); + const relayerTokenEarnedByRelayer = issuanceOrder.makerRelayerFee.add(issuanceOrder.takerRelayerFee); const txHash = await subject(); @@ -313,7 +311,7 @@ contract('CoreIssuanceOrder', accounts => { issuanceOrderMaker, // makerAddress subjectCaller, // takerAddress makerToken.address, // makerToken - order.relayerAddress, // relayerAddress + issuanceOrder.relayerAddress, // relayerAddress relayerToken.address, // relayerToken subjectQuantityToFill, // quantityFilled makerTokenEarnedByOrderTaker, // makerTokenToTaker @@ -327,7 +325,7 @@ contract('CoreIssuanceOrder', accounts => { describe('when the fill size is less than the order quantity', async () => { beforeEach(async () => { - subjectQuantityToFill = order.quantity.div(2); + subjectQuantityToFill = issuanceOrder.quantity.div(2); }); it('transfers the partial maker token amount from the maker', async () => { @@ -336,7 +334,7 @@ contract('CoreIssuanceOrder', accounts => { await subject(); - const partialMakerTokenAmount = order.makerTokenAmount.mul(subjectQuantityToFill).div(ether(4)); + const partialMakerTokenAmount = issuanceOrder.makerTokenAmount.mul(subjectQuantityToFill).div(ether(4)); const expectedNewBalance = existingBalance.sub(partialMakerTokenAmount); await assertTokenBalanceAsync(makerToken, expectedNewBalance, issuanceOrderMaker); }); @@ -347,19 +345,19 @@ contract('CoreIssuanceOrder', accounts => { await subject(); - const makerTokenAmountAvailableForThisOrder = order.makerTokenAmount.div(2); + const makerTokenAmountAvailableForThisOrder = issuanceOrder.makerTokenAmount.div(2); const netMakerToTaker = makerTokenAmountAvailableForThisOrder.mul(subjectQuantityToFill).div(ether(4)); const expectedNewBalance = existingBalance.plus(netMakerToTaker); await assertTokenBalanceAsync(makerToken, expectedNewBalance, subjectCaller); }); it('transfers the partial fees to the relayer', async () => { - await assertTokenBalanceAsync(relayerToken, ZERO, relayerAccount); + await assertTokenBalanceAsync(relayerToken, ZERO, issuanceOrder.relayerAddress); await subject(); const expectedNewBalance = ether(3).mul(subjectQuantityToFill).div(ether(4)); - await assertTokenBalanceAsync(relayerToken, expectedNewBalance, relayerAccount); + await assertTokenBalanceAsync(relayerToken, expectedNewBalance, issuanceOrder.relayerAddress); }); it('mints the correct partial quantity of the set for the user', async () => { @@ -381,25 +379,25 @@ contract('CoreIssuanceOrder', accounts => { }); it('emits correct LogFill event', async () => { - const makerTokenAmountAvailableForThisOrder = order.makerTokenAmount.div(2); + const makerTokenAmountAvailableForThisOrder = issuanceOrder.makerTokenAmount.div(2); const netMakerToTaker = makerTokenAmountAvailableForThisOrder.mul(subjectQuantityToFill).div(ether(4)); - const fullFillRelayerFee = order.makerRelayerFee.add(order.takerRelayerFee); + const fullFillRelayerFee = issuanceOrder.makerRelayerFee.add(issuanceOrder.takerRelayerFee); const partialFillRelayerFee = fullFillRelayerFee.mul(subjectQuantityToFill).div(ether(4)); const txHash = await subject(); const formattedLogs = await setTestUtils.getLogsFromTxHash(txHash); const expectedLogs = getExpectedFillLog( - setToken.address, // setAddress - issuanceOrderMaker, // makerAddress - subjectCaller, // takerAddress - makerToken.address, // makerToken - order.relayerAddress, // relayerAddress - relayerToken.address, // relayerToken - subjectQuantityToFill, // quantityFilled - netMakerToTaker, // makerTokenToTaker - partialFillRelayerFee, // relayerTokenAmountPaid - orderHash, // orderHash + setToken.address, // setAddress + issuanceOrderMaker, // makerAddress + subjectCaller, // takerAddress + makerToken.address, // makerToken + issuanceOrder.relayerAddress, // relayerAddress + relayerToken.address, // relayerToken + subjectQuantityToFill, // quantityFilled + netMakerToTaker, // makerTokenToTaker + partialFillRelayerFee, // relayerTokenAmountPaid + orderHash, // orderHash core.address ); @@ -431,7 +429,7 @@ contract('CoreIssuanceOrder', accounts => { } }); - expect(transferAddresses).to.not.include(order.relayerAddress); + expect(transferAddresses).to.not.include(issuanceOrder.relayerAddress); }); }); @@ -454,12 +452,12 @@ contract('CoreIssuanceOrder', accounts => { }); it('transfers the fees to the relayer', async () => { - await assertTokenBalanceAsync(relayerToken, ZERO, order.relayerAddress); + await assertTokenBalanceAsync(relayerToken, ZERO, issuanceOrder.relayerAddress); await subject(); - const expectedNewBalance = order.makerRelayerFee.add(order.takerRelayerFee); - await assertTokenBalanceAsync(relayerToken, expectedNewBalance, order.relayerAddress); + const expectedNewBalance = issuanceOrder.makerRelayerFee.add(issuanceOrder.takerRelayerFee); + await assertTokenBalanceAsync(relayerToken, expectedNewBalance, issuanceOrder.relayerAddress); }); }); @@ -527,7 +525,7 @@ contract('CoreIssuanceOrder', accounts => { describe('when the fill size is greater than the order quantity', async () => { beforeEach(async () => { - subjectQuantityToFill = order.quantity.add(1); + subjectQuantityToFill = issuanceOrder.quantity.add(1); }); it('should revert', async () => { @@ -653,17 +651,48 @@ contract('CoreIssuanceOrder', accounts => { }); }); - describe('when the maker token required for the 0x order is more than the signed amount', async () => { - before(async () => { - makerTokenAmountToUseOnZeroExOrderAsFillAmount = ether(11); - issuanceOrderMakerTokenAmount = ether(10); - makerTokenAmountToUseAcrossLiqudityOrders = ether(11); - }); + describe('when the 0x order uses more maker token than the signed amount', async () => { + beforeEach(async () => { - after(async () => { - issuanceOrderMakerTokenAmount = undefined; - makerTokenAmountToUseOnZeroExOrderAsFillAmount = undefined; - makerTokenAmountToUseAcrossLiqudityOrders = undefined; + // We are generating separate orders because we need to manaully update the exchange header to pass + // in an invalid makerTokenAmount. It will be greater than the amount the user signed + const zeroExOrderTakerAssetAmount = issuanceOrder.makerTokenAmount.add(1); + + const invalidZeroExOrder: ZeroExSignedFillOrder = await setUtils.generateZeroExSignedFillOrder( + NULL_ADDRESS, // senderAddress + zeroExOrderMaker, // makerAddress + NULL_ADDRESS, // takerAddress + ZERO, // makerFee + ZERO, // takerFee + issuanceOrderRequiredComponentAmounts[1], // makerAssetAmount + zeroExOrderTakerAssetAmount, // takerAssetAmount + issuanceOrderRequiredComponents[1], // makerAssetAddress + makerToken.address, // takerAssetAddress + SetUtils.generateSalt(), // salt + SetTestUtils.ZERO_EX_EXCHANGE_ADDRESS, // exchangeAddress + NULL_ADDRESS, // feeRecipientAddress + SetTestUtils.generateTimestamp(10000), // expirationTimeSeconds + zeroExOrderTakerAssetAmount, // amount of 0x order to fill + ); + const zeroExOrderBuffer: Buffer = Buffer.concat( + SetTestUtils.zeroExSignedFillOrderToBuffer(invalidZeroExOrder) + ); + + const exchangeHeaderOrderCount = 1; + const exchangeHeaderMakerTokenAmount = zeroExOrderTakerAssetAmount; + const exchangeHeaderTotalOrderBodyLength = zeroExOrderBuffer.length; + const zeroExOrdersExchangeHeader = Buffer.concat( + SetTestUtils.generateExchangeOrderHeader( + SetUtils.EXCHANGES.ZERO_EX, + exchangeHeaderOrderCount, + exchangeHeaderMakerTokenAmount, + exchangeHeaderTotalOrderBodyLength, + ) + ); + + subjectExchangeOrdersData = ethUtil.bufferToHex( + Buffer.concat([zeroExOrdersExchangeHeader, zeroExOrderBuffer]) + ); }); it('should revert', async () => { @@ -704,7 +733,7 @@ contract('CoreIssuanceOrder', accounts => { let setToken: SetTokenContract; let makerToken: StandardTokenMockContract; - let order: IssuanceOrder; + let issuanceOrder: IssuanceOrder; let issuanceOrderQuantity: BigNumber; let issuanceOrderMakerTokenAmount: BigNumber; let issuanceOrderExpiration: BigNumber; @@ -736,7 +765,7 @@ contract('CoreIssuanceOrder', accounts => { const requiredComponentAmounts = _.map(componentUnits, unit => unit.mul(quantity).div(naturalUnit)); // Property: Value | Default | Property - order = { + issuanceOrder = { setAddress: setToken.address, // setAddress makerAddress: issuanceOrderMaker, // makerAddress makerToken: makerToken.address, // makerToken @@ -744,33 +773,33 @@ contract('CoreIssuanceOrder', accounts => { relayerToken: relayerToken.address, // relayerToken quantity: quantity || ether(4), // quantity makerTokenAmount: issuanceOrderMakerTokenAmount || ether(10), // makerTokenAmount - expiration: issuanceOrderExpiration || SetUtils.generateTimestamp(10000), // expiration + expiration: issuanceOrderExpiration || SetTestUtils.generateTimestamp(10000), // expiration makerRelayerFee: issuanceOrderMakerRelayerFee, // makerRelayerFee takerRelayerFee: issuanceOrderTakerRelayerFee, // takerRelayerFee requiredComponents: requiredComponents, // requiredComponents requiredComponentAmounts: requiredComponentAmounts, // requiredComponentAmounts salt: SetUtils.generateSalt(), // salt }; - orderHash = SetUtils.hashOrderHex(order); + orderHash = SetUtils.hashOrderHex(issuanceOrder); subjectAddresses = [ - order.setAddress, - order.makerAddress, - order.makerToken, - order.relayerAddress, - order.relayerToken, + issuanceOrder.setAddress, + issuanceOrder.makerAddress, + issuanceOrder.makerToken, + issuanceOrder.relayerAddress, + issuanceOrder.relayerToken, ]; subjectValues = [ - order.quantity, - order.makerTokenAmount, - order.expiration, - order.makerRelayerFee, - order.takerRelayerFee, - order.salt, + issuanceOrder.quantity, + issuanceOrder.makerTokenAmount, + issuanceOrder.expiration, + issuanceOrder.makerRelayerFee, + issuanceOrder.takerRelayerFee, + issuanceOrder.salt, ]; - subjectRequiredComponents = order.requiredComponents; - subjectRequiredComponentAmounts = order.requiredComponentAmounts; - subjectQuantityToCancel = order.quantity.div(2); + subjectRequiredComponents = issuanceOrder.requiredComponents; + subjectRequiredComponentAmounts = issuanceOrder.requiredComponentAmounts; + subjectQuantityToCancel = issuanceOrder.quantity.div(2); subjectCaller = issuanceOrderMaker; }); @@ -803,7 +832,7 @@ contract('CoreIssuanceOrder', accounts => { setToken.address, issuanceOrderMaker, makerToken.address, - order.relayerAddress, + issuanceOrder.relayerAddress, subjectQuantityToCancel, orderHash, core.address @@ -820,7 +849,7 @@ contract('CoreIssuanceOrder', accounts => { it('should mark only the remaining open amount as canceled', async () => { const filled = await core.orderFills.callAsync(orderHash); const preCanceled = await core.orderCancels.callAsync(orderHash); - const openAmount = order.quantity.minus(filled).minus(preCanceled); + const openAmount = issuanceOrder.quantity.minus(filled).minus(preCanceled); await subject(); diff --git a/test/core/rebalancingSetTokenFactory.spec.ts b/test/core/rebalancingSetTokenFactory.spec.ts index bff1de160..0642cddda 100644 --- a/test/core/rebalancingSetTokenFactory.spec.ts +++ b/test/core/rebalancingSetTokenFactory.spec.ts @@ -111,7 +111,7 @@ contract('RebalancingSetTokenFactory', accounts => { const asciiSubjectSymbol = 'REBAL'; subjectName = SetUtils.stringToBytes(asciiSubjectName); subjectSymbol = SetUtils.stringToBytes(asciiSubjectSymbol); - subjectCallData = SetUtils.bufferArrayToHex([ + subjectCallData = SetTestUtils.bufferArrayToHex([ SetUtils.paddedBufferForPrimitive(managerAddress), SetUtils.paddedBufferForBigNumber(proposalPeriod), SetUtils.paddedBufferForBigNumber(rebalanceInterval), @@ -221,7 +221,7 @@ contract('RebalancingSetTokenFactory', accounts => { const asciiSubjectSymbol = 'REBAL'; subjectName = SetUtils.stringToBytes(asciiSubjectName); subjectSymbol = SetUtils.stringToBytes(asciiSubjectSymbol); - subjectCallData = SetUtils.bufferArrayToHex([ + subjectCallData = SetTestUtils.bufferArrayToHex([ SetUtils.paddedBufferForPrimitive(managerAddress), SetUtils.paddedBufferForBigNumber(proposalPeriod), SetUtils.paddedBufferForBigNumber(rebalanceInterval), diff --git a/utils/RebalancingTokenWrapper.ts b/utils/RebalancingTokenWrapper.ts index f85ea5329..f2a2e2ede 100644 --- a/utils/RebalancingTokenWrapper.ts +++ b/utils/RebalancingTokenWrapper.ts @@ -1,5 +1,5 @@ import * as _ from 'lodash'; -import { SetProtocolUtils, Address } from 'set-protocol-utils'; +import { Address, SetProtocolUtils, SetProtocolTestUtils } from 'set-protocol-utils'; import { CoreContract, @@ -107,7 +107,7 @@ export class RebalancingTokenWrapper { // Generate defualt rebalancingSetToken params const initialUnitShares = DEFAULT_UNIT_SHARES; const rebalanceInterval = ONE_DAY_IN_SECONDS; - const callData = SetProtocolUtils.bufferArrayToHex([ + const callData = SetProtocolTestUtils.bufferArrayToHex([ SetProtocolUtils.paddedBufferForPrimitive(manager), SetProtocolUtils.paddedBufferForBigNumber(proposalPeriod), SetProtocolUtils.paddedBufferForBigNumber(rebalanceInterval), diff --git a/utils/orders.ts b/utils/orders.ts index cefa8a48c..4c5f0fa95 100644 --- a/utils/orders.ts +++ b/utils/orders.ts @@ -3,6 +3,7 @@ import * as ethUtil from 'ethereumjs-util'; import { BigNumber } from 'bignumber.js'; import { SetProtocolUtils, + SetProtocolTestUtils, Address, Bytes, IssuanceOrder @@ -35,7 +36,7 @@ export async function generateFillOrderParameters( relayerToken, quantity, makerTokenAmount, - expiration: SetProtocolUtils.generateTimestamp(timeToExpiration), + expiration: SetProtocolTestUtils.generateTimestamp(timeToExpiration), makerRelayerFee, takerRelayerFee, salt: SetProtocolUtils.generateSalt(), diff --git a/yarn.lock b/yarn.lock index a223abd62..491aa2dae 100644 --- a/yarn.lock +++ b/yarn.lock @@ -4933,9 +4933,9 @@ set-immediate-shim@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz#4b2b1b27eb808a9f8dcc481a58e5e56f599f3f61" -set-protocol-utils@^0.3.33: - version "0.3.33" - resolved "https://registry.yarnpkg.com/set-protocol-utils/-/set-protocol-utils-0.3.33.tgz#0ad41e32ec1ee5b81a7d2e8262ddfb32b55c19fb" +set-protocol-utils@^0.3.37: + version "0.3.37" + resolved "https://registry.yarnpkg.com/set-protocol-utils/-/set-protocol-utils-0.3.37.tgz#4632ff3708dc0c9792a4c63765ac6518c709b790" dependencies: "@0xproject/base-contract" "^1.0.4" "@0xproject/order-utils" "^1.0.1-rc.2"