diff --git a/contracts/test-utils/src/types.ts b/contracts/test-utils/src/types.ts index 12a3a341f1..57b52487ff 100644 --- a/contracts/test-utils/src/types.ts +++ b/contracts/test-utils/src/types.ts @@ -90,7 +90,6 @@ export enum ContractName { DummyERC721Token = 'DummyERC721Token', TestLibBytes = 'TestLibBytes', TestWallet = 'TestWallet', - Authorizable = 'Authorizable', Whitelist = 'Whitelist', Forwarder = 'Forwarder', BalanceThresholdFilter = 'BalanceThresholdFilter', diff --git a/contracts/utils/contracts/src/Authorizable.sol b/contracts/utils/contracts/src/Authorizable.sol deleted file mode 100644 index b4190c53ab..0000000000 --- a/contracts/utils/contracts/src/Authorizable.sol +++ /dev/null @@ -1,122 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -import "./interfaces/IAuthorizable.sol"; -import "./LibAuthorizableRichErrors.sol"; -import "./LibRichErrors.sol"; -import "./Ownable.sol"; - -contract Authorizable is Ownable, IAuthorizable { - /// @dev Only authorized addresses can invoke functions with this modifier. - modifier onlyAuthorized() { - _assertSenderIsAuthorized(); - _; - } - - /// @dev Whether an adderss is authorized to call privileged functions. - /// @param 0 Address to query. - /// @return 0 Whether the address is authorized. - mapping(address => bool) public authorized; - /// @dev Whether an adderss is authorized to call privileged functions. - /// @param 0 Index of authorized address. - /// @return 0 Authorized address. - address[] public authorities; - - /// @dev Initializes the `owner` address. - constructor() public Ownable() {} - - /// @dev Authorizes an address. - /// @param target Address to authorize. - function addAuthorizedAddress(address target) external onlyOwner { - _addAuthorizedAddress(target); - } - - /// @dev Removes authorizion of an address. - /// @param target Address to remove authorization from. - function removeAuthorizedAddress(address target) external onlyOwner { - if (!authorized[target]) { - LibRichErrors.rrevert(LibAuthorizableRichErrors.TargetNotAuthorizedError(target)); - } - for (uint256 i = 0; i < authorities.length; i++) { - if (authorities[i] == target) { - _removeAuthorizedAddressAtIndex(target, i); - break; - } - } - } - - /// @dev Removes authorizion of an address. - /// @param target Address to remove authorization from. - /// @param index Index of target in authorities array. - function removeAuthorizedAddressAtIndex(address target, uint256 index) external onlyOwner { - _removeAuthorizedAddressAtIndex(target, index); - } - - /// @dev Gets all authorized addresses. - /// @return Array of authorized addresses. - function getAuthorizedAddresses() external view returns (address[] memory) { - return authorities; - } - - /// @dev Reverts if msg.sender is not authorized. - function _assertSenderIsAuthorized() internal view { - if (!authorized[msg.sender]) { - LibRichErrors.rrevert(LibAuthorizableRichErrors.SenderNotAuthorizedError(msg.sender)); - } - } - - /// @dev Authorizes an address. - /// @param target Address to authorize. - function _addAuthorizedAddress(address target) internal { - // Ensure that the target is not the zero address. - if (target == address(0)) { - LibRichErrors.rrevert(LibAuthorizableRichErrors.ZeroCantBeAuthorizedError()); - } - - // Ensure that the target is not already authorized. - if (authorized[target]) { - LibRichErrors.rrevert(LibAuthorizableRichErrors.TargetAlreadyAuthorizedError(target)); - } - - authorized[target] = true; - authorities.push(target); - emit AuthorizedAddressAdded(target, msg.sender); - } - - /// @dev Removes authorizion of an address. - /// @param target Address to remove authorization from. - /// @param index Index of target in authorities array. - function _removeAuthorizedAddressAtIndex(address target, uint256 index) internal { - if (!authorized[target]) { - LibRichErrors.rrevert(LibAuthorizableRichErrors.TargetNotAuthorizedError(target)); - } - if (index >= authorities.length) { - LibRichErrors.rrevert(LibAuthorizableRichErrors.IndexOutOfBoundsError(index, authorities.length)); - } - if (authorities[index] != target) { - LibRichErrors.rrevert(LibAuthorizableRichErrors.AuthorizedAddressMismatchError(authorities[index], target)); - } - - delete authorized[target]; - authorities[index] = authorities[authorities.length - 1]; - authorities.length -= 1; - emit AuthorizedAddressRemoved(target, msg.sender); - } -} diff --git a/contracts/utils/contracts/src/D18.sol b/contracts/utils/contracts/src/D18.sol deleted file mode 100644 index ca1ea212fc..0000000000 --- a/contracts/utils/contracts/src/D18.sol +++ /dev/null @@ -1,159 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.16; - -/// @dev A library for working with 18 digit, base 10 decimals. -library D18 { - /// @dev Decimal places for dydx value quantities. - uint256 private constant PRECISION = 18; - /// @dev 1.0 in base-18 decimal. - int256 private constant DECIMAL_ONE = int256(10 ** PRECISION); - /// @dev Minimum signed integer value. - int256 private constant MIN_INT256_VALUE = - int256(0x8000000000000000000000000000000000000000000000000000000000000000); - - /// @dev Return `1.0` - function one() internal pure returns (int256 r) { - r = DECIMAL_ONE; - } - - /// @dev Add two decimals. - function add(int256 a, int256 b) internal pure returns (int256 r) { - r = _add(a, b); - } - - /// @dev Add two decimals. - function add(uint256 a, int256 b) internal pure returns (int256 r) { - require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - r = _add(int256(a), b); - } - - /// @dev Add two decimals. - function add(int256 a, uint256 b) internal pure returns (int256 r) { - require(int256(b) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - r = _add(a, int256(b)); - } - - /// @dev Add two decimals. - function add(uint256 a, uint256 b) internal pure returns (int256 r) { - require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - require(int256(b) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - r = _add(int256(a), int256(b)); - } - - /// @dev Subract two decimals. - function sub(int256 a, int256 b) internal pure returns (int256 r) { - r = _add(a, -b); - } - - /// @dev Subract two decimals. - function sub(uint256 a, int256 b) internal pure returns (int256 r) { - require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - r = _add(int256(a), -b); - } - - /// @dev Subract two decimals. - function sub(uint256 a, uint256 b) internal pure returns (int256 r) { - require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - require(int256(b) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - r = _add(int256(a), -int256(b)); - } - - /// @dev Multiply two decimals. - function mul(int256 a, int256 b) internal pure returns (int256 r) { - r = _div(_mul(a, b), DECIMAL_ONE); - } - - /// @dev Multiply two decimals. - function mul(uint256 a, int256 b) internal pure returns (int256 r) { - require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - r = _div(_mul(int256(a), b), DECIMAL_ONE); - } - - /// @dev Multiply two decimals. - function mul(int256 a, uint256 b) internal pure returns (int256 r) { - require(int256(b) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - r = _div(_mul(a, int256(b)), DECIMAL_ONE); - } - - /// @dev Multiply two decimals. - function mul(uint256 a, uint256 b) internal pure returns (int256 r) { - require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - require(int256(b) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - r = _div(_mul(int256(a), int256(b)), DECIMAL_ONE); - } - - /// @dev Divide two decimals. - function div(int256 a, int256 b) internal pure returns (int256 r) { - r = _div(_mul(a, DECIMAL_ONE), b); - } - - /// @dev Divide two decimals. - function div(uint256 a, int256 b) internal pure returns (int256 r) { - require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - r = _div(_mul(int256(a), DECIMAL_ONE), b); - } - - /// @dev Divide two decimals. - function div(int256 a, uint256 b) internal pure returns (int256 r) { - require(int256(b) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - r = _div(_mul(a, DECIMAL_ONE), int256(b)); - } - - /// @dev Divide two decimals. - function div(uint256 a, uint256 b) internal pure returns (int256 r) { - require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - require(int256(b) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - r = _div(_mul(int256(a), DECIMAL_ONE), int256(b)); - } - - /// @dev Safely convert an unsigned integer into a signed integer. - function toSigned(uint256 a) internal pure returns (int256 r) { - require(int256(a) >= 0, "D18/DECIMAL_VALUE_TOO_BIG"); - r = int256(a); - } - - /// @dev Clip a signed value to be positive. - function clip(int256 a) internal pure returns (int256 r) { - r = a < 0 ? 0 : a; - } - - /// @dev Safely multiply two signed integers. - function _mul(int256 a, int256 b) private pure returns (int256 r) { - if (a == 0 || b == 0) { - return 0; - } - r = a * b; - require(r / a == b && r / b == a, "D18/DECIMAL_MUL_OVERFLOW"); - return r; - } - - /// @dev Safely divide two signed integers. - function _div(int256 a, int256 b) private pure returns (int256 r) { - require(b != 0, "D18/DECIMAL_DIV_BY_ZERO"); - require(a != MIN_INT256_VALUE || b != -1, "D18/DECIMAL_DIV_OVERFLOW"); - r = a / b; - } - - /// @dev Safely add two signed integers. - function _add(int256 a, int256 b) private pure returns (int256 r) { - r = a + b; - require(!((a < 0 && b < 0 && r > a) || (a > 0 && b > 0 && r < a)), "D18/DECIMAL_ADD_OVERFLOW"); - } -} diff --git a/contracts/utils/contracts/src/DeploymentConstants.sol b/contracts/utils/contracts/src/DeploymentConstants.sol deleted file mode 100644 index eeb5847463..0000000000 --- a/contracts/utils/contracts/src/DeploymentConstants.sol +++ /dev/null @@ -1,251 +0,0 @@ -/* - - Copyright 2020 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -contract DeploymentConstants { - // Mainnet addresses /////////////////////////////////////////////////////// - /// @dev Mainnet address of the WETH contract. - address private constant WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; - /// @dev Mainnet address of the KyberNetworkProxy contract. - address private constant KYBER_NETWORK_PROXY_ADDRESS = 0x9AAb3f75489902f3a48495025729a0AF77d4b11e; - /// @dev Mainnet address of the KyberHintHandler contract. - address private constant KYBER_HINT_HANDLER_ADDRESS = 0xa1C0Fa73c39CFBcC11ec9Eb1Afc665aba9996E2C; - /// @dev Mainnet address of the `UniswapExchangeFactory` contract. - address private constant UNISWAP_EXCHANGE_FACTORY_ADDRESS = 0xc0a47dFe034B400B47bDaD5FecDa2621de6c4d95; - /// @dev Mainnet address of the `UniswapV2Router01` contract. - address private constant UNISWAP_V2_ROUTER_01_ADDRESS = 0xf164fC0Ec4E93095b804a4795bBe1e041497b92a; - /// @dev Mainnet address of the Eth2Dai `MatchingMarket` contract. - address private constant ETH2DAI_ADDRESS = 0x794e6e91555438aFc3ccF1c5076A74F42133d08D; - /// @dev Mainnet address of the `ERC20BridgeProxy` contract - address private constant ERC20_BRIDGE_PROXY_ADDRESS = 0x8ED95d1746bf1E4dAb58d8ED4724f1Ef95B20Db0; - ///@dev Mainnet address of the `Dai` (multi-collateral) contract - address private constant DAI_ADDRESS = 0x6B175474E89094C44Da98b954EedeAC495271d0F; - /// @dev Mainnet address of the `Chai` contract - address private constant CHAI_ADDRESS = 0x06AF07097C9Eeb7fD685c692751D5C66dB49c215; - /// @dev Mainnet address of the 0x DevUtils contract. - address private constant DEV_UTILS_ADDRESS = 0x74134CF88b21383713E096a5ecF59e297dc7f547; - /// @dev Kyber ETH pseudo-address. - address internal constant KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; - /// @dev Mainnet address of the dYdX contract. - address private constant DYDX_ADDRESS = 0x1E0447b19BB6EcFdAe1e4AE1694b0C3659614e4e; - /// @dev Mainnet address of the GST2 contract - address private constant GST_ADDRESS = 0x0000000000b3F879cb30FE243b4Dfee438691c04; - /// @dev Mainnet address of the GST Collector - address private constant GST_COLLECTOR_ADDRESS = 0x000000D3b08566BE75A6DB803C03C85C0c1c5B96; - /// @dev Mainnet address of the mStable mUSD contract. - address private constant MUSD_ADDRESS = 0xe2f2a5C287993345a840Db3B0845fbC70f5935a5; - /// @dev Mainnet address of the Mooniswap Registry contract - address private constant MOONISWAP_REGISTRY = 0x71CD6666064C3A1354a3B4dca5fA1E2D3ee7D303; - /// @dev Mainnet address of the DODO Registry (ZOO) contract - address private constant DODO_REGISTRY = 0x3A97247DF274a17C59A3bd12735ea3FcDFb49950; - /// @dev Mainnet address of the DODO Helper contract - address private constant DODO_HELPER = 0x533dA777aeDCE766CEAe696bf90f8541A4bA80Eb; - - // // Ropsten addresses /////////////////////////////////////////////////////// - /// @dev Mainnet address of the WETH contract. - // address constant private WETH_ADDRESS = 0xc778417E063141139Fce010982780140Aa0cD5Ab; - /// @dev Mainnet address of the KyberNetworkProxy contract. - // address constant private KYBER_NETWORK_PROXY_ADDRESS = 0xd719c34261e099Fdb33030ac8909d5788D3039C4; - /// @dev Mainnet address of the `UniswapExchangeFactory` contract. - // address constant private UNISWAP_EXCHANGE_FACTORY_ADDRESS = 0x9c83dCE8CA20E9aAF9D3efc003b2ea62aBC08351; - /// @dev Mainnet address of the `UniswapV2Router01` contract. - // address constant private UNISWAP_V2_ROUTER_01_ADDRESS = 0xf164fC0Ec4E93095b804a4795bBe1e041497b92a; - /// @dev Mainnet address of the Eth2Dai `MatchingMarket` contract. - // address constant private ETH2DAI_ADDRESS = address(0); - /// @dev Mainnet address of the `ERC20BridgeProxy` contract - // address constant private ERC20_BRIDGE_PROXY_ADDRESS = 0xb344afeD348de15eb4a9e180205A2B0739628339; - // ///@dev Mainnet address of the `Dai` (multi-collateral) contract - // address constant private DAI_ADDRESS = address(0); - /// @dev Mainnet address of the `Chai` contract - // address constant private CHAI_ADDRESS = address(0); - /// @dev Mainnet address of the 0x DevUtils contract. - // address constant private DEV_UTILS_ADDRESS = 0xC812AF3f3fBC62F76ea4262576EC0f49dB8B7f1c; - /// @dev Kyber ETH pseudo-address. - // address constant internal KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; - /// @dev Mainnet address of the dYdX contract. - // address constant private DYDX_ADDRESS = address(0); - /// @dev Mainnet address of the GST2 contract - // address constant private GST_ADDRESS = address(0); - /// @dev Mainnet address of the GST Collector - // address constant private GST_COLLECTOR_ADDRESS = address(0); - /// @dev Mainnet address of the mStable mUSD contract. - // address constant private MUSD_ADDRESS = 0x4E1000616990D83e56f4b5fC6CC8602DcfD20459; - - // // Rinkeby addresses /////////////////////////////////////////////////////// - /// @dev Mainnet address of the WETH contract. - // address constant private WETH_ADDRESS = 0xc778417E063141139Fce010982780140Aa0cD5Ab; - /// @dev Mainnet address of the KyberNetworkProxy contract. - // address constant private KYBER_NETWORK_PROXY_ADDRESS = 0x0d5371e5EE23dec7DF251A8957279629aa79E9C5; - /// @dev Mainnet address of the `UniswapExchangeFactory` contract. - // address constant private UNISWAP_EXCHANGE_FACTORY_ADDRESS = 0xf5D915570BC477f9B8D6C0E980aA81757A3AaC36; - /// @dev Mainnet address of the `UniswapV2Router01` contract. - // address constant private UNISWAP_V2_ROUTER_01_ADDRESS = 0xf164fC0Ec4E93095b804a4795bBe1e041497b92a; - /// @dev Mainnet address of the Eth2Dai `MatchingMarket` contract. - // address constant private ETH2DAI_ADDRESS = address(0); - /// @dev Mainnet address of the `ERC20BridgeProxy` contract - // address constant private ERC20_BRIDGE_PROXY_ADDRESS = 0xA2AA4bEFED748Fba27a3bE7Dfd2C4b2c6DB1F49B; - // ///@dev Mainnet address of the `Dai` (multi-collateral) contract - // address constant private DAI_ADDRESS = address(0); - /// @dev Mainnet address of the `Chai` contract - // address constant private CHAI_ADDRESS = address(0); - /// @dev Mainnet address of the 0x DevUtils contract. - // address constant private DEV_UTILS_ADDRESS = 0x46B5BC959e8A754c0256FFF73bF34A52Ad5CdfA9; - /// @dev Kyber ETH pseudo-address. - // address constant internal KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; - /// @dev Mainnet address of the dYdX contract. - // address constant private DYDX_ADDRESS = address(0); - /// @dev Mainnet address of the GST2 contract - // address constant private GST_ADDRESS = address(0); - /// @dev Mainnet address of the GST Collector - // address constant private GST_COLLECTOR_ADDRESS = address(0); - /// @dev Mainnet address of the mStable mUSD contract. - // address constant private MUSD_ADDRESS = address(0); - - // // Kovan addresses ///////////////////////////////////////////////////////// - /// @dev Kovan address of the WETH contract. - // address constant private WETH_ADDRESS = 0xd0A1E359811322d97991E03f863a0C30C2cF029C; - /// @dev Kovan address of the KyberNetworkProxy contract. - // address constant private KYBER_NETWORK_PROXY_ADDRESS = 0x692f391bCc85cefCe8C237C01e1f636BbD70EA4D; - /// @dev Kovan address of the `UniswapExchangeFactory` contract. - // address constant private UNISWAP_EXCHANGE_FACTORY_ADDRESS = 0xD3E51Ef092B2845f10401a0159B2B96e8B6c3D30; - /// @dev Kovan address of the `UniswapV2Router01` contract. - // address constant private UNISWAP_V2_ROUTER_01_ADDRESS = 0xf164fC0Ec4E93095b804a4795bBe1e041497b92a; - /// @dev Kovan address of the Eth2Dai `MatchingMarket` contract. - // address constant private ETH2DAI_ADDRESS = 0xe325acB9765b02b8b418199bf9650972299235F4; - /// @dev Kovan address of the `ERC20BridgeProxy` contract - // address constant private ERC20_BRIDGE_PROXY_ADDRESS = 0x3577552C1Fb7A44aD76BeEB7aB53251668A21F8D; - /// @dev Kovan address of the `Chai` contract - // address constant private CHAI_ADDRESS = address(0); - /// @dev Kovan address of the `Dai` (multi-collateral) contract - // address constant private DAI_ADDRESS = 0x4F96Fe3b7A6Cf9725f59d353F723c1bDb64CA6Aa; - /// @dev Kovan address of the 0x DevUtils contract. - // address constant private DEV_UTILS_ADDRESS = 0x9402639A828BdF4E9e4103ac3B69E1a6E522eB59; - /// @dev Kyber ETH pseudo-address. - // address constant internal KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; - /// @dev Kovan address of the dYdX contract. - // address constant private DYDX_ADDRESS = address(0); - /// @dev Kovan address of the GST2 contract - // address constant private GST_ADDRESS = address(0); - /// @dev Kovan address of the GST Collector - // address constant private GST_COLLECTOR_ADDRESS = address(0); - /// @dev Mainnet address of the mStable mUSD contract. - // address constant private MUSD_ADDRESS = address(0); - - /// @dev Overridable way to get the `KyberNetworkProxy` address. - /// @return kyberAddress The `IKyberNetworkProxy` address. - function _getKyberNetworkProxyAddress() internal view returns (address kyberAddress) { - return KYBER_NETWORK_PROXY_ADDRESS; - } - - /// @dev Overridable way to get the `KyberHintHandler` address. - /// @return kyberAddress The `IKyberHintHandler` address. - function _getKyberHintHandlerAddress() internal view returns (address hintHandlerAddress) { - return KYBER_HINT_HANDLER_ADDRESS; - } - - /// @dev Overridable way to get the WETH address. - /// @return wethAddress The WETH address. - function _getWethAddress() internal view returns (address wethAddress) { - return WETH_ADDRESS; - } - - /// @dev Overridable way to get the `UniswapExchangeFactory` address. - /// @return uniswapAddress The `UniswapExchangeFactory` address. - function _getUniswapExchangeFactoryAddress() internal view returns (address uniswapAddress) { - return UNISWAP_EXCHANGE_FACTORY_ADDRESS; - } - - /// @dev Overridable way to get the `UniswapV2Router01` address. - /// @return uniswapRouterAddress The `UniswapV2Router01` address. - function _getUniswapV2Router01Address() internal view returns (address uniswapRouterAddress) { - return UNISWAP_V2_ROUTER_01_ADDRESS; - } - - /// @dev An overridable way to retrieve the Eth2Dai `MatchingMarket` contract. - /// @return eth2daiAddress The Eth2Dai `MatchingMarket` contract. - function _getEth2DaiAddress() internal view returns (address eth2daiAddress) { - return ETH2DAI_ADDRESS; - } - - /// @dev An overridable way to retrieve the `ERC20BridgeProxy` contract. - /// @return erc20BridgeProxyAddress The `ERC20BridgeProxy` contract. - function _getERC20BridgeProxyAddress() internal view returns (address erc20BridgeProxyAddress) { - return ERC20_BRIDGE_PROXY_ADDRESS; - } - - /// @dev An overridable way to retrieve the `Dai` contract. - /// @return daiAddress The `Dai` contract. - function _getDaiAddress() internal view returns (address daiAddress) { - return DAI_ADDRESS; - } - - /// @dev An overridable way to retrieve the `Chai` contract. - /// @return chaiAddress The `Chai` contract. - function _getChaiAddress() internal view returns (address chaiAddress) { - return CHAI_ADDRESS; - } - - /// @dev An overridable way to retrieve the 0x `DevUtils` contract address. - /// @return devUtils The 0x `DevUtils` contract address. - function _getDevUtilsAddress() internal view returns (address devUtils) { - return DEV_UTILS_ADDRESS; - } - - /// @dev Overridable way to get the DyDx contract. - /// @return exchange The DyDx exchange contract. - function _getDydxAddress() internal view returns (address dydxAddress) { - return DYDX_ADDRESS; - } - - /// @dev An overridable way to retrieve the GST2 contract address. - /// @return gst The GST contract. - function _getGstAddress() internal view returns (address gst) { - return GST_ADDRESS; - } - - /// @dev An overridable way to retrieve the GST Collector address. - /// @return collector The GST collector address. - function _getGstCollectorAddress() internal view returns (address collector) { - return GST_COLLECTOR_ADDRESS; - } - - /// @dev An overridable way to retrieve the mStable mUSD address. - /// @return musd The mStable mUSD address. - function _getMUsdAddress() internal view returns (address musd) { - return MUSD_ADDRESS; - } - - /// @dev An overridable way to retrieve the Mooniswap registry address. - /// @return registry The Mooniswap registry address. - function _getMooniswapAddress() internal view returns (address) { - return MOONISWAP_REGISTRY; - } - - /// @dev An overridable way to retrieve the DODO Registry contract address. - /// @return registry The DODO Registry contract address. - function _getDODORegistryAddress() internal view returns (address) { - return DODO_REGISTRY; - } - - /// @dev An overridable way to retrieve the DODO Helper contract address. - /// @return registry The DODO Helper contract address. - function _getDODOHelperAddress() internal view returns (address) { - return DODO_HELPER; - } -} diff --git a/contracts/utils/contracts/src/LibAddress.sol b/contracts/utils/contracts/src/LibAddress.sol deleted file mode 100644 index cacaaed1e2..0000000000 --- a/contracts/utils/contracts/src/LibAddress.sol +++ /dev/null @@ -1,46 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -/** - * Utility library of inline functions on addresses - */ -library LibAddress { - /** - * Returns whether the target address is a contract - * @dev This function will return false if invoked during the constructor of a contract, - * as the code is not actually created until after the constructor finishes. - * @param account address of the account to check - * @return whether the target address is a contract - */ - function isContract(address account) internal view returns (bool) { - uint256 size; - // XXX Currently there is no better way to check if there is a contract in an address - // than to check the size of the code at that address. - // See https://ethereum.stackexchange.com/a/14016/36603 - // for more details about how this works. - // TODO Check this again before the Serenity release, because all addresses will be - // contracts then. - // solium-disable-next-line security/no-inline-assembly - assembly { - size := extcodesize(account) - } - return size > 0; - } -} diff --git a/contracts/utils/contracts/src/LibAddressArray.sol b/contracts/utils/contracts/src/LibAddressArray.sol deleted file mode 100644 index 4b2060bb2a..0000000000 --- a/contracts/utils/contracts/src/LibAddressArray.sol +++ /dev/null @@ -1,153 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -import "./LibAddressArrayRichErrors.sol"; -import "./LibBytes.sol"; -import "./LibRichErrors.sol"; - -library LibAddressArray { - /// @dev Append a new address to an array of addresses. - /// The `addressArray` may need to be reallocated to make space - /// for the new address. Because of this we return the resulting - /// memory location of `addressArray`. - /// @param addressArray Array of addresses. - /// @param addressToAppend Address to append. - /// @return Array of addresses: [... addressArray, addressToAppend] - function append(address[] memory addressArray, address addressToAppend) internal pure returns (address[] memory) { - // Get stats on address array and free memory - uint256 freeMemPtr = 0; - uint256 addressArrayBeginPtr = 0; - uint256 addressArrayEndPtr = 0; - uint256 addressArrayLength = addressArray.length; - uint256 addressArrayMemSizeInBytes = 32 + (32 * addressArrayLength); - assembly { - freeMemPtr := mload(0x40) - addressArrayBeginPtr := addressArray - addressArrayEndPtr := add(addressArray, addressArrayMemSizeInBytes) - } - - // Cases for `freeMemPtr`: - // `freeMemPtr` == `addressArrayEndPtr`: Nothing occupies memory after `addressArray` - // `freeMemPtr` > `addressArrayEndPtr`: Some value occupies memory after `addressArray` - // `freeMemPtr` < `addressArrayEndPtr`: Memory has not been managed properly. - if (freeMemPtr < addressArrayEndPtr) { - LibRichErrors.rrevert(LibAddressArrayRichErrors.MismanagedMemoryError(freeMemPtr, addressArrayEndPtr)); - } - - // If free memory begins at the end of `addressArray` - // then we can append `addressToAppend` directly. - // Otherwise, we must copy the array to free memory - // before appending new values to it. - if (freeMemPtr > addressArrayEndPtr) { - LibBytes.memCopy(freeMemPtr, addressArrayBeginPtr, addressArrayMemSizeInBytes); - assembly { - addressArray := freeMemPtr - addressArrayBeginPtr := addressArray - } - } - - // Append `addressToAppend` - addressArrayLength += 1; - addressArrayMemSizeInBytes += 32; - addressArrayEndPtr = addressArrayBeginPtr + addressArrayMemSizeInBytes; - freeMemPtr = addressArrayEndPtr; - assembly { - // Store new array length - mstore(addressArray, addressArrayLength) - - // Update `freeMemPtr` - mstore(0x40, freeMemPtr) - } - addressArray[addressArrayLength - 1] = addressToAppend; - return addressArray; - } - - /// @dev Checks if an address array contains the target address. - /// @param addressArray Array of addresses. - /// @param target Address to search for in array. - /// @return True if the addressArray contains the target. - function contains(address[] memory addressArray, address target) internal pure returns (bool success) { - assembly { - // Calculate byte length of array - let arrayByteLen := mul(mload(addressArray), 32) - // Calculate beginning of array contents - let arrayContentsStart := add(addressArray, 32) - // Calclulate end of array contents - let arrayContentsEnd := add(arrayContentsStart, arrayByteLen) - - // Loop through array - for { - let i := arrayContentsStart - } lt(i, arrayContentsEnd) { - i := add(i, 32) - } { - // Load array element - let arrayElement := mload(i) - - // Return true if array element equals target - if eq(target, arrayElement) { - // Set success to true - success := 1 - // Break loop - i := arrayContentsEnd - } - } - } - return success; - } - - /// @dev Finds the index of an address within an array. - /// @param addressArray Array of addresses. - /// @param target Address to search for in array. - /// @return Existence and index of the target in the array. - function indexOf( - address[] memory addressArray, - address target - ) internal pure returns (bool success, uint256 index) { - assembly { - // Calculate byte length of array - let arrayByteLen := mul(mload(addressArray), 32) - // Calculate beginning of array contents - let arrayContentsStart := add(addressArray, 32) - // Calclulate end of array contents - let arrayContentsEnd := add(arrayContentsStart, arrayByteLen) - - // Loop through array - for { - let i := arrayContentsStart - } lt(i, arrayContentsEnd) { - i := add(i, 32) - } { - // Load array element - let arrayElement := mload(i) - - // Return true if array element equals target - if eq(target, arrayElement) { - // Set success and index - success := 1 - index := div(sub(i, arrayContentsStart), 32) - // Break loop - i := arrayContentsEnd - } - } - } - return (success, index); - } -} diff --git a/contracts/utils/contracts/src/LibAddressArrayRichErrors.sol b/contracts/utils/contracts/src/LibAddressArrayRichErrors.sol deleted file mode 100644 index 49684911f9..0000000000 --- a/contracts/utils/contracts/src/LibAddressArrayRichErrors.sol +++ /dev/null @@ -1,31 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -library LibAddressArrayRichErrors { - // bytes4(keccak256("MismanagedMemoryError(uint256,uint256)")) - bytes4 internal constant MISMANAGED_MEMORY_ERROR_SELECTOR = 0x5fc83722; - - function MismanagedMemoryError( - uint256 freeMemPtr, - uint256 addressArrayEndPtr - ) internal pure returns (bytes memory) { - return abi.encodeWithSelector(MISMANAGED_MEMORY_ERROR_SELECTOR, freeMemPtr, addressArrayEndPtr); - } -} diff --git a/contracts/utils/contracts/src/LibAuthorizableRichErrors.sol b/contracts/utils/contracts/src/LibAuthorizableRichErrors.sol deleted file mode 100644 index 9a6b1a7a50..0000000000 --- a/contracts/utils/contracts/src/LibAuthorizableRichErrors.sol +++ /dev/null @@ -1,63 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -library LibAuthorizableRichErrors { - // bytes4(keccak256("AuthorizedAddressMismatchError(address,address)")) - bytes4 internal constant AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR = 0x140a84db; - - // bytes4(keccak256("IndexOutOfBoundsError(uint256,uint256)")) - bytes4 internal constant INDEX_OUT_OF_BOUNDS_ERROR_SELECTOR = 0xe9f83771; - - // bytes4(keccak256("SenderNotAuthorizedError(address)")) - bytes4 internal constant SENDER_NOT_AUTHORIZED_ERROR_SELECTOR = 0xb65a25b9; - - // bytes4(keccak256("TargetAlreadyAuthorizedError(address)")) - bytes4 internal constant TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR = 0xde16f1a0; - - // bytes4(keccak256("TargetNotAuthorizedError(address)")) - bytes4 internal constant TARGET_NOT_AUTHORIZED_ERROR_SELECTOR = 0xeb5108a2; - - // bytes4(keccak256("ZeroCantBeAuthorizedError()")) - bytes internal constant ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES = hex"57654fe4"; - - function AuthorizedAddressMismatchError(address authorized, address target) internal pure returns (bytes memory) { - return abi.encodeWithSelector(AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR, authorized, target); - } - - function IndexOutOfBoundsError(uint256 index, uint256 length) internal pure returns (bytes memory) { - return abi.encodeWithSelector(INDEX_OUT_OF_BOUNDS_ERROR_SELECTOR, index, length); - } - - function SenderNotAuthorizedError(address sender) internal pure returns (bytes memory) { - return abi.encodeWithSelector(SENDER_NOT_AUTHORIZED_ERROR_SELECTOR, sender); - } - - function TargetAlreadyAuthorizedError(address target) internal pure returns (bytes memory) { - return abi.encodeWithSelector(TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR, target); - } - - function TargetNotAuthorizedError(address target) internal pure returns (bytes memory) { - return abi.encodeWithSelector(TARGET_NOT_AUTHORIZED_ERROR_SELECTOR, target); - } - - function ZeroCantBeAuthorizedError() internal pure returns (bytes memory) { - return ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES; - } -} diff --git a/contracts/utils/contracts/src/LibEIP1271.sol b/contracts/utils/contracts/src/LibEIP1271.sol deleted file mode 100644 index c4da2cf26f..0000000000 --- a/contracts/utils/contracts/src/LibEIP1271.sol +++ /dev/null @@ -1,25 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -contract LibEIP1271 { - /// @dev Magic bytes returned by EIP1271 wallets on success. - /// @return 0 Magic bytes. - bytes4 public constant EIP1271_MAGIC_VALUE = 0x20c13b0b; -} diff --git a/contracts/utils/contracts/src/LibEIP712.sol b/contracts/utils/contracts/src/LibEIP712.sol deleted file mode 100644 index 656eb90ec1..0000000000 --- a/contracts/utils/contracts/src/LibEIP712.sol +++ /dev/null @@ -1,103 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -library LibEIP712 { - // Hash of the EIP712 Domain Separator Schema - // keccak256(abi.encodePacked( - // "EIP712Domain(", - // "string name,", - // "string version,", - // "uint256 chainId,", - // "address verifyingContract", - // ")" - // )) - bytes32 internal constant _EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH = - 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f; - - /// @dev Calculates a EIP712 domain separator. - /// @param name The EIP712 domain name. - /// @param version The EIP712 domain version. - /// @param verifyingContract The EIP712 verifying contract. - /// @return EIP712 domain separator. - function hashEIP712Domain( - string memory name, - string memory version, - uint256 chainId, - address verifyingContract - ) internal pure returns (bytes32 result) { - bytes32 schemaHash = _EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH; - - // Assembly for more efficient computing: - // keccak256(abi.encodePacked( - // _EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH, - // keccak256(bytes(name)), - // keccak256(bytes(version)), - // chainId, - // uint256(verifyingContract) - // )) - - assembly { - // Calculate hashes of dynamic data - let nameHash := keccak256(add(name, 32), mload(name)) - let versionHash := keccak256(add(version, 32), mload(version)) - - // Load free memory pointer - let memPtr := mload(64) - - // Store params in memory - mstore(memPtr, schemaHash) - mstore(add(memPtr, 32), nameHash) - mstore(add(memPtr, 64), versionHash) - mstore(add(memPtr, 96), chainId) - mstore(add(memPtr, 128), verifyingContract) - - // Compute hash - result := keccak256(memPtr, 160) - } - return result; - } - - /// @dev Calculates EIP712 encoding for a hash struct with a given domain hash. - /// @param eip712DomainHash Hash of the domain domain separator data, computed - /// with getDomainHash(). - /// @param hashStruct The EIP712 hash struct. - /// @return EIP712 hash applied to the given EIP712 Domain. - function hashEIP712Message(bytes32 eip712DomainHash, bytes32 hashStruct) internal pure returns (bytes32 result) { - // Assembly for more efficient computing: - // keccak256(abi.encodePacked( - // EIP191_HEADER, - // EIP712_DOMAIN_HASH, - // hashStruct - // )); - - assembly { - // Load free memory pointer - let memPtr := mload(64) - - mstore(memPtr, 0x1901000000000000000000000000000000000000000000000000000000000000) // EIP191 header - mstore(add(memPtr, 2), eip712DomainHash) // EIP712 domain hash - mstore(add(memPtr, 34), hashStruct) // Hash of struct - - // Compute hash - result := keccak256(memPtr, 66) - } - return result; - } -} diff --git a/contracts/utils/contracts/src/LibFractions.sol b/contracts/utils/contracts/src/LibFractions.sol deleted file mode 100644 index 1309110948..0000000000 --- a/contracts/utils/contracts/src/LibFractions.sol +++ /dev/null @@ -1,96 +0,0 @@ -pragma solidity ^0.5.9; - -import "./LibSafeMath.sol"; - -library LibFractions { - using LibSafeMath for uint256; - - /// @dev Safely adds two fractions `n1/d1 + n2/d2` - /// @param n1 numerator of `1` - /// @param d1 denominator of `1` - /// @param n2 numerator of `2` - /// @param d2 denominator of `2` - /// @return numerator Numerator of sum - /// @return denominator Denominator of sum - function add( - uint256 n1, - uint256 d1, - uint256 n2, - uint256 d2 - ) internal pure returns (uint256 numerator, uint256 denominator) { - if (n1 == 0) { - return (numerator = n2, denominator = d2); - } - if (n2 == 0) { - return (numerator = n1, denominator = d1); - } - numerator = n1.safeMul(d2).safeAdd(n2.safeMul(d1)); - denominator = d1.safeMul(d2); - return (numerator, denominator); - } - - /// @dev Rescales a fraction to prevent overflows during addition if either - /// the numerator or the denominator are > `maxValue`. - /// @param numerator The numerator. - /// @param denominator The denominator. - /// @param maxValue The maximum value allowed for both the numerator and - /// denominator. - /// @return scaledNumerator The rescaled numerator. - /// @return scaledDenominator The rescaled denominator. - function normalize( - uint256 numerator, - uint256 denominator, - uint256 maxValue - ) internal pure returns (uint256 scaledNumerator, uint256 scaledDenominator) { - // If either the numerator or the denominator are > `maxValue`, - // re-scale them by `maxValue` to prevent overflows in future operations. - if (numerator > maxValue || denominator > maxValue) { - uint256 rescaleBase = numerator >= denominator ? numerator : denominator; - rescaleBase = rescaleBase.safeDiv(maxValue); - scaledNumerator = numerator.safeDiv(rescaleBase); - scaledDenominator = denominator.safeDiv(rescaleBase); - } else { - scaledNumerator = numerator; - scaledDenominator = denominator; - } - return (scaledNumerator, scaledDenominator); - } - - /// @dev Rescales a fraction to prevent overflows during addition if either - /// the numerator or the denominator are > 2 ** 127. - /// @param numerator The numerator. - /// @param denominator The denominator. - /// @return scaledNumerator The rescaled numerator. - /// @return scaledDenominator The rescaled denominator. - function normalize( - uint256 numerator, - uint256 denominator - ) internal pure returns (uint256 scaledNumerator, uint256 scaledDenominator) { - return normalize(numerator, denominator, 2 ** 127); - } - - /// @dev Safely scales the difference between two fractions. - /// @param n1 numerator of `1` - /// @param d1 denominator of `1` - /// @param n2 numerator of `2` - /// @param d2 denominator of `2` - /// @param s scalar to multiply by difference. - /// @return result `s * (n1/d1 - n2/d2)`. - function scaleDifference( - uint256 n1, - uint256 d1, - uint256 n2, - uint256 d2, - uint256 s - ) internal pure returns (uint256 result) { - if (s == 0) { - return 0; - } - if (n2 == 0) { - return result = s.safeMul(n1).safeDiv(d1); - } - uint256 numerator = n1.safeMul(d2).safeSub(n2.safeMul(d1)); - uint256 tmp = numerator.safeDiv(d2); - return s.safeMul(tmp).safeDiv(d1); - } -} diff --git a/contracts/utils/contracts/src/LibMath.sol b/contracts/utils/contracts/src/LibMath.sol deleted file mode 100644 index 797508be35..0000000000 --- a/contracts/utils/contracts/src/LibMath.sol +++ /dev/null @@ -1,174 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -import "./LibSafeMath.sol"; -import "./LibRichErrors.sol"; -import "./LibMathRichErrors.sol"; - -library LibMath { - using LibSafeMath for uint256; - - /// @dev Calculates partial value given a numerator and denominator rounded down. - /// Reverts if rounding error is >= 0.1% - /// @param numerator Numerator. - /// @param denominator Denominator. - /// @param target Value to calculate partial of. - /// @return Partial value of target rounded down. - function safeGetPartialAmountFloor( - uint256 numerator, - uint256 denominator, - uint256 target - ) internal pure returns (uint256 partialAmount) { - if (isRoundingErrorFloor(numerator, denominator, target)) { - LibRichErrors.rrevert(LibMathRichErrors.RoundingError(numerator, denominator, target)); - } - - partialAmount = numerator.safeMul(target).safeDiv(denominator); - return partialAmount; - } - - /// @dev Calculates partial value given a numerator and denominator rounded down. - /// Reverts if rounding error is >= 0.1% - /// @param numerator Numerator. - /// @param denominator Denominator. - /// @param target Value to calculate partial of. - /// @return Partial value of target rounded up. - function safeGetPartialAmountCeil( - uint256 numerator, - uint256 denominator, - uint256 target - ) internal pure returns (uint256 partialAmount) { - if (isRoundingErrorCeil(numerator, denominator, target)) { - LibRichErrors.rrevert(LibMathRichErrors.RoundingError(numerator, denominator, target)); - } - - // safeDiv computes `floor(a / b)`. We use the identity (a, b integer): - // ceil(a / b) = floor((a + b - 1) / b) - // To implement `ceil(a / b)` using safeDiv. - partialAmount = numerator.safeMul(target).safeAdd(denominator.safeSub(1)).safeDiv(denominator); - - return partialAmount; - } - - /// @dev Calculates partial value given a numerator and denominator rounded down. - /// @param numerator Numerator. - /// @param denominator Denominator. - /// @param target Value to calculate partial of. - /// @return Partial value of target rounded down. - function getPartialAmountFloor( - uint256 numerator, - uint256 denominator, - uint256 target - ) internal pure returns (uint256 partialAmount) { - partialAmount = numerator.safeMul(target).safeDiv(denominator); - return partialAmount; - } - - /// @dev Calculates partial value given a numerator and denominator rounded down. - /// @param numerator Numerator. - /// @param denominator Denominator. - /// @param target Value to calculate partial of. - /// @return Partial value of target rounded up. - function getPartialAmountCeil( - uint256 numerator, - uint256 denominator, - uint256 target - ) internal pure returns (uint256 partialAmount) { - // safeDiv computes `floor(a / b)`. We use the identity (a, b integer): - // ceil(a / b) = floor((a + b - 1) / b) - // To implement `ceil(a / b)` using safeDiv. - partialAmount = numerator.safeMul(target).safeAdd(denominator.safeSub(1)).safeDiv(denominator); - - return partialAmount; - } - - /// @dev Checks if rounding error >= 0.1% when rounding down. - /// @param numerator Numerator. - /// @param denominator Denominator. - /// @param target Value to multiply with numerator/denominator. - /// @return Rounding error is present. - function isRoundingErrorFloor( - uint256 numerator, - uint256 denominator, - uint256 target - ) internal pure returns (bool isError) { - if (denominator == 0) { - LibRichErrors.rrevert(LibMathRichErrors.DivisionByZeroError()); - } - - // The absolute rounding error is the difference between the rounded - // value and the ideal value. The relative rounding error is the - // absolute rounding error divided by the absolute value of the - // ideal value. This is undefined when the ideal value is zero. - // - // The ideal value is `numerator * target / denominator`. - // Let's call `numerator * target % denominator` the remainder. - // The absolute error is `remainder / denominator`. - // - // When the ideal value is zero, we require the absolute error to - // be zero. Fortunately, this is always the case. The ideal value is - // zero iff `numerator == 0` and/or `target == 0`. In this case the - // remainder and absolute error are also zero. - if (target == 0 || numerator == 0) { - return false; - } - - // Otherwise, we want the relative rounding error to be strictly - // less than 0.1%. - // The relative error is `remainder / (numerator * target)`. - // We want the relative error less than 1 / 1000: - // remainder / (numerator * denominator) < 1 / 1000 - // or equivalently: - // 1000 * remainder < numerator * target - // so we have a rounding error iff: - // 1000 * remainder >= numerator * target - uint256 remainder = mulmod(target, numerator, denominator); - isError = remainder.safeMul(1000) >= numerator.safeMul(target); - return isError; - } - - /// @dev Checks if rounding error >= 0.1% when rounding up. - /// @param numerator Numerator. - /// @param denominator Denominator. - /// @param target Value to multiply with numerator/denominator. - /// @return Rounding error is present. - function isRoundingErrorCeil( - uint256 numerator, - uint256 denominator, - uint256 target - ) internal pure returns (bool isError) { - if (denominator == 0) { - LibRichErrors.rrevert(LibMathRichErrors.DivisionByZeroError()); - } - - // See the comments in `isRoundingError`. - if (target == 0 || numerator == 0) { - // When either is zero, the ideal value and rounded value are zero - // and there is no rounding error. (Although the relative error - // is undefined.) - return false; - } - // Compute remainder as before - uint256 remainder = mulmod(target, numerator, denominator); - remainder = denominator.safeSub(remainder) % denominator; - isError = remainder.safeMul(1000) >= numerator.safeMul(target); - return isError; - } -} diff --git a/contracts/utils/contracts/src/LibMathRichErrors.sol b/contracts/utils/contracts/src/LibMathRichErrors.sol deleted file mode 100644 index 91b85cc1ce..0000000000 --- a/contracts/utils/contracts/src/LibMathRichErrors.sol +++ /dev/null @@ -1,21 +0,0 @@ -pragma solidity ^0.5.9; - -library LibMathRichErrors { - // bytes4(keccak256("DivisionByZeroError()")) - bytes internal constant DIVISION_BY_ZERO_ERROR = hex"a791837c"; - - // bytes4(keccak256("RoundingError(uint256,uint256,uint256)")) - bytes4 internal constant ROUNDING_ERROR_SELECTOR = 0x339f3de2; - - function DivisionByZeroError() internal pure returns (bytes memory) { - return DIVISION_BY_ZERO_ERROR; - } - - function RoundingError( - uint256 numerator, - uint256 denominator, - uint256 target - ) internal pure returns (bytes memory) { - return abi.encodeWithSelector(ROUNDING_ERROR_SELECTOR, numerator, denominator, target); - } -} diff --git a/contracts/utils/contracts/src/Refundable.sol b/contracts/utils/contracts/src/Refundable.sol deleted file mode 100644 index 77f47c4d0a..0000000000 --- a/contracts/utils/contracts/src/Refundable.sol +++ /dev/null @@ -1,74 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -import "./ReentrancyGuard.sol"; - -contract Refundable is ReentrancyGuard { - // This bool is used by the refund modifier to allow for lazily evaluated refunds. - bool internal _shouldNotRefund; - - modifier refundFinalBalance() { - _; - _refundNonZeroBalanceIfEnabled(); - } - - modifier refundFinalBalanceNoReentry() { - _lockMutexOrThrowIfAlreadyLocked(); - _; - _refundNonZeroBalanceIfEnabled(); - _unlockMutex(); - } - - modifier disableRefundUntilEnd() { - if (_areRefundsDisabled()) { - _; - } else { - _disableRefund(); - _; - _enableAndRefundNonZeroBalance(); - } - } - - function _refundNonZeroBalanceIfEnabled() internal { - if (!_areRefundsDisabled()) { - _refundNonZeroBalance(); - } - } - - function _refundNonZeroBalance() internal { - uint256 balance = address(this).balance; - if (balance > 0) { - msg.sender.transfer(balance); - } - } - - function _disableRefund() internal { - _shouldNotRefund = true; - } - - function _enableAndRefundNonZeroBalance() internal { - _shouldNotRefund = false; - _refundNonZeroBalance(); - } - - function _areRefundsDisabled() internal view returns (bool) { - return _shouldNotRefund; - } -} diff --git a/contracts/utils/contracts/src/interfaces/IAuthorizable.sol b/contracts/utils/contracts/src/interfaces/IAuthorizable.sol deleted file mode 100644 index 2e817f5c38..0000000000 --- a/contracts/utils/contracts/src/interfaces/IAuthorizable.sol +++ /dev/null @@ -1,46 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -import "./IOwnable.sol"; - -contract IAuthorizable is IOwnable { - // Event logged when a new address is authorized. - event AuthorizedAddressAdded(address indexed target, address indexed caller); - - // Event logged when a currently authorized address is unauthorized. - event AuthorizedAddressRemoved(address indexed target, address indexed caller); - - /// @dev Authorizes an address. - /// @param target Address to authorize. - function addAuthorizedAddress(address target) external; - - /// @dev Removes authorizion of an address. - /// @param target Address to remove authorization from. - function removeAuthorizedAddress(address target) external; - - /// @dev Removes authorizion of an address. - /// @param target Address to remove authorization from. - /// @param index Index of target in authorities array. - function removeAuthorizedAddressAtIndex(address target, uint256 index) external; - - /// @dev Gets all authorized addresses. - /// @return Array of authorized addresses. - function getAuthorizedAddresses() external view returns (address[] memory); -} diff --git a/contracts/utils/contracts/src/v06/ReentrancyGuardV06.sol b/contracts/utils/contracts/src/v06/ReentrancyGuardV06.sol deleted file mode 100644 index 33dd4782a8..0000000000 --- a/contracts/utils/contracts/src/v06/ReentrancyGuardV06.sol +++ /dev/null @@ -1,50 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -/* - - Copyright 2020 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.6.5; - -import "./errors/LibReentrancyGuardRichErrorsV06.sol"; -import "./errors/LibRichErrorsV06.sol"; - -contract ReentrancyGuardV06 { - // Locked state of mutex. - bool private _locked = false; - - /// @dev Functions with this modifer cannot be reentered. The mutex will be locked - /// before function execution and unlocked after. - modifier nonReentrant() { - _lockMutexOrThrowIfAlreadyLocked(); - _; - _unlockMutex(); - } - - function _lockMutexOrThrowIfAlreadyLocked() internal { - // Ensure mutex is unlocked. - if (_locked) { - LibRichErrorsV06.rrevert(LibReentrancyGuardRichErrorsV06.IllegalReentrancyError()); - } - // Lock mutex. - _locked = true; - } - - function _unlockMutex() internal { - // Unlock mutex. - _locked = false; - } -} diff --git a/contracts/utils/contracts/test/TestAuthorizable.sol b/contracts/utils/contracts/test/TestAuthorizable.sol deleted file mode 100644 index 08782170aa..0000000000 --- a/contracts/utils/contracts/test/TestAuthorizable.sol +++ /dev/null @@ -1,25 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -import "../src/Authorizable.sol"; - -contract TestAuthorizable is Authorizable { - function onlyAuthorizedFn() external view onlyAuthorized {} -} diff --git a/contracts/utils/contracts/test/TestLibAddress.sol b/contracts/utils/contracts/test/TestLibAddress.sol deleted file mode 100644 index b3c1f60a13..0000000000 --- a/contracts/utils/contracts/test/TestLibAddress.sol +++ /dev/null @@ -1,29 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -import "../src/LibAddress.sol"; - -contract TestLibAddress { - using LibAddress for address; - - function externalIsContract(address account) external view returns (bool) { - return account.isContract(); - } -} diff --git a/contracts/utils/contracts/test/TestLibAddressArray.sol b/contracts/utils/contracts/test/TestLibAddressArray.sol deleted file mode 100644 index 01af93acbf..0000000000 --- a/contracts/utils/contracts/test/TestLibAddressArray.sol +++ /dev/null @@ -1,89 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.5; - -import "../src/LibAddressArray.sol"; - -contract TestLibAddressArray { - using LibAddressArray for address[]; - - /// @dev Append a new address to an array of addresses. - /// The `addressArray` may need to be reallocated to make space - /// for the new address. Because of this we return the resulting - /// memory location of `addressArray`. - /// @param addressArray Array of addresses. - /// @param addressToAppend Address to append. - /// @return Array of addresses: [... addressArray, addressToAppend] - function publicAppend( - address[] memory addressArray, - address addressToAppend - ) public pure returns (address[] memory) { - return addressArray.append(addressToAppend); - } - - /// @dev Moves the free memory pointer by `freeMemOffset` bytes, - /// then performs the append. - /// This tests the behavior of the address array being reallocated if - /// the memory immediately after the old array is claimed. - /// @param addressArray Array of addresses. - /// @param freeMemOffset Number of (signed) bytes to offset the free memory pointer (0x40). - /// @param addressToAppend Address to append. - /// @return The new address array. - /// @return The memory address of the old address array. - /// @return The memory address of the new address array. - function testAppendRealloc( - address[] memory addressArray, - int256 freeMemOffset, - address addressToAppend - ) public pure returns (address[] memory result, uint256 oldArrayMemStart, uint256 newArrayMemStart) { - assembly { - // Remember the original memory address of the array. - oldArrayMemStart := addressArray - // Move the free memory pointer. - mstore(0x40, add(mload(0x40), freeMemOffset)) - } - - // Call append. - result = addressArray.append(addressToAppend); - - // Get the new array memory address. - assembly { - newArrayMemStart := result - } - } - - /// @dev Checks if an address array contains the target address. - /// @param addressArray Array of addresses. - /// @param target Address to search for in array. - /// @return True if the addressArray contains the target. - function publicContains(address[] memory addressArray, address target) public pure returns (bool success) { - return addressArray.contains(target); - } - - /// @dev Finds the index of an address within an array. - /// @param addressArray Array of addresses. - /// @param target Address to search for in array. - /// @return Existence and index of the target in the array. - function publicIndexOf( - address[] memory addressArray, - address target - ) public pure returns (bool success, uint256 index) { - (success, index) = addressArray.indexOf(target); - } -} diff --git a/contracts/utils/contracts/test/TestLibEIP712.sol b/contracts/utils/contracts/test/TestLibEIP712.sol deleted file mode 100644 index 77077c6892..0000000000 --- a/contracts/utils/contracts/test/TestLibEIP712.sol +++ /dev/null @@ -1,36 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -import "../src/LibEIP712.sol"; - -contract TestLibEIP712 { - function externalHashEIP712DomainSeperator( - string calldata name, - string calldata version, - uint256 chainid, - address verifyingcontractaddress - ) external pure returns (bytes32) { - return LibEIP712.hashEIP712Domain(name, version, chainid, verifyingcontractaddress); - } - - function externalHashEIP712Message(bytes32 eip712DomainHash, bytes32 hashStruct) external pure returns (bytes32) { - return LibEIP712.hashEIP712Message(eip712DomainHash, hashStruct); - } -} diff --git a/contracts/utils/contracts/test/TestLibMath.sol b/contracts/utils/contracts/test/TestLibMath.sol deleted file mode 100644 index 9af557dcea..0000000000 --- a/contracts/utils/contracts/test/TestLibMath.sol +++ /dev/null @@ -1,104 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; -pragma experimental ABIEncoderV2; - -import "../src/LibMath.sol"; - -contract TestLibMath { - /// @dev Calculates partial value given a numerator and denominator. - /// Reverts if rounding error is >= 0.1% - /// @param numerator Numerator. - /// @param denominator Denominator. - /// @param target Value to calculate partial of. - /// @return Partial value of target. - function safeGetPartialAmountFloor( - uint256 numerator, - uint256 denominator, - uint256 target - ) public pure returns (uint256 partialAmount) { - return LibMath.safeGetPartialAmountFloor(numerator, denominator, target); - } - - /// @dev Calculates partial value given a numerator and denominator. - /// Reverts if rounding error is >= 0.1% - /// @param numerator Numerator. - /// @param denominator Denominator. - /// @param target Value to calculate partial of. - /// @return Partial value of target. - function safeGetPartialAmountCeil( - uint256 numerator, - uint256 denominator, - uint256 target - ) public pure returns (uint256 partialAmount) { - return LibMath.safeGetPartialAmountCeil(numerator, denominator, target); - } - - /// @dev Calculates partial value given a numerator and denominator. - /// @param numerator Numerator. - /// @param denominator Denominator. - /// @param target Value to calculate partial of. - /// @return Partial value of target. - function getPartialAmountFloor( - uint256 numerator, - uint256 denominator, - uint256 target - ) public pure returns (uint256 partialAmount) { - return LibMath.getPartialAmountFloor(numerator, denominator, target); - } - - /// @dev Calculates partial value given a numerator and denominator. - /// @param numerator Numerator. - /// @param denominator Denominator. - /// @param target Value to calculate partial of. - /// @return Partial value of target. - function getPartialAmountCeil( - uint256 numerator, - uint256 denominator, - uint256 target - ) public pure returns (uint256 partialAmount) { - return LibMath.getPartialAmountCeil(numerator, denominator, target); - } - - /// @dev Checks if rounding error >= 0.1%. - /// @param numerator Numerator. - /// @param denominator Denominator. - /// @param target Value to multiply with numerator/denominator. - /// @return Rounding error is present. - function isRoundingErrorFloor( - uint256 numerator, - uint256 denominator, - uint256 target - ) public pure returns (bool isError) { - return LibMath.isRoundingErrorFloor(numerator, denominator, target); - } - - /// @dev Checks if rounding error >= 0.1%. - /// @param numerator Numerator. - /// @param denominator Denominator. - /// @param target Value to multiply with numerator/denominator. - /// @return Rounding error is present. - function isRoundingErrorCeil( - uint256 numerator, - uint256 denominator, - uint256 target - ) public pure returns (bool isError) { - return LibMath.isRoundingErrorCeil(numerator, denominator, target); - } -} diff --git a/contracts/utils/contracts/test/TestLogDecoding.sol b/contracts/utils/contracts/test/TestLogDecoding.sol deleted file mode 100644 index 624e71e637..0000000000 --- a/contracts/utils/contracts/test/TestLogDecoding.sol +++ /dev/null @@ -1,43 +0,0 @@ -/* - - Copyright 2018 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.5; - -import "./TestLogDecodingDownstream.sol"; - -contract TestLogDecoding { - /// @dev arbitrary event; fields to not matter. - event TestEvent(uint256 foo, bytes bar, string car); - - /// @dev Emits a local event - function emitEvent() public { - emit TestEvent(256, hex"1234", "4321"); - } - - /// @dev Emits an event in a downstream contract - function emitEventDownstream() public { - TestLogDecodingDownstream testLogDecodingDownstream = new TestLogDecodingDownstream(); - ITestLogDecodingDownstream(testLogDecodingDownstream).emitEvent(); - } - - /// @dev Emits a local event and a downstream event - function emitEventsLocalAndDownstream() public { - emitEvent(); - emitEventDownstream(); - } -} diff --git a/contracts/utils/contracts/test/TestLogDecodingDownstream.sol b/contracts/utils/contracts/test/TestLogDecodingDownstream.sol deleted file mode 100644 index 9424fab385..0000000000 --- a/contracts/utils/contracts/test/TestLogDecodingDownstream.sol +++ /dev/null @@ -1,37 +0,0 @@ -/* - - Copyright 2018 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.5; - -contract ITestLogDecodingDownstream { - /// @dev Emits a local event - function emitEvent() external; -} - -contract TestLogDecodingDownstream is ITestLogDecodingDownstream { - /// @dev event with fields different than those in `TestLogDecoding.TestEvent` - /// Note: do not include this in the interface - /// For testing, we want to emit an event that is - /// not known by the calling contract. - event TestEvent2(uint256 lorem, string ipsum); - - /// @dev Emits a local event - function emitEvent() external { - emit TestEvent2(256, "4321"); - } -} diff --git a/contracts/utils/contracts/test/TestRefundable.sol b/contracts/utils/contracts/test/TestRefundable.sol deleted file mode 100644 index 5a792bf735..0000000000 --- a/contracts/utils/contracts/test/TestRefundable.sol +++ /dev/null @@ -1,49 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -import "../src/Refundable.sol"; - -contract TestRefundable is Refundable { - function refundNonZeroBalanceExternal() external payable { - _refundNonZeroBalance(); - } - - function setShouldNotRefund(bool shouldNotRefundNew) external { - _shouldNotRefund = shouldNotRefundNew; - } - - function getShouldNotRefund() external view returns (bool) { - return _shouldNotRefund; - } - - function refundFinalBalanceFunction() public payable refundFinalBalance {} - - function disableRefundUntilEndFunction() public payable disableRefundUntilEnd {} - - function nestedDisableRefundUntilEndFunction() public payable disableRefundUntilEnd returns (uint256) { - disableRefundUntilEndFunction(); - return address(this).balance; - } - - function mixedRefundModifierFunction() public payable disableRefundUntilEnd returns (uint256) { - refundFinalBalanceFunction(); - return address(this).balance; - } -} diff --git a/contracts/utils/contracts/test/TestRefundableReceiver.sol b/contracts/utils/contracts/test/TestRefundableReceiver.sol deleted file mode 100644 index f66b0ccff2..0000000000 --- a/contracts/utils/contracts/test/TestRefundableReceiver.sol +++ /dev/null @@ -1,154 +0,0 @@ -/* - - Copyright 2019 ZeroEx Intl. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -*/ - -pragma solidity ^0.5.9; - -import "./TestRefundable.sol"; - -contract TestRefundableReceiver { - /// @dev A payable fallback function is necessary to receive refunds from the `TestRefundable` contract. - /// This function ensures that zero value is not sent to the contract, which tests the feature of - /// of the `refundNonzeroBalance` that doesn't transfer if the balance is zero. - function() external payable { - // Ensure that a value of zero was not transferred to the contract. - require(msg.value != 0, "Zero value should not be sent to this contract."); - } - - /// @dev This function tests the behavior of the `refundNonzeroBalance` function by checking whether or - /// not the `callCounter` state variable changes after the `refundNonzeroBalance` is called. - /// @param testRefundable The TestRefundable that should be tested against. - function testRefundNonZeroBalance(TestRefundable testRefundable) external payable { - // Call `refundNonzeroBalance()` and forward all of the eth sent to the contract. - testRefundable.refundNonZeroBalanceExternal.value(msg.value)(); - - // If the value sent was nonzero, a check that a refund was received will be executed. Otherwise, the fallback - // function contains a check that will fail in the event that a value of zero was sent to the contract. - if (msg.value > 0) { - // Ensure that a full refund was provided to this contract. - require(address(this).balance == msg.value, "A full refund was not provided by `refundNonzeroBalance`"); - } - } - - /// @dev This function tests the behavior to a simple call to `refundFinalBalanceFunction`. This - /// test will verify that the correct refund was provided after the call (depending on whether - /// a refund should be provided), and it will ensure that the `shouldNotRefund` state variable - /// remains unaltered after the function call. - /// @param testRefundable The TestRefundable that should be tested against. - /// @param shouldNotRefund The value that shouldNotRefund should be set to before the call to TestRefundable. - function testRefundFinalBalance(TestRefundable testRefundable, bool shouldNotRefund) external payable { - // Set `shouldNotRefund` to the specified bool. - testRefundable.setShouldNotRefund(shouldNotRefund); - - // Call `refundFinalBalanceFunction` and forward all value from the contract. - testRefundable.refundFinalBalanceFunction.value(msg.value)(); - - // Assert that the expected refunds happened and that the `shouldNotRefund` value was - // set back to an unaltered state after the call. - requireCorrectFinalBalancesAndState(testRefundable, shouldNotRefund); - } - - /// @dev This function tests the behavior to a simple call to `disableRefundUntilEndFunction`. This - /// test will verify that the correct refund was provided after the call (depending on whether - /// a refund should be provided), and it will ensure that the `shouldNotRefund` state variable - /// remains unaltered after the function call. - /// @param testRefundable The TestRefundable that should be tested against. - /// @param shouldNotRefund The value that shouldNotRefund should be set to before the call to TestRefundable. - function testDisableRefundUntilEnd(TestRefundable testRefundable, bool shouldNotRefund) external payable { - // Set `shouldNotRefund` to the specified bool. - testRefundable.setShouldNotRefund(shouldNotRefund); - - // Call `disableRefundUntilEndFunction` and forward all value from the contract. - testRefundable.disableRefundUntilEndFunction.value(msg.value)(); - - // Assert that the expected refunds happened and that the `shouldNotRefund` value was - // set back to an unaltered state after the call. - requireCorrectFinalBalancesAndState(testRefundable, shouldNotRefund); - } - - /// @dev This function tests the behavior of a call to a function that has the `disableRefundUntilEndFunction`. - /// The function that is called also uses the `disableRefundUntilEndFunction`, so this function's role is - /// to verify that both the inner and outer modifiers worked correctly. - /// @param testRefundable The TestRefundable that should be tested against. - /// @param shouldNotRefund The value that shouldNotRefund should be set to before the call to TestRefundable. - function testNestedDisableRefundUntilEnd(TestRefundable testRefundable, bool shouldNotRefund) external payable { - // Set `shouldNotRefund` to the specified bool. - testRefundable.setShouldNotRefund(shouldNotRefund); - - // Call `nestedDisableRefundUntilEndFunction` and forward all value from the contract. - uint256 balanceWithinCall = testRefundable.nestedDisableRefundUntilEndFunction.value(msg.value)(); - - // Ensure that the balance within the call was equal to `msg.value` since the inner refund should - // not have been triggered regardless of the value of `shouldNotRefund`. - require(balanceWithinCall == msg.value, "Incorrect inner balance"); - - // Assert that the expected refunds happened and that the `shouldNotRefund` value was - // set back to an unaltered state after the call. - requireCorrectFinalBalancesAndState(testRefundable, shouldNotRefund); - } - - /// @dev This function tests the behavior of a call to a function that has the `disableRefundUntilEndFunction`. - /// The function that is called uses the `refundFinalBalanceFunction`, so this function's role is - /// to verify that both the inner and outer modifiers worked correctly. - /// @param testRefundable The TestRefundable that should be tested against. - /// @param shouldNotRefund The value that shouldNotRefund should be set to before the call to TestRefundable. - function testMixedRefunds(TestRefundable testRefundable, bool shouldNotRefund) external payable { - // Set `shouldNotRefund` to the specified bool. - testRefundable.setShouldNotRefund(shouldNotRefund); - - // Call `mixedRefundModifierFunction` and forward all value from the contract. - uint256 balanceWithinCall = testRefundable.mixedRefundModifierFunction.value(msg.value)(); - - // Ensure that the balance within the call was equal to `msg.value` since the inner refund should - // not have been triggered regardless of the value of `shouldNotRefund`. - require(balanceWithinCall == msg.value, "Incorrect inner balance"); - - // Assert that the expected refunds happened and that the `shouldNotRefund` value was - // set back to an unaltered state after the call. - requireCorrectFinalBalancesAndState(testRefundable, shouldNotRefund); - } - - /// @dev This helper function verifies the final balances of this receiver contract and a specified - /// refundable contract and verifies that the `shouldNotRefund` value remains unaltered. - /// @param testRefundable The TestRefundable that should be tested against. - /// @param shouldNotRefund The value that shouldNotRefund was set to before the call to TestRefundable. - function requireCorrectFinalBalancesAndState(TestRefundable testRefundable, bool shouldNotRefund) internal { - // If `shouldNotRefund` was true, then this contract should have a balance of zero, - // and `testRefundable` should have a balance of `msg.value`. Otherwise, the opposite - // should be true. - if (shouldNotRefund) { - // Ensure that this contract's balance is zero. - require(address(this).balance == 0, "Incorrect balance for TestRefundableReceiver"); - - // Ensure that the other contract's balance is equal to `msg.value`. - require(address(testRefundable).balance == msg.value, "Incorrect balance for TestRefundable"); - } else { - // Ensure that this contract's balance is `msg.value`. - require(address(this).balance == msg.value, "Incorrect balance for TestRefundableReceiver"); - - // Ensure that the other contract's balance is equal to zero. - require(address(testRefundable).balance == 0, "Incorrect balance for TestRefundable"); - } - - // Ensure that `shouldNotRefund` in TestRefundable is set to the parameter `shouldNotRefund` - // after the call (i.e. the value didn't change during the function call). - require(testRefundable.getShouldNotRefund() == shouldNotRefund, "Incorrect shouldNotRefund value"); - - // Drain the contract of funds so that subsequent tests don't have to account for leftover ether. - msg.sender.transfer(address(this).balance); - } -} diff --git a/contracts/utils/package.json b/contracts/utils/package.json index 617a7a70e9..d4a447faba 100644 --- a/contracts/utils/package.json +++ b/contracts/utils/package.json @@ -30,9 +30,9 @@ "contracts:copy": "contracts-gen copy" }, "config": { - "publicInterfaceContracts": "Authorizable,IAuthorizable,IOwnable,LibAddress,LibAddressArray,LibAddressArrayRichErrors,LibAuthorizableRichErrors,LibBytes,LibBytesRichErrors,LibEIP1271,LibEIP712,LibFractions,LibOwnableRichErrors,LibReentrancyGuardRichErrors,LibRichErrors,LibMath,LibMathRichErrors,LibSafeMath,LibSafeMathRichErrors,Ownable,ReentrancyGuard,Refundable", + "publicInterfaceContracts": "IOwnable,LibBytes,LibBytesRichErrors,LibOwnableRichErrors,LibReentrancyGuardRichErrors,LibRichErrors,LibSafeMath,LibSafeMathRichErrors,Ownable,ReentrancyGuard", "abis:comment": "This list is auto-generated by contracts-gen. Don't edit manually.", - "abis": "./test/generated-artifacts/@(Authorizable|AuthorizableV06|AuthorizableV08|D18|DeploymentConstants|IAuthorizable|IAuthorizableV06|IAuthorizableV08|IOwnable|IOwnableV06|IOwnableV08|LibAddress|LibAddressArray|LibAddressArrayRichErrors|LibAuthorizableRichErrors|LibAuthorizableRichErrorsV06|LibAuthorizableRichErrorsV08|LibBytes|LibBytesRichErrors|LibBytesRichErrorsV06|LibBytesRichErrorsV08|LibBytesV06|LibBytesV08|LibEIP1271|LibEIP712|LibFractions|LibMath|LibMathRichErrors|LibMathRichErrorsV06|LibMathRichErrorsV08|LibMathV06|LibMathV08|LibOwnableRichErrors|LibOwnableRichErrorsV06|LibOwnableRichErrorsV08|LibReentrancyGuardRichErrors|LibReentrancyGuardRichErrorsV06|LibReentrancyGuardRichErrorsV08|LibRichErrors|LibRichErrorsV06|LibRichErrorsV08|LibSafeMath|LibSafeMathRichErrors|LibSafeMathRichErrorsV06|LibSafeMathRichErrorsV08|LibSafeMathV06|Ownable|OwnableV06|OwnableV08|ReentrancyGuard|ReentrancyGuardV06|ReentrancyGuardV08|Refundable|TestAuthorizable|TestLibAddress|TestLibAddressArray|TestLibBytes|TestLibEIP712|TestLibMath|TestLibRichErrors|TestLibSafeMath|TestLogDecoding|TestLogDecodingDownstream|TestOwnable|TestReentrancyGuard|TestRefundable|TestRefundableReceiver).json" + "abis": "./test/generated-artifacts/@(AuthorizableV06|AuthorizableV08|IAuthorizableV06|IAuthorizableV08|IOwnable|IOwnableV06|IOwnableV08|LibAuthorizableRichErrorsV06|LibAuthorizableRichErrorsV08|LibBytes|LibBytesRichErrors|LibBytesRichErrorsV06|LibBytesRichErrorsV08|LibBytesV06|LibBytesV08|LibMathRichErrorsV06|LibMathRichErrorsV08|LibMathV06|LibMathV08|LibOwnableRichErrors|LibOwnableRichErrorsV06|LibOwnableRichErrorsV08|LibReentrancyGuardRichErrors|LibReentrancyGuardRichErrorsV06|LibReentrancyGuardRichErrorsV08|LibRichErrors|LibRichErrorsV06|LibRichErrorsV08|LibSafeMath|LibSafeMathRichErrors|LibSafeMathRichErrorsV06|LibSafeMathRichErrorsV08|LibSafeMathV06|Ownable|OwnableV06|OwnableV08|ReentrancyGuard|ReentrancyGuardV08|TestLibBytes|TestLibRichErrors|TestLibSafeMath|TestOwnable|TestReentrancyGuard).json" }, "repository": { "type": "git", diff --git a/contracts/utils/src/artifacts.ts b/contracts/utils/src/artifacts.ts index 7b4d4213f3..870c70c06d 100644 --- a/contracts/utils/src/artifacts.ts +++ b/contracts/utils/src/artifacts.ts @@ -5,20 +5,9 @@ */ import { ContractArtifact } from 'ethereum-types'; -import * as Authorizable from '../generated-artifacts/Authorizable.json'; -import * as IAuthorizable from '../generated-artifacts/IAuthorizable.json'; import * as IOwnable from '../generated-artifacts/IOwnable.json'; -import * as LibAddress from '../generated-artifacts/LibAddress.json'; -import * as LibAddressArray from '../generated-artifacts/LibAddressArray.json'; -import * as LibAddressArrayRichErrors from '../generated-artifacts/LibAddressArrayRichErrors.json'; -import * as LibAuthorizableRichErrors from '../generated-artifacts/LibAuthorizableRichErrors.json'; import * as LibBytes from '../generated-artifacts/LibBytes.json'; import * as LibBytesRichErrors from '../generated-artifacts/LibBytesRichErrors.json'; -import * as LibEIP1271 from '../generated-artifacts/LibEIP1271.json'; -import * as LibEIP712 from '../generated-artifacts/LibEIP712.json'; -import * as LibFractions from '../generated-artifacts/LibFractions.json'; -import * as LibMath from '../generated-artifacts/LibMath.json'; -import * as LibMathRichErrors from '../generated-artifacts/LibMathRichErrors.json'; import * as LibOwnableRichErrors from '../generated-artifacts/LibOwnableRichErrors.json'; import * as LibReentrancyGuardRichErrors from '../generated-artifacts/LibReentrancyGuardRichErrors.json'; import * as LibRichErrors from '../generated-artifacts/LibRichErrors.json'; @@ -26,28 +15,15 @@ import * as LibSafeMath from '../generated-artifacts/LibSafeMath.json'; import * as LibSafeMathRichErrors from '../generated-artifacts/LibSafeMathRichErrors.json'; import * as Ownable from '../generated-artifacts/Ownable.json'; import * as ReentrancyGuard from '../generated-artifacts/ReentrancyGuard.json'; -import * as Refundable from '../generated-artifacts/Refundable.json'; export const artifacts = { - Authorizable: Authorizable as ContractArtifact, - IAuthorizable: IAuthorizable as ContractArtifact, IOwnable: IOwnable as ContractArtifact, - LibAddress: LibAddress as ContractArtifact, - LibAddressArray: LibAddressArray as ContractArtifact, - LibAddressArrayRichErrors: LibAddressArrayRichErrors as ContractArtifact, - LibAuthorizableRichErrors: LibAuthorizableRichErrors as ContractArtifact, LibBytes: LibBytes as ContractArtifact, LibBytesRichErrors: LibBytesRichErrors as ContractArtifact, - LibEIP1271: LibEIP1271 as ContractArtifact, - LibEIP712: LibEIP712 as ContractArtifact, - LibFractions: LibFractions as ContractArtifact, LibOwnableRichErrors: LibOwnableRichErrors as ContractArtifact, LibReentrancyGuardRichErrors: LibReentrancyGuardRichErrors as ContractArtifact, LibRichErrors: LibRichErrors as ContractArtifact, - LibMath: LibMath as ContractArtifact, - LibMathRichErrors: LibMathRichErrors as ContractArtifact, LibSafeMath: LibSafeMath as ContractArtifact, LibSafeMathRichErrors: LibSafeMathRichErrors as ContractArtifact, Ownable: Ownable as ContractArtifact, ReentrancyGuard: ReentrancyGuard as ContractArtifact, - Refundable: Refundable as ContractArtifact, }; diff --git a/contracts/utils/src/reference_functions.ts b/contracts/utils/src/reference_functions.ts index 91d2ae21f6..bcac880803 100644 --- a/contracts/utils/src/reference_functions.ts +++ b/contracts/utils/src/reference_functions.ts @@ -52,77 +52,3 @@ export function safeDiv(a: BigNumber, b: BigNumber): BigNumber { } return a.dividedToIntegerBy(b); } - -// LibMath - -/** - * Checks if rounding error >= 0.1% when rounding down. - */ -export function isRoundingErrorFloor(numerator: BigNumber, denominator: BigNumber, target: BigNumber): boolean { - if (denominator.eq(0)) { - throw new LibMathRevertErrors.DivisionByZeroError(); - } - if (numerator.eq(0) || target.eq(0)) { - return false; - } - const remainder = numerator.times(target).mod(denominator); - // Need to do this separately because solidity evaluates RHS of the comparison expression first. - const rhs = safeMul(numerator, target); - const lhs = safeMul(remainder, new BigNumber(1000)); - return lhs.gte(rhs); -} - -/** - * Checks if rounding error >= 0.1% when rounding up. - */ -export function isRoundingErrorCeil(numerator: BigNumber, denominator: BigNumber, target: BigNumber): boolean { - if (denominator.eq(0)) { - throw new LibMathRevertErrors.DivisionByZeroError(); - } - if (numerator.eq(0) || target.eq(0)) { - return false; - } - let remainder = numerator.times(target).mod(denominator); - remainder = safeSub(denominator, remainder).mod(denominator); - // Need to do this separately because solidity evaluates RHS of the comparison expression first. - const rhs = safeMul(numerator, target); - const lhs = safeMul(remainder, new BigNumber(1000)); - return lhs.gte(rhs); -} - -/** - * Calculates partial value given a numerator and denominator rounded down. - * Reverts if rounding error is >= 0.1% - */ -export function safeGetPartialAmountFloor(numerator: BigNumber, denominator: BigNumber, target: BigNumber): BigNumber { - if (isRoundingErrorFloor(numerator, denominator, target)) { - throw new LibMathRevertErrors.RoundingError(numerator, denominator, target); - } - return safeDiv(safeMul(numerator, target), denominator); -} - -/** - * Calculates partial value given a numerator and denominator rounded down. - * Reverts if rounding error is >= 0.1% - */ -export function safeGetPartialAmountCeil(numerator: BigNumber, denominator: BigNumber, target: BigNumber): BigNumber { - if (isRoundingErrorCeil(numerator, denominator, target)) { - throw new LibMathRevertErrors.RoundingError(numerator, denominator, target); - } - return safeDiv(safeAdd(safeMul(numerator, target), safeSub(denominator, new BigNumber(1))), denominator); -} - -/** - * Calculates partial value given a numerator and denominator rounded down. - */ -export function getPartialAmountFloor(numerator: BigNumber, denominator: BigNumber, target: BigNumber): BigNumber { - return safeDiv(safeMul(numerator, target), denominator); -} - -/** - * Calculates partial value given a numerator and denominator rounded down. - */ -export function getPartialAmountCeil(numerator: BigNumber, denominator: BigNumber, target: BigNumber): BigNumber { - const sub = safeSub(denominator, new BigNumber(1)); // This is computed first to simulate Solidity's order of operations - return safeDiv(safeAdd(safeMul(numerator, target), sub), denominator); -} diff --git a/contracts/utils/src/wrappers.ts b/contracts/utils/src/wrappers.ts index b403af0b7e..a37ef2d0b8 100644 --- a/contracts/utils/src/wrappers.ts +++ b/contracts/utils/src/wrappers.ts @@ -3,20 +3,9 @@ * Warning: This file is auto-generated by contracts-gen. Don't edit manually. * ----------------------------------------------------------------------------- */ -export * from '../generated-wrappers/authorizable'; -export * from '../generated-wrappers/i_authorizable'; export * from '../generated-wrappers/i_ownable'; -export * from '../generated-wrappers/lib_address'; -export * from '../generated-wrappers/lib_address_array'; -export * from '../generated-wrappers/lib_address_array_rich_errors'; -export * from '../generated-wrappers/lib_authorizable_rich_errors'; export * from '../generated-wrappers/lib_bytes'; export * from '../generated-wrappers/lib_bytes_rich_errors'; -export * from '../generated-wrappers/lib_e_i_p1271'; -export * from '../generated-wrappers/lib_e_i_p712'; -export * from '../generated-wrappers/lib_fractions'; -export * from '../generated-wrappers/lib_math'; -export * from '../generated-wrappers/lib_math_rich_errors'; export * from '../generated-wrappers/lib_ownable_rich_errors'; export * from '../generated-wrappers/lib_reentrancy_guard_rich_errors'; export * from '../generated-wrappers/lib_rich_errors'; @@ -24,4 +13,3 @@ export * from '../generated-wrappers/lib_safe_math'; export * from '../generated-wrappers/lib_safe_math_rich_errors'; export * from '../generated-wrappers/ownable'; export * from '../generated-wrappers/reentrancy_guard'; -export * from '../generated-wrappers/refundable'; diff --git a/contracts/utils/test/artifacts.ts b/contracts/utils/test/artifacts.ts index fe873bd827..f605a172fe 100644 --- a/contracts/utils/test/artifacts.ts +++ b/contracts/utils/test/artifacts.ts @@ -5,21 +5,13 @@ */ import { ContractArtifact } from 'ethereum-types'; -import * as Authorizable from '../test/generated-artifacts/Authorizable.json'; import * as AuthorizableV06 from '../test/generated-artifacts/AuthorizableV06.json'; import * as AuthorizableV08 from '../test/generated-artifacts/AuthorizableV08.json'; -import * as D18 from '../test/generated-artifacts/D18.json'; -import * as DeploymentConstants from '../test/generated-artifacts/DeploymentConstants.json'; -import * as IAuthorizable from '../test/generated-artifacts/IAuthorizable.json'; import * as IAuthorizableV06 from '../test/generated-artifacts/IAuthorizableV06.json'; import * as IAuthorizableV08 from '../test/generated-artifacts/IAuthorizableV08.json'; import * as IOwnable from '../test/generated-artifacts/IOwnable.json'; import * as IOwnableV06 from '../test/generated-artifacts/IOwnableV06.json'; import * as IOwnableV08 from '../test/generated-artifacts/IOwnableV08.json'; -import * as LibAddress from '../test/generated-artifacts/LibAddress.json'; -import * as LibAddressArray from '../test/generated-artifacts/LibAddressArray.json'; -import * as LibAddressArrayRichErrors from '../test/generated-artifacts/LibAddressArrayRichErrors.json'; -import * as LibAuthorizableRichErrors from '../test/generated-artifacts/LibAuthorizableRichErrors.json'; import * as LibAuthorizableRichErrorsV06 from '../test/generated-artifacts/LibAuthorizableRichErrorsV06.json'; import * as LibAuthorizableRichErrorsV08 from '../test/generated-artifacts/LibAuthorizableRichErrorsV08.json'; import * as LibBytes from '../test/generated-artifacts/LibBytes.json'; @@ -28,11 +20,6 @@ import * as LibBytesRichErrorsV06 from '../test/generated-artifacts/LibBytesRich import * as LibBytesRichErrorsV08 from '../test/generated-artifacts/LibBytesRichErrorsV08.json'; import * as LibBytesV06 from '../test/generated-artifacts/LibBytesV06.json'; import * as LibBytesV08 from '../test/generated-artifacts/LibBytesV08.json'; -import * as LibEIP1271 from '../test/generated-artifacts/LibEIP1271.json'; -import * as LibEIP712 from '../test/generated-artifacts/LibEIP712.json'; -import * as LibFractions from '../test/generated-artifacts/LibFractions.json'; -import * as LibMath from '../test/generated-artifacts/LibMath.json'; -import * as LibMathRichErrors from '../test/generated-artifacts/LibMathRichErrors.json'; import * as LibMathRichErrorsV06 from '../test/generated-artifacts/LibMathRichErrorsV06.json'; import * as LibMathRichErrorsV08 from '../test/generated-artifacts/LibMathRichErrorsV08.json'; import * as LibMathV06 from '../test/generated-artifacts/LibMathV06.json'; @@ -55,38 +42,15 @@ import * as Ownable from '../test/generated-artifacts/Ownable.json'; import * as OwnableV06 from '../test/generated-artifacts/OwnableV06.json'; import * as OwnableV08 from '../test/generated-artifacts/OwnableV08.json'; import * as ReentrancyGuard from '../test/generated-artifacts/ReentrancyGuard.json'; -import * as ReentrancyGuardV06 from '../test/generated-artifacts/ReentrancyGuardV06.json'; import * as ReentrancyGuardV08 from '../test/generated-artifacts/ReentrancyGuardV08.json'; -import * as Refundable from '../test/generated-artifacts/Refundable.json'; -import * as TestAuthorizable from '../test/generated-artifacts/TestAuthorizable.json'; -import * as TestLibAddress from '../test/generated-artifacts/TestLibAddress.json'; -import * as TestLibAddressArray from '../test/generated-artifacts/TestLibAddressArray.json'; import * as TestLibBytes from '../test/generated-artifacts/TestLibBytes.json'; -import * as TestLibEIP712 from '../test/generated-artifacts/TestLibEIP712.json'; -import * as TestLibMath from '../test/generated-artifacts/TestLibMath.json'; import * as TestLibRichErrors from '../test/generated-artifacts/TestLibRichErrors.json'; import * as TestLibSafeMath from '../test/generated-artifacts/TestLibSafeMath.json'; -import * as TestLogDecoding from '../test/generated-artifacts/TestLogDecoding.json'; -import * as TestLogDecodingDownstream from '../test/generated-artifacts/TestLogDecodingDownstream.json'; import * as TestOwnable from '../test/generated-artifacts/TestOwnable.json'; import * as TestReentrancyGuard from '../test/generated-artifacts/TestReentrancyGuard.json'; -import * as TestRefundable from '../test/generated-artifacts/TestRefundable.json'; -import * as TestRefundableReceiver from '../test/generated-artifacts/TestRefundableReceiver.json'; export const artifacts = { - Authorizable: Authorizable as ContractArtifact, - D18: D18 as ContractArtifact, - DeploymentConstants: DeploymentConstants as ContractArtifact, - LibAddress: LibAddress as ContractArtifact, - LibAddressArray: LibAddressArray as ContractArtifact, - LibAddressArrayRichErrors: LibAddressArrayRichErrors as ContractArtifact, - LibAuthorizableRichErrors: LibAuthorizableRichErrors as ContractArtifact, LibBytes: LibBytes as ContractArtifact, LibBytesRichErrors: LibBytesRichErrors as ContractArtifact, - LibEIP1271: LibEIP1271 as ContractArtifact, - LibEIP712: LibEIP712 as ContractArtifact, - LibFractions: LibFractions as ContractArtifact, - LibMath: LibMath as ContractArtifact, - LibMathRichErrors: LibMathRichErrors as ContractArtifact, LibOwnableRichErrors: LibOwnableRichErrors as ContractArtifact, LibReentrancyGuardRichErrors: LibReentrancyGuardRichErrors as ContractArtifact, LibRichErrors: LibRichErrors as ContractArtifact, @@ -94,15 +58,12 @@ export const artifacts = { LibSafeMathRichErrors: LibSafeMathRichErrors as ContractArtifact, Ownable: Ownable as ContractArtifact, ReentrancyGuard: ReentrancyGuard as ContractArtifact, - Refundable: Refundable as ContractArtifact, - IAuthorizable: IAuthorizable as ContractArtifact, IOwnable: IOwnable as ContractArtifact, AuthorizableV06: AuthorizableV06 as ContractArtifact, LibBytesV06: LibBytesV06 as ContractArtifact, LibMathV06: LibMathV06 as ContractArtifact, LibSafeMathV06: LibSafeMathV06 as ContractArtifact, OwnableV06: OwnableV06 as ContractArtifact, - ReentrancyGuardV06: ReentrancyGuardV06 as ContractArtifact, LibAuthorizableRichErrorsV06: LibAuthorizableRichErrorsV06 as ContractArtifact, LibBytesRichErrorsV06: LibBytesRichErrorsV06 as ContractArtifact, LibMathRichErrorsV06: LibMathRichErrorsV06 as ContractArtifact, @@ -126,18 +87,9 @@ export const artifacts = { LibSafeMathRichErrorsV08: LibSafeMathRichErrorsV08 as ContractArtifact, IAuthorizableV08: IAuthorizableV08 as ContractArtifact, IOwnableV08: IOwnableV08 as ContractArtifact, - TestAuthorizable: TestAuthorizable as ContractArtifact, - TestLibAddress: TestLibAddress as ContractArtifact, - TestLibAddressArray: TestLibAddressArray as ContractArtifact, TestLibBytes: TestLibBytes as ContractArtifact, - TestLibEIP712: TestLibEIP712 as ContractArtifact, - TestLibMath: TestLibMath as ContractArtifact, TestLibRichErrors: TestLibRichErrors as ContractArtifact, TestLibSafeMath: TestLibSafeMath as ContractArtifact, - TestLogDecoding: TestLogDecoding as ContractArtifact, - TestLogDecodingDownstream: TestLogDecodingDownstream as ContractArtifact, TestOwnable: TestOwnable as ContractArtifact, TestReentrancyGuard: TestReentrancyGuard as ContractArtifact, - TestRefundable: TestRefundable as ContractArtifact, - TestRefundableReceiver: TestRefundableReceiver as ContractArtifact, }; diff --git a/contracts/utils/test/authorizable.ts b/contracts/utils/test/authorizable.ts deleted file mode 100644 index c48852500b..0000000000 --- a/contracts/utils/test/authorizable.ts +++ /dev/null @@ -1,165 +0,0 @@ -import { blockchainTests, constants, expect } from '@0x/contracts-test-utils'; -import { AuthorizableRevertErrors, BigNumber, OwnableRevertErrors } from '@0x/utils'; -import * as _ from 'lodash'; - -import { artifacts } from './artifacts'; -import { TestAuthorizableContract } from './wrappers'; - -blockchainTests.resets('Authorizable', env => { - let owner: string; - let notOwner: string; - let address: string; - let authorizable: TestAuthorizableContract; - - before(async () => { - const accounts = await env.getAccountAddressesAsync(); - [owner, address, notOwner] = _.slice(accounts, 0, 3); - authorizable = await TestAuthorizableContract.deployFrom0xArtifactAsync( - artifacts.TestAuthorizable, - env.provider, - env.txDefaults, - artifacts, - ); - }); - - describe('addAuthorizedAddress', () => { - it('should revert if not called by owner', async () => { - const expectedError = new OwnableRevertErrors.OnlyOwnerError(notOwner, owner); - const tx = authorizable.addAuthorizedAddress(notOwner).sendTransactionAsync({ from: notOwner }); - return expect(tx).to.revertWith(expectedError); - }); - - it('should allow owner to add an authorized address', async () => { - await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner }); - const isAuthorized = await authorizable.authorized(address).callAsync(); - expect(isAuthorized).to.be.true(); - }); - - it('should revert if owner attempts to authorize the zero address', async () => { - const expectedError = new AuthorizableRevertErrors.ZeroCantBeAuthorizedError(); - const tx = authorizable.addAuthorizedAddress(constants.NULL_ADDRESS).sendTransactionAsync({ from: owner }); - return expect(tx).to.revertWith(expectedError); - }); - - it('should revert if owner attempts to authorize a duplicate address', async () => { - await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner }); - const expectedError = new AuthorizableRevertErrors.TargetAlreadyAuthorizedError(address); - const tx = authorizable.addAuthorizedAddress(address).sendTransactionAsync({ from: owner }); - return expect(tx).to.revertWith(expectedError); - }); - }); - - describe('onlyAuthorized', () => { - before(async () => { - await authorizable.addAuthorizedAddress(owner).awaitTransactionSuccessAsync({ from: owner }); - }); - - after(async () => { - await authorizable.removeAuthorizedAddress(owner).awaitTransactionSuccessAsync({ from: owner }); - }); - - it('should revert if sender is not authorized', async () => { - const tx = authorizable.onlyAuthorizedFn().callAsync({ from: notOwner }); - const expectedError = new AuthorizableRevertErrors.SenderNotAuthorizedError(notOwner); - return expect(tx).to.revertWith(expectedError); - }); - - it('should succeed if sender is authorized', async () => { - await authorizable.onlyAuthorizedFn().callAsync({ from: owner }); - }); - }); - - describe('removeAuthorizedAddress', () => { - it('should revert if not called by owner', async () => { - await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner }); - const expectedError = new OwnableRevertErrors.OnlyOwnerError(notOwner, owner); - const tx = authorizable.removeAuthorizedAddress(address).sendTransactionAsync({ from: notOwner }); - return expect(tx).to.revertWith(expectedError); - }); - - it('should allow owner to remove an authorized address', async () => { - await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner }); - await authorizable.removeAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner }); - const isAuthorized = await authorizable.authorized(address).callAsync(); - expect(isAuthorized).to.be.false(); - }); - - it('should revert if owner attempts to remove an address that is not authorized', async () => { - const expectedError = new AuthorizableRevertErrors.TargetNotAuthorizedError(address); - const tx = authorizable.removeAuthorizedAddress(address).sendTransactionAsync({ from: owner }); - return expect(tx).to.revertWith(expectedError); - }); - }); - - describe('removeAuthorizedAddressAtIndex', () => { - it('should revert if not called by owner', async () => { - await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner }); - const index = new BigNumber(0); - const expectedError = new OwnableRevertErrors.OnlyOwnerError(notOwner, owner); - const tx = authorizable.removeAuthorizedAddressAtIndex(address, index).sendTransactionAsync({ - from: notOwner, - }); - return expect(tx).to.revertWith(expectedError); - }); - - it('should revert if index is >= authorities.length', async () => { - await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner }); - const index = new BigNumber(1); - const expectedError = new AuthorizableRevertErrors.IndexOutOfBoundsError(index, index); - const tx = authorizable.removeAuthorizedAddressAtIndex(address, index).sendTransactionAsync({ - from: owner, - }); - return expect(tx).to.revertWith(expectedError); - }); - - it('should revert if owner attempts to remove an address that is not authorized', async () => { - const index = new BigNumber(0); - const expectedError = new AuthorizableRevertErrors.TargetNotAuthorizedError(address); - const tx = authorizable.removeAuthorizedAddressAtIndex(address, index).sendTransactionAsync({ - from: owner, - }); - return expect(tx).to.revertWith(expectedError); - }); - - it('should revert if address at index does not match target', async () => { - const address1 = address; - const address2 = notOwner; - await authorizable.addAuthorizedAddress(address1).awaitTransactionSuccessAsync({ from: owner }); - await authorizable.addAuthorizedAddress(address2).awaitTransactionSuccessAsync({ from: owner }); - const address1Index = new BigNumber(0); - const expectedError = new AuthorizableRevertErrors.AuthorizedAddressMismatchError(address1, address2); - const tx = authorizable.removeAuthorizedAddressAtIndex(address2, address1Index).sendTransactionAsync({ - from: owner, - }); - return expect(tx).to.revertWith(expectedError); - }); - - it('should allow owner to remove an authorized address', async () => { - await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner }); - const index = new BigNumber(0); - await authorizable.removeAuthorizedAddressAtIndex(address, index).awaitTransactionSuccessAsync({ - from: owner, - }); - const isAuthorized = await authorizable.authorized(address).callAsync(); - expect(isAuthorized).to.be.false(); - }); - }); - - describe('getAuthorizedAddresses', () => { - it('should return correct authorized addresses', async () => { - // Initial Authorities - let authorities = await authorizable.getAuthorizedAddresses().callAsync(); - expect(authorities).to.be.deep.eq([]); - - // Authorities after addition - await authorizable.addAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner }); - authorities = await authorizable.getAuthorizedAddresses().callAsync(); - expect(authorities).to.be.deep.eq([address]); - - // Authorities after removal - await authorizable.removeAuthorizedAddress(address).awaitTransactionSuccessAsync({ from: owner }); - authorities = await authorizable.getAuthorizedAddresses().callAsync(); - expect(authorities).to.be.deep.eq([]); - }); - }); -}); diff --git a/contracts/utils/test/lib_address.ts b/contracts/utils/test/lib_address.ts deleted file mode 100644 index 72a67f6a65..0000000000 --- a/contracts/utils/test/lib_address.ts +++ /dev/null @@ -1,43 +0,0 @@ -import { chaiSetup, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils'; -import { BlockchainLifecycle } from '@0x/dev-utils'; -import * as chai from 'chai'; - -import { artifacts } from './artifacts'; -import { TestLibAddressContract } from './wrappers'; - -chaiSetup.configure(); -const expect = chai.expect; -const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper); - -describe('LibAddress', () => { - let lib: TestLibAddressContract; - let nonContract: string; - - before(async () => { - await blockchainLifecycle.startAsync(); - nonContract = (await web3Wrapper.getAvailableAddressesAsync())[0]; - // Deploy LibAddress - lib = await TestLibAddressContract.deployFrom0xArtifactAsync( - artifacts.TestLibAddress, - provider, - txDefaults, - {}, - ); - }); - - after(async () => { - await blockchainLifecycle.revertAsync(); - }); - - describe('isContract', () => { - it('should return false for a non-contract address', async () => { - const isContract = await lib.externalIsContract(nonContract).callAsync(); - expect(isContract).to.be.false(); - }); - - it('should return true for a non-contract address', async () => { - const isContract = await lib.externalIsContract(lib.address).callAsync(); - expect(isContract).to.be.true(); - }); - }); -}); diff --git a/contracts/utils/test/lib_address_array.ts b/contracts/utils/test/lib_address_array.ts deleted file mode 100644 index 1d637f3f8f..0000000000 --- a/contracts/utils/test/lib_address_array.ts +++ /dev/null @@ -1,144 +0,0 @@ -import { chaiSetup, provider, randomAddress, txDefaults, web3Wrapper } from '@0x/contracts-test-utils'; -import { BlockchainLifecycle } from '@0x/dev-utils'; -import { BigNumber, LibAddressArrayRevertErrors } from '@0x/utils'; -import * as chai from 'chai'; -import * as _ from 'lodash'; - -import { artifacts } from './artifacts'; -import { TestLibAddressArrayContract } from './wrappers'; - -chaiSetup.configure(); -const expect = chai.expect; -const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper); - -describe('LibAddressArray', () => { - let lib: TestLibAddressArrayContract; - - before(async () => { - await blockchainLifecycle.startAsync(); - // Deploy LibAddressArray - lib = await TestLibAddressArrayContract.deployFrom0xArtifactAsync( - artifacts.TestLibAddressArray, - provider, - txDefaults, - artifacts, - ); - }); - after(async () => { - await blockchainLifecycle.revertAsync(); - }); - - describe('append', () => { - it('should append to empty array', async () => { - const addr = randomAddress(); - const result = await lib.publicAppend([], addr).callAsync(); - const expected = [addr]; - expect(result).to.deep.equal(expected); - }); - - it('should append to non-empty array', async () => { - const arr = _.times(3, () => randomAddress()); - const addr = randomAddress(); - const expected = [...arr, addr]; - const result = await lib.publicAppend(arr, addr).callAsync(); - expect(result).to.deep.equal(expected); - }); - - it('should revert if the free memory pointer was moved to before the end of the array', async () => { - const arr = _.times(3, () => randomAddress()); - const addr = randomAddress(); - const freeMemOffset = new BigNumber(-1); - const addressArrayEndPtr = new BigNumber(256); - const expectedError = new LibAddressArrayRevertErrors.MismanagedMemoryError( - addressArrayEndPtr.plus(freeMemOffset), - addressArrayEndPtr, - ); - return expect(lib.testAppendRealloc(arr, freeMemOffset, addr).callAsync()).to.revertWith(expectedError); - }); - - it('should keep the same memory address if free memory pointer does not move', async () => { - const arr = _.times(3, () => randomAddress()); - const addr = randomAddress(); - const freeMemOffset = new BigNumber(0); - const expected = [...arr, addr]; - const [result, oldArrayMemStart, newArrayMemStart] = await lib - .testAppendRealloc(arr, freeMemOffset, addr) - .callAsync(); - expect(result).to.deep.equal(expected); - expect(newArrayMemStart).bignumber.to.be.equal(oldArrayMemStart); - }); - - it('should change memory address if free memory pointer advances', async () => { - const arr = _.times(3, () => randomAddress()); - const addr = randomAddress(); - const freeMemOffset = new BigNumber(1); - const expectedArray = [...arr, addr]; - const [result, oldArrayMemStart, newArrayMemStart] = await lib - .testAppendRealloc(arr, freeMemOffset, addr) - .callAsync(); - // The new location should be the end of the old array + freeMemOffset. - const expectedNewArrayMemStart = oldArrayMemStart.plus((arr.length + 1) * 32).plus(freeMemOffset); - expect(result).to.deep.equal(expectedArray); - expect(newArrayMemStart).bignumber.to.be.equal(expectedNewArrayMemStart); - }); - }); - - describe('contains', () => { - it('should return false on an empty array', async () => { - const addr = randomAddress(); - const isFound = await lib.publicContains([], addr).callAsync(); - expect(isFound).to.equal(false); - }); - - it('should return false on a missing item', async () => { - const arr = _.times(3, () => randomAddress()); - const addr = randomAddress(); - const isFound = await lib.publicContains(arr, addr).callAsync(); - expect(isFound).to.equal(false); - }); - - it('should return true on an included item', async () => { - const arr = _.times(4, () => randomAddress()); - const addr = _.sample(arr) as string; - const isFound = await lib.publicContains(arr, addr).callAsync(); - expect(isFound).to.equal(true); - }); - - it('should return true on the only item in the array', async () => { - const arr = _.times(1, () => randomAddress()); - const isFound = await lib.publicContains(arr, arr[0]).callAsync(); - expect(isFound).to.equal(true); - }); - }); - - describe('indexOf', () => { - it('should fail on an empty array', async () => { - const addr = randomAddress(); - const [isSuccess] = await lib.publicIndexOf([], addr).callAsync(); - expect(isSuccess).to.equal(false); - }); - - it('should fail on a missing item', async () => { - const arr = _.times(3, () => randomAddress()); - const addr = randomAddress(); - const [isSuccess] = await lib.publicIndexOf(arr, addr).callAsync(); - expect(isSuccess).to.equal(false); - }); - - it('should succeed on an included item', async () => { - const arr = _.times(4, () => randomAddress()); - const expectedIndexOf = _.random(0, arr.length - 1); - const addr = arr[expectedIndexOf]; - const [isSuccess, index] = await lib.publicIndexOf(arr, addr).callAsync(); - expect(isSuccess).to.equal(true); - expect(index).bignumber.to.equal(expectedIndexOf); - }); - - it('should succeed on the only item in the array', async () => { - const arr = _.times(1, () => randomAddress()); - const [isSuccess, index] = await lib.publicIndexOf(arr, arr[0]).callAsync(); - expect(isSuccess).to.equal(true); - expect(index).bignumber.to.equal(0); - }); - }); -}); diff --git a/contracts/utils/test/lib_eip712.ts b/contracts/utils/test/lib_eip712.ts deleted file mode 100644 index 4e6ecaed1e..0000000000 --- a/contracts/utils/test/lib_eip712.ts +++ /dev/null @@ -1,108 +0,0 @@ -import { chaiSetup, constants, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils'; -import { BlockchainLifecycle } from '@0x/dev-utils'; -import { BigNumber, hexUtils, signTypedDataUtils } from '@0x/utils'; -import * as chai from 'chai'; -import * as _ from 'lodash'; - -import { artifacts } from './artifacts'; -import { TestLibEIP712Contract } from './wrappers'; - -chaiSetup.configure(); -const expect = chai.expect; -const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper); - -describe('LibEIP712', () => { - let lib: TestLibEIP712Contract; - - before(async () => { - await blockchainLifecycle.startAsync(); - // Deploy LibEIP712 - lib = await TestLibEIP712Contract.deployFrom0xArtifactAsync(artifacts.TestLibEIP712, provider, txDefaults, {}); - }); - - after(async () => { - await blockchainLifecycle.revertAsync(); - }); - - /** - * Tests a specific instance of EIP712 domain hashing. - * @param lib The LibEIP712 contract to call. - * @param name The name of the domain. - * @param version The version of the domain. - * @param chainId The chain id of the domain. - * @param verifyingContract The verifying contract address of the domain. - */ - async function testHashEIP712DomainAsync( - name: string, - version: string, - chainId: number, - verifyingContract: string, - ): Promise { - const expectedHash = signTypedDataUtils.generateDomainHash({ - name, - version, - chainId, - verifyingContract, - }); - const actualHash = await lib - .externalHashEIP712DomainSeperator(name, version, new BigNumber(chainId), verifyingContract) - .callAsync(); - expect(actualHash).to.be.eq(hexUtils.concat(expectedHash)); - } - - describe('_hashEIP712Domain', async () => { - it('should correctly hash empty input', async () => { - await testHashEIP712DomainAsync('', '', 0, constants.NULL_ADDRESS); - }); - - it('should correctly hash non-empty input', async () => { - await testHashEIP712DomainAsync('_hashEIP712Domain', '1.0', 62, lib.address); - }); - - it('should correctly hash non-empty input', async () => { - await testHashEIP712DomainAsync('_hashEIP712Domain', '2.0', 0, lib.address); - }); - }); - - /** - * Tests a specific instance of EIP712 message hashing. - * @param lib The LibEIP712 contract to call. - * @param domainHash The hash of the EIP712 domain of this instance. - * @param hashStruct The hash of the struct of this instance. - */ - async function testHashEIP712MessageAsync(domainHash: string, hashStruct: string): Promise { - // Remove the hex prefix from the domain hash and the hash struct - const unprefixedDomainHash = domainHash.slice(2, domainHash.length); - const unprefixedHashStruct = hashStruct.slice(2, hashStruct.length); - - // Hash the provided input to get the expected hash - const input = '0x1901'.concat(unprefixedDomainHash.concat(unprefixedHashStruct)); - const expectedHash = hexUtils.hash(input); - - // Get the actual hash by calling the smart contract - const actualHash = await lib.externalHashEIP712Message(domainHash, hashStruct).callAsync(); - - // Verify that the actual hash matches the expected hash - expect(actualHash).to.be.eq(expectedHash); - } - - describe('_hashEIP712Message', () => { - it('should correctly hash empty input', async () => { - await testHashEIP712MessageAsync(constants.NULL_BYTES32, constants.NULL_BYTES32); - }); - - it('should correctly hash non-empty input', async () => { - await testHashEIP712MessageAsync( - '0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6', // keccak256(abi.encode(1)) - '0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace', // keccak256(abi.encode(2)) - ); - }); - - it('should correctly hash non-empty input', async () => { - await testHashEIP712MessageAsync( - '0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace', // keccak256(abi.encode(2)) - '0xc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b', // keccak256(abi.encode(3)) - ); - }); - }); -}); diff --git a/contracts/utils/test/lib_math.ts b/contracts/utils/test/lib_math.ts deleted file mode 100644 index fa24a6c67e..0000000000 --- a/contracts/utils/test/lib_math.ts +++ /dev/null @@ -1,421 +0,0 @@ -import { - blockchainTests, - constants, - describe, - expect, - testCombinatoriallyWithReferenceFunc, - uint256Values, -} from '@0x/contracts-test-utils'; -import { BigNumber, LibMathRevertErrors, SafeMathRevertErrors } from '@0x/utils'; - -import { - getPartialAmountCeil, - getPartialAmountFloor, - isRoundingErrorCeil, - isRoundingErrorFloor, - safeGetPartialAmountCeil, - safeGetPartialAmountFloor, -} from '../src/reference_functions'; - -import { artifacts } from './artifacts'; -import { TestLibMathContract } from './wrappers'; - -blockchainTests('LibMath', env => { - const { ONE_ETHER, MAX_UINT256, MAX_UINT256_ROOT, ZERO_AMOUNT } = constants; - let libsContract: TestLibMathContract; - - before(async () => { - libsContract = await TestLibMathContract.deployFrom0xArtifactAsync( - artifacts.TestLibMath, - env.provider, - env.txDefaults, - {}, - ); - }); - - // Wrap a reference function with identical arguments in a promise. - function createAsyncReferenceFunction(ref: (...args: any[]) => T): (...args: any[]) => Promise { - return async (...args: any[]): Promise => { - return ref(...args); - }; - } - - function createContractTestFunction(name: string): (...args: any[]) => Promise { - return async (...args: any[]): Promise => { - return (libsContract as any)[name](...args).callAsync; - }; - } - - describe('getPartialAmountFloor', () => { - describe.optional('combinatorial tests', () => { - testCombinatoriallyWithReferenceFunc( - 'getPartialAmountFloor', - createAsyncReferenceFunction(getPartialAmountFloor), - createContractTestFunction('getPartialAmountFloor'), - [uint256Values, uint256Values, uint256Values], - ); - }); - - describe('explicit tests', () => { - it('matches the reference function output', async () => { - const numerator = ONE_ETHER; - const denominator = ONE_ETHER.dividedToIntegerBy(2); - const target = ONE_ETHER.times(0.01); - const expected = getPartialAmountFloor(numerator, denominator, target); - const actual = await libsContract.getPartialAmountFloor(numerator, denominator, target).callAsync(); - expect(actual).to.bignumber.eq(expected); - }); - - it('rounds down when computing the partial amount', async () => { - const numerator = ONE_ETHER.times(0.6); - const denominator = ONE_ETHER.times(1.8); - const target = ONE_ETHER; - const expected = ONE_ETHER.dividedToIntegerBy(3); - const actual = await libsContract.getPartialAmountFloor(numerator, denominator, target).callAsync(); - expect(actual).to.bignumber.eq(expected); - }); - - it('reverts if `denominator` is zero', async () => { - const numerator = ONE_ETHER; - const denominator = ZERO_AMOUNT; - const target = ONE_ETHER.times(0.01); - const expectedError = new SafeMathRevertErrors.Uint256BinOpError( - SafeMathRevertErrors.BinOpErrorCodes.DivisionByZero, - numerator.times(target), - denominator, - ); - return expect( - libsContract.getPartialAmountFloor(numerator, denominator, target).callAsync(), - ).to.revertWith(expectedError); - }); - - it('reverts if `numerator * target` overflows', async () => { - const numerator = MAX_UINT256; - const denominator = ONE_ETHER.dividedToIntegerBy(2); - const target = MAX_UINT256_ROOT.times(2); - const expectedError = new SafeMathRevertErrors.Uint256BinOpError( - SafeMathRevertErrors.BinOpErrorCodes.MultiplicationOverflow, - numerator, - target, - ); - return expect( - libsContract.getPartialAmountFloor(numerator, denominator, target).callAsync(), - ).to.revertWith(expectedError); - }); - }); - }); - - describe('getPartialAmountCeil', () => { - describe.optional('combinatorial tests', () => { - testCombinatoriallyWithReferenceFunc( - 'getPartialAmountCeil', - createAsyncReferenceFunction(getPartialAmountCeil), - createContractTestFunction('getPartialAmountCeil'), - [uint256Values, uint256Values, uint256Values], - ); - }); - - describe('explicit tests', () => { - it('matches the reference function output', async () => { - const numerator = ONE_ETHER; - const denominator = ONE_ETHER.dividedToIntegerBy(2); - const target = ONE_ETHER.times(0.01); - const expected = getPartialAmountCeil(numerator, denominator, target); - const actual = await libsContract.getPartialAmountCeil(numerator, denominator, target).callAsync(); - expect(actual).to.bignumber.eq(expected); - }); - - it('rounds up when computing the partial amount', async () => { - const numerator = ONE_ETHER.times(0.6); - const denominator = ONE_ETHER.times(1.8); - const target = ONE_ETHER; - const expected = ONE_ETHER.dividedToIntegerBy(3).plus(1); - const actual = await libsContract.getPartialAmountCeil(numerator, denominator, target).callAsync(); - expect(actual).to.bignumber.eq(expected); - }); - - it('reverts if `denominator` is zero', async () => { - const numerator = ONE_ETHER; - const denominator = ZERO_AMOUNT; - const target = ONE_ETHER.times(0.01); - // This will actually manifest as a subtraction underflow. - const expectedError = new SafeMathRevertErrors.Uint256BinOpError( - SafeMathRevertErrors.BinOpErrorCodes.SubtractionUnderflow, - denominator, - new BigNumber(1), - ); - return expect( - libsContract.getPartialAmountCeil(numerator, denominator, target).callAsync(), - ).to.revertWith(expectedError); - }); - - it('reverts if `numerator * target` overflows', async () => { - const numerator = MAX_UINT256; - const denominator = ONE_ETHER.dividedToIntegerBy(2); - const target = MAX_UINT256_ROOT.times(2); - const expectedError = new SafeMathRevertErrors.Uint256BinOpError( - SafeMathRevertErrors.BinOpErrorCodes.MultiplicationOverflow, - numerator, - target, - ); - return expect( - libsContract.getPartialAmountCeil(numerator, denominator, target).callAsync(), - ).to.revertWith(expectedError); - }); - }); - }); - - describe('safeGetPartialAmountFloor', () => { - describe.optional('combinatorial tests', () => { - testCombinatoriallyWithReferenceFunc( - 'safeGetPartialAmountFloor', - createAsyncReferenceFunction(safeGetPartialAmountFloor), - createContractTestFunction('safeGetPartialAmountFloor'), - [uint256Values, uint256Values, uint256Values], - ); - }); - - describe('explicit tests', () => { - it('matches the reference function output', async () => { - const numerator = ONE_ETHER; - const denominator = ONE_ETHER.dividedToIntegerBy(2); - const target = ONE_ETHER.times(0.01); - const expected = safeGetPartialAmountFloor(numerator, denominator, target); - const actual = await libsContract.safeGetPartialAmountFloor(numerator, denominator, target).callAsync(); - expect(actual).to.bignumber.eq(expected); - }); - - it('rounds down when computing the partial amount', async () => { - const numerator = ONE_ETHER.times(0.6); - const denominator = ONE_ETHER.times(1.8); - const target = ONE_ETHER; - const expected = ONE_ETHER.dividedToIntegerBy(3); - const actual = await libsContract.safeGetPartialAmountFloor(numerator, denominator, target).callAsync(); - expect(actual).to.bignumber.eq(expected); - }); - - it('reverts for a rounding error', async () => { - const numerator = new BigNumber(1e3); - const denominator = new BigNumber(1e4); - const target = new BigNumber(333); - const expectedError = new LibMathRevertErrors.RoundingError(numerator, denominator, target); - return expect( - libsContract.safeGetPartialAmountFloor(numerator, denominator, target).callAsync(), - ).to.revertWith(expectedError); - }); - - it('reverts if `denominator` is zero', async () => { - const numerator = ONE_ETHER; - const denominator = ZERO_AMOUNT; - const target = ONE_ETHER.times(0.01); - const expectedError = new LibMathRevertErrors.DivisionByZeroError(); - return expect( - libsContract.safeGetPartialAmountFloor(numerator, denominator, target).callAsync(), - ).to.revertWith(expectedError); - }); - - it('reverts if `numerator * target` overflows', async () => { - const numerator = MAX_UINT256; - const denominator = ONE_ETHER.dividedToIntegerBy(2); - const target = MAX_UINT256_ROOT.times(2); - const expectedError = new SafeMathRevertErrors.Uint256BinOpError( - SafeMathRevertErrors.BinOpErrorCodes.MultiplicationOverflow, - numerator, - target, - ); - return expect( - libsContract.safeGetPartialAmountFloor(numerator, denominator, target).callAsync(), - ).to.revertWith(expectedError); - }); - }); - }); - - describe('safeGetPartialAmountCeil', () => { - describe.optional('combinatorial tests', () => { - testCombinatoriallyWithReferenceFunc( - 'safeGetPartialAmountCeil', - createAsyncReferenceFunction(safeGetPartialAmountCeil), - createContractTestFunction('safeGetPartialAmountCeil'), - [uint256Values, uint256Values, uint256Values], - ); - }); - - describe('explicit tests', () => { - it('matches the reference function output', async () => { - const numerator = ONE_ETHER; - const denominator = ONE_ETHER.dividedToIntegerBy(2); - const target = ONE_ETHER.times(0.01); - const expected = safeGetPartialAmountCeil(numerator, denominator, target); - const actual = await libsContract.safeGetPartialAmountCeil(numerator, denominator, target).callAsync(); - expect(actual).to.bignumber.eq(expected); - }); - - it('rounds up when computing the partial amount', async () => { - const numerator = ONE_ETHER.times(0.6); - const denominator = ONE_ETHER.times(1.8); - const target = ONE_ETHER; - const expected = ONE_ETHER.dividedToIntegerBy(3).plus(1); - const actual = await libsContract.safeGetPartialAmountCeil(numerator, denominator, target).callAsync(); - expect(actual).to.bignumber.eq(expected); - }); - - it('reverts for a rounding error', async () => { - const numerator = new BigNumber(1e3); - const denominator = new BigNumber(1e4); - const target = new BigNumber(333); - const expectedError = new LibMathRevertErrors.RoundingError(numerator, denominator, target); - return expect( - libsContract.safeGetPartialAmountCeil(numerator, denominator, target).callAsync(), - ).to.revertWith(expectedError); - }); - - it('reverts if `denominator` is zero', async () => { - const numerator = ONE_ETHER; - const denominator = ZERO_AMOUNT; - const target = ONE_ETHER.times(0.01); - const expectedError = new LibMathRevertErrors.DivisionByZeroError(); - return expect( - libsContract.safeGetPartialAmountCeil(numerator, denominator, target).callAsync(), - ).to.revertWith(expectedError); - }); - - it('reverts if `numerator * target` overflows', async () => { - const numerator = MAX_UINT256; - const denominator = ONE_ETHER.dividedToIntegerBy(2); - const target = MAX_UINT256_ROOT.times(2); - const expectedError = new SafeMathRevertErrors.Uint256BinOpError( - SafeMathRevertErrors.BinOpErrorCodes.MultiplicationOverflow, - numerator, - target, - ); - return expect( - libsContract.safeGetPartialAmountCeil(numerator, denominator, target).callAsync(), - ).to.revertWith(expectedError); - }); - }); - }); - - describe('isRoundingErrorFloor', () => { - describe.optional('combinatorial tests', () => { - testCombinatoriallyWithReferenceFunc( - 'isRoundingErrorFloor', - createAsyncReferenceFunction(isRoundingErrorFloor), - createContractTestFunction('isRoundingErrorFloor'), - [uint256Values, uint256Values, uint256Values], - ); - }); - - describe('explicit tests', () => { - it('returns true when `numerator * target / denominator` produces an error >= 0.1%', async () => { - const numerator = new BigNumber(100); - const denominator = new BigNumber(102); - const target = new BigNumber(52); - const actual = await libsContract.isRoundingErrorFloor(numerator, denominator, target).callAsync(); - expect(actual).to.eq(true); - }); - - it('returns false when `numerator * target / denominator` produces an error < 0.1%', async () => { - const numerator = new BigNumber(100); - const denominator = new BigNumber(101); - const target = new BigNumber(92); - const actual = await libsContract.isRoundingErrorFloor(numerator, denominator, target).callAsync(); - expect(actual).to.eq(false); - }); - - it('matches the reference function output', async () => { - const numerator = ONE_ETHER; - const denominator = ONE_ETHER.dividedToIntegerBy(2); - const target = ONE_ETHER.times(0.01); - const expected = isRoundingErrorFloor(numerator, denominator, target); - const actual = await libsContract.isRoundingErrorFloor(numerator, denominator, target).callAsync(); - expect(actual).to.eq(expected); - }); - - it('reverts if `denominator` is zero', async () => { - const numerator = ONE_ETHER; - const denominator = ZERO_AMOUNT; - const target = ONE_ETHER.times(0.01); - const expectedError = new LibMathRevertErrors.DivisionByZeroError(); - return expect( - libsContract.isRoundingErrorFloor(numerator, denominator, target).callAsync(), - ).to.revertWith(expectedError); - }); - - it('reverts if `numerator * target` overflows', async () => { - const numerator = MAX_UINT256; - const denominator = ONE_ETHER.dividedToIntegerBy(2); - const target = MAX_UINT256_ROOT.times(2); - const expectedError = new SafeMathRevertErrors.Uint256BinOpError( - SafeMathRevertErrors.BinOpErrorCodes.MultiplicationOverflow, - numerator, - target, - ); - return expect( - libsContract.isRoundingErrorFloor(numerator, denominator, target).callAsync(), - ).to.revertWith(expectedError); - }); - }); - }); - - describe('isRoundingErrorCeil', () => { - describe.optional('combinatorial tests', () => { - testCombinatoriallyWithReferenceFunc( - 'isRoundingErrorCeil', - createAsyncReferenceFunction(isRoundingErrorCeil), - createContractTestFunction('isRoundingErrorCeil'), - [uint256Values, uint256Values, uint256Values], - ); - }); - - describe('explicit tests', () => { - it('returns true when `numerator * target / (denominator - 1)` produces an error >= 0.1%', async () => { - const numerator = new BigNumber(100); - const denominator = new BigNumber(101); - const target = new BigNumber(92); - const actual = await libsContract.isRoundingErrorCeil(numerator, denominator, target).callAsync(); - expect(actual).to.eq(true); - }); - - it('returns false when `numerator * target / (denominator - 1)` produces an error < 0.1%', async () => { - const numerator = new BigNumber(100); - const denominator = new BigNumber(102); - const target = new BigNumber(52); - const actual = await libsContract.isRoundingErrorCeil(numerator, denominator, target).callAsync(); - expect(actual).to.eq(false); - }); - - it('matches the reference function output', async () => { - const numerator = ONE_ETHER; - const denominator = ONE_ETHER.dividedToIntegerBy(2); - const target = ONE_ETHER.times(0.01); - const expected = isRoundingErrorCeil(numerator, denominator, target); - const actual = await libsContract.isRoundingErrorCeil(numerator, denominator, target).callAsync(); - expect(actual).to.eq(expected); - }); - - it('reverts if `denominator` is zero', async () => { - const numerator = ONE_ETHER; - const denominator = ZERO_AMOUNT; - const target = ONE_ETHER.times(0.01); - const expectedError = new LibMathRevertErrors.DivisionByZeroError(); - return expect( - libsContract.isRoundingErrorCeil(numerator, denominator, target).callAsync(), - ).to.revertWith(expectedError); - }); - - it('reverts if `numerator * target` overflows', async () => { - const numerator = MAX_UINT256; - const denominator = ONE_ETHER.dividedToIntegerBy(2); - const target = MAX_UINT256_ROOT.times(2); - const expectedError = new SafeMathRevertErrors.Uint256BinOpError( - SafeMathRevertErrors.BinOpErrorCodes.MultiplicationOverflow, - numerator, - target, - ); - return expect( - libsContract.isRoundingErrorCeil(numerator, denominator, target).callAsync(), - ).to.revertWith(expectedError); - }); - }); - }); -}); diff --git a/contracts/utils/test/log_decoding.ts b/contracts/utils/test/log_decoding.ts deleted file mode 100644 index ae1ea47c77..0000000000 --- a/contracts/utils/test/log_decoding.ts +++ /dev/null @@ -1,98 +0,0 @@ -import { chaiSetup, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils'; -import { BlockchainLifecycle } from '@0x/dev-utils'; -import { BigNumber } from '@0x/utils'; -import * as chai from 'chai'; -import { DecodedLogArgs, LogWithDecodedArgs } from 'ethereum-types'; - -import { artifacts } from './artifacts'; -import { TestLogDecodingContract } from './wrappers'; - -chaiSetup.configure(); -const expect = chai.expect; - -const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper); - -describe('TestLogDecoding', () => { - let testLogDecodingWithDependencies: TestLogDecodingContract; - let testLogDecodingDeployedWithoutDependencies: TestLogDecodingContract; - const expectedEvent = { - foo: new BigNumber(256), - bar: '0x1234', - car: '4321', - }; - const expectedDownstreamEvent = { - lorem: new BigNumber(256), - ipsum: '4321', - }; - const emptyDependencyList = {}; - - before(async () => { - testLogDecodingDeployedWithoutDependencies = await TestLogDecodingContract.deployFrom0xArtifactAsync( - artifacts.TestLogDecoding, - provider, - txDefaults, - emptyDependencyList, - ); - testLogDecodingWithDependencies = await TestLogDecodingContract.deployFrom0xArtifactAsync( - artifacts.TestLogDecoding, - provider, - txDefaults, - artifacts, - ); - }); - beforeEach(async () => { - await blockchainLifecycle.startAsync(); - }); - afterEach(async () => { - await blockchainLifecycle.revertAsync(); - }); - - describe('Decoding Log Arguments', () => { - it('should decode locally emitted event args when no dependencies are passed into wrapper', async () => { - const txReceipt = await testLogDecodingDeployedWithoutDependencies - .emitEvent() - .awaitTransactionSuccessAsync(); - expect(txReceipt.logs.length).to.be.equal(1); - expect((txReceipt.logs[0] as LogWithDecodedArgs).args).to.be.deep.equal(expectedEvent); - }); - it('should not decode event args when no dependencies are passed into wrapper', async () => { - const txReceipt = await testLogDecodingDeployedWithoutDependencies - .emitEventDownstream() - .awaitTransactionSuccessAsync(); - expect(txReceipt.logs.length).to.be.equal(1); - expect((txReceipt.logs[0] as LogWithDecodedArgs).args).to.be.undefined(); - }); - it('should decode args for local but not downstream event when no dependencies are passed into wrapper', async () => { - const txReceipt = await testLogDecodingDeployedWithoutDependencies - .emitEventsLocalAndDownstream() - .awaitTransactionSuccessAsync(); - expect(txReceipt.logs.length).to.be.equal(2); - expect((txReceipt.logs[0] as LogWithDecodedArgs).args).to.be.deep.equal(expectedEvent); - expect((txReceipt.logs[1] as LogWithDecodedArgs).args).to.be.undefined(); - }); - it('should decode locally emitted event args when dependencies are passed into wrapper', async () => { - const txReceipt = await testLogDecodingWithDependencies.emitEvent().awaitTransactionSuccessAsync(); - expect(txReceipt.logs.length).to.be.equal(1); - expect((txReceipt.logs[0] as LogWithDecodedArgs).args).to.be.deep.equal(expectedEvent); - }); - it('should decode downstream event args when dependencies are passed into wrapper', async () => { - const txReceipt = await testLogDecodingWithDependencies - .emitEventDownstream() - .awaitTransactionSuccessAsync(); - expect(txReceipt.logs.length).to.be.equal(1); - expect((txReceipt.logs[0] as LogWithDecodedArgs).args).to.be.deep.equal( - expectedDownstreamEvent, - ); - }); - it('should decode args for both local and downstream events when dependencies are passed into wrapper', async () => { - const txReceipt = await testLogDecodingWithDependencies - .emitEventsLocalAndDownstream() - .awaitTransactionSuccessAsync(); - expect(txReceipt.logs.length).to.be.equal(2); - expect((txReceipt.logs[0] as LogWithDecodedArgs).args).to.be.deep.equal(expectedEvent); - expect((txReceipt.logs[1] as LogWithDecodedArgs).args).to.be.deep.equal( - expectedDownstreamEvent, - ); - }); - }); -}); diff --git a/contracts/utils/test/refundable.ts b/contracts/utils/test/refundable.ts deleted file mode 100644 index 2a6ce57df6..0000000000 --- a/contracts/utils/test/refundable.ts +++ /dev/null @@ -1,141 +0,0 @@ -import { blockchainTests, constants } from '@0x/contracts-test-utils'; -import { BigNumber } from '@0x/utils'; -import * as _ from 'lodash'; - -import { artifacts } from './artifacts'; -import { TestRefundableContract, TestRefundableReceiverContract } from './wrappers'; - -blockchainTests('Refundable', env => { - let refundable: TestRefundableContract; - let receiver: TestRefundableReceiverContract; - - const ONE_HUNDRED = new BigNumber(100); - const ONE_THOUSAND = new BigNumber(1000); - - before(async () => { - // Create the refundable contract. - refundable = await TestRefundableContract.deployFrom0xArtifactAsync( - artifacts.TestRefundable, - env.provider, - env.txDefaults, - {}, - ); - - // Create the receiver contract. - receiver = await TestRefundableReceiverContract.deployFrom0xArtifactAsync( - artifacts.TestRefundableReceiver, - env.provider, - env.txDefaults, - {}, - ); - }); - - // The contents of these typescript tests is not adequate to understand the assertions that are made during - // these calls. For a more accurate picture, checkout out "./contracts/test/TestRefundableReceiver.sol". Specifically, - // the function `testRefundNonzeroBalance()` is used in this test suite. - blockchainTests.resets('refundNonzeroBalance', () => { - it('should not send a refund when no value is sent', async () => { - // Send 100 wei to the refundable contract that should be refunded. - await receiver.testRefundNonZeroBalance(refundable.address).awaitTransactionSuccessAsync({ - value: constants.ZERO_AMOUNT, - }); - }); - - it('should send a full refund when nonzero value is sent', async () => { - // Send 100 wei to the refundable contract that should be refunded. - await receiver.testRefundNonZeroBalance(refundable.address).awaitTransactionSuccessAsync({ - value: ONE_HUNDRED, - }); - }); - }); - - // The contents of these typescript tests is not adequate to understand the assertions that are made during - // these calls. For a more accurate picture, checkout out "./contracts/test/TestRefundableReceiver.sol". - blockchainTests.resets('refundFinalBalance', () => { - it('should fully refund the sender when `shouldNotRefund` is false', async () => { - // Send 100 wei to the refundable contract that should be refunded to the receiver contract. - await receiver.testRefundFinalBalance(refundable.address, false).awaitTransactionSuccessAsync({ - value: ONE_HUNDRED, - }); - }); - - // This test may not be necessary, but it is included here as a sanity check. - it('should fully refund the sender when `shouldNotRefund` is false for two calls in a row', async () => { - // Send 100 wei to the refundable contract that should be refunded to the receiver contract. - await receiver.testRefundFinalBalance(refundable.address, false).awaitTransactionSuccessAsync({ - value: ONE_HUNDRED, - }); - - // Send 1000 wei to the refundable contract that should be refunded to the receiver contract. - await receiver.testRefundFinalBalance(refundable.address, false).awaitTransactionSuccessAsync({ - value: new BigNumber(1000), - }); - }); - - it('should not refund the sender if `shouldNotRefund` is true', async () => { - /// Send 100 wei to the refundable contract that should not be refunded. - await receiver.testRefundFinalBalance(refundable.address, true).awaitTransactionSuccessAsync({ - value: new BigNumber(1000), - }); - }); - }); - - // The contents of these typescript tests is not adequate to understand the assertions that are made during - // these calls. For a more accurate picture, checkout out "./contracts/test/TestRefundableReceiver.sol". - blockchainTests.resets('disableRefundUntilEnd', () => { - it('should fully refund the sender when `shouldNotRefund` is false', async () => { - // Send 100 wei to the refundable contract that should be refunded to the receiver contract. - await receiver.testDisableRefundUntilEnd(refundable.address, false).awaitTransactionSuccessAsync({ - value: ONE_HUNDRED, - }); - }); - - // This test may not be necessary, but it is included here as a sanity check. - it('should fully refund the sender when `shouldNotRefund` is false for two calls in a row', async () => { - // Send 100 wei to the refundable contract that should be refunded to the receiver contract. - await receiver.testDisableRefundUntilEnd(refundable.address, false).awaitTransactionSuccessAsync({ - value: ONE_HUNDRED, - }); - - // Send 1000 wei to the refundable contract that should be refunded to the receiver contract. - await receiver.testDisableRefundUntilEnd(refundable.address, false).awaitTransactionSuccessAsync({ - value: ONE_THOUSAND, - }); - }); - - it('should not refund the sender if `shouldNotRefund` is true', async () => { - /// Send 100 wei to the refundable contract that should not be refunded. - await receiver.testDisableRefundUntilEnd(refundable.address, false).awaitTransactionSuccessAsync({ - value: ONE_HUNDRED, - }); - }); - - it('should disable the `disableRefundUntilEnd` modifier and refund when `shouldNotRefund` is false', async () => { - /// Send 100 wei to the refundable contract that should be refunded. - await receiver.testNestedDisableRefundUntilEnd(refundable.address, false).awaitTransactionSuccessAsync({ - value: ONE_HUNDRED, - }); - }); - - it('should disable the `refundFinalBalance` modifier and send no refund when `shouldNotRefund` is true', async () => { - /// Send 100 wei to the refundable contract that should not be refunded. - await receiver.testNestedDisableRefundUntilEnd(refundable.address, true).awaitTransactionSuccessAsync({ - value: ONE_HUNDRED, - }); - }); - - it('should disable the `refundFinalBalance` modifier and refund when `shouldNotRefund` is false', async () => { - /// Send 100 wei to the refundable contract that should be refunded. - await receiver.testMixedRefunds(refundable.address, false).awaitTransactionSuccessAsync({ - value: ONE_HUNDRED, - }); - }); - - it('should disable the `refundFinalBalance` modifier and send no refund when `shouldNotRefund` is true', async () => { - /// Send 100 wei to the refundable contract that should not be refunded. - await receiver.testMixedRefunds(refundable.address, true).awaitTransactionSuccessAsync({ - value: ONE_HUNDRED, - }); - }); - }); -}); diff --git a/contracts/utils/test/wrappers.ts b/contracts/utils/test/wrappers.ts index 0400162154..04ec520394 100644 --- a/contracts/utils/test/wrappers.ts +++ b/contracts/utils/test/wrappers.ts @@ -3,21 +3,13 @@ * Warning: This file is auto-generated by contracts-gen. Don't edit manually. * ----------------------------------------------------------------------------- */ -export * from '../test/generated-wrappers/authorizable'; export * from '../test/generated-wrappers/authorizable_v06'; export * from '../test/generated-wrappers/authorizable_v08'; -export * from '../test/generated-wrappers/d18'; -export * from '../test/generated-wrappers/deployment_constants'; -export * from '../test/generated-wrappers/i_authorizable'; export * from '../test/generated-wrappers/i_authorizable_v06'; export * from '../test/generated-wrappers/i_authorizable_v08'; export * from '../test/generated-wrappers/i_ownable'; export * from '../test/generated-wrappers/i_ownable_v06'; export * from '../test/generated-wrappers/i_ownable_v08'; -export * from '../test/generated-wrappers/lib_address'; -export * from '../test/generated-wrappers/lib_address_array'; -export * from '../test/generated-wrappers/lib_address_array_rich_errors'; -export * from '../test/generated-wrappers/lib_authorizable_rich_errors'; export * from '../test/generated-wrappers/lib_authorizable_rich_errors_v06'; export * from '../test/generated-wrappers/lib_authorizable_rich_errors_v08'; export * from '../test/generated-wrappers/lib_bytes'; @@ -26,11 +18,6 @@ export * from '../test/generated-wrappers/lib_bytes_rich_errors_v06'; export * from '../test/generated-wrappers/lib_bytes_rich_errors_v08'; export * from '../test/generated-wrappers/lib_bytes_v06'; export * from '../test/generated-wrappers/lib_bytes_v08'; -export * from '../test/generated-wrappers/lib_e_i_p1271'; -export * from '../test/generated-wrappers/lib_e_i_p712'; -export * from '../test/generated-wrappers/lib_fractions'; -export * from '../test/generated-wrappers/lib_math'; -export * from '../test/generated-wrappers/lib_math_rich_errors'; export * from '../test/generated-wrappers/lib_math_rich_errors_v06'; export * from '../test/generated-wrappers/lib_math_rich_errors_v08'; export * from '../test/generated-wrappers/lib_math_v06'; @@ -53,20 +40,9 @@ export * from '../test/generated-wrappers/ownable'; export * from '../test/generated-wrappers/ownable_v06'; export * from '../test/generated-wrappers/ownable_v08'; export * from '../test/generated-wrappers/reentrancy_guard'; -export * from '../test/generated-wrappers/reentrancy_guard_v06'; export * from '../test/generated-wrappers/reentrancy_guard_v08'; -export * from '../test/generated-wrappers/refundable'; -export * from '../test/generated-wrappers/test_authorizable'; -export * from '../test/generated-wrappers/test_lib_address'; -export * from '../test/generated-wrappers/test_lib_address_array'; export * from '../test/generated-wrappers/test_lib_bytes'; -export * from '../test/generated-wrappers/test_lib_e_i_p712'; -export * from '../test/generated-wrappers/test_lib_math'; export * from '../test/generated-wrappers/test_lib_rich_errors'; export * from '../test/generated-wrappers/test_lib_safe_math'; -export * from '../test/generated-wrappers/test_log_decoding'; -export * from '../test/generated-wrappers/test_log_decoding_downstream'; export * from '../test/generated-wrappers/test_ownable'; export * from '../test/generated-wrappers/test_reentrancy_guard'; -export * from '../test/generated-wrappers/test_refundable'; -export * from '../test/generated-wrappers/test_refundable_receiver'; diff --git a/contracts/utils/tsconfig.json b/contracts/utils/tsconfig.json index 36c7fc7d26..ef06564fe9 100644 --- a/contracts/utils/tsconfig.json +++ b/contracts/utils/tsconfig.json @@ -3,20 +3,9 @@ "compilerOptions": { "outDir": "lib", "rootDir": ".", "resolveJsonModule": true }, "include": ["./src/**/*", "./test/**/*", "./generated-wrappers/**/*"], "files": [ - "generated-artifacts/Authorizable.json", - "generated-artifacts/IAuthorizable.json", "generated-artifacts/IOwnable.json", - "generated-artifacts/LibAddress.json", - "generated-artifacts/LibAddressArray.json", - "generated-artifacts/LibAddressArrayRichErrors.json", - "generated-artifacts/LibAuthorizableRichErrors.json", "generated-artifacts/LibBytes.json", "generated-artifacts/LibBytesRichErrors.json", - "generated-artifacts/LibEIP1271.json", - "generated-artifacts/LibEIP712.json", - "generated-artifacts/LibFractions.json", - "generated-artifacts/LibMath.json", - "generated-artifacts/LibMathRichErrors.json", "generated-artifacts/LibOwnableRichErrors.json", "generated-artifacts/LibReentrancyGuardRichErrors.json", "generated-artifacts/LibRichErrors.json", @@ -24,22 +13,13 @@ "generated-artifacts/LibSafeMathRichErrors.json", "generated-artifacts/Ownable.json", "generated-artifacts/ReentrancyGuard.json", - "generated-artifacts/Refundable.json", - "test/generated-artifacts/Authorizable.json", "test/generated-artifacts/AuthorizableV06.json", "test/generated-artifacts/AuthorizableV08.json", - "test/generated-artifacts/D18.json", - "test/generated-artifacts/DeploymentConstants.json", - "test/generated-artifacts/IAuthorizable.json", "test/generated-artifacts/IAuthorizableV06.json", "test/generated-artifacts/IAuthorizableV08.json", "test/generated-artifacts/IOwnable.json", "test/generated-artifacts/IOwnableV06.json", "test/generated-artifacts/IOwnableV08.json", - "test/generated-artifacts/LibAddress.json", - "test/generated-artifacts/LibAddressArray.json", - "test/generated-artifacts/LibAddressArrayRichErrors.json", - "test/generated-artifacts/LibAuthorizableRichErrors.json", "test/generated-artifacts/LibAuthorizableRichErrorsV06.json", "test/generated-artifacts/LibAuthorizableRichErrorsV08.json", "test/generated-artifacts/LibBytes.json", @@ -48,11 +28,6 @@ "test/generated-artifacts/LibBytesRichErrorsV08.json", "test/generated-artifacts/LibBytesV06.json", "test/generated-artifacts/LibBytesV08.json", - "test/generated-artifacts/LibEIP1271.json", - "test/generated-artifacts/LibEIP712.json", - "test/generated-artifacts/LibFractions.json", - "test/generated-artifacts/LibMath.json", - "test/generated-artifacts/LibMathRichErrors.json", "test/generated-artifacts/LibMathRichErrorsV06.json", "test/generated-artifacts/LibMathRichErrorsV08.json", "test/generated-artifacts/LibMathV06.json", @@ -75,23 +50,12 @@ "test/generated-artifacts/OwnableV06.json", "test/generated-artifacts/OwnableV08.json", "test/generated-artifacts/ReentrancyGuard.json", - "test/generated-artifacts/ReentrancyGuardV06.json", "test/generated-artifacts/ReentrancyGuardV08.json", - "test/generated-artifacts/Refundable.json", - "test/generated-artifacts/TestAuthorizable.json", - "test/generated-artifacts/TestLibAddress.json", - "test/generated-artifacts/TestLibAddressArray.json", "test/generated-artifacts/TestLibBytes.json", - "test/generated-artifacts/TestLibEIP712.json", - "test/generated-artifacts/TestLibMath.json", "test/generated-artifacts/TestLibRichErrors.json", "test/generated-artifacts/TestLibSafeMath.json", - "test/generated-artifacts/TestLogDecoding.json", - "test/generated-artifacts/TestLogDecodingDownstream.json", "test/generated-artifacts/TestOwnable.json", - "test/generated-artifacts/TestReentrancyGuard.json", - "test/generated-artifacts/TestRefundable.json", - "test/generated-artifacts/TestRefundableReceiver.json" + "test/generated-artifacts/TestReentrancyGuard.json" ], "exclude": ["./deploy/solc/solc_bin"] }