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

Remove obsoleted code from 0x/contracts-utils (#643)

Browse Source 
* Remove TestAuthorizable

* Remove contracts/utils Authorizable and IAuthorizable

* Remove contracts/utils D18 contract

* Remove contracts/utils LibAddress contracts

* Remove contracts/utils LogDecoding contracts

* Remove contracts/utils Refundable contracts

* Remove contracts/utils LibAuthorizableRichErrors contracts

* Remove contracts/utils EIP712 contracts

* Remove contracts/utils TestRefundableReceiver contracts

* Remove contracts/utils EIP1271 contracts

* Remove contracts/utils ReentrancyGuardV06 contracts

* Remove contracts/utils LibMath contracts

* Remove contracts/utils LibFractions contracts

* Remove contracts/utils LibMathRichErrors contracts

* Remove DeploymentConstants as per PR review
https://github.com/0xProject/protocol/pull/643#pullrequestreview-1264963784
This commit is contained in:
Elena 2023-02-06 19:35:39 +02:00 committed by GitHub
parent a472125c65
commit c4b1f043c6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
39 changed files with 3 additions and 3322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
contracts/test-utils/src/types.ts
View File

@ -90,7 +90,6 @@ export enum ContractName {
DummyERC721Token = 'DummyERC721Token', DummyERC721Token = 'DummyERC721Token',
TestLibBytes = 'TestLibBytes', TestLibBytes = 'TestLibBytes',
TestWallet = 'TestWallet', TestWallet = 'TestWallet',
Authorizable = 'Authorizable',
Whitelist = 'Whitelist', Whitelist = 'Whitelist',
Forwarder = 'Forwarder', Forwarder = 'Forwarder',
BalanceThresholdFilter = 'BalanceThresholdFilter', BalanceThresholdFilter = 'BalanceThresholdFilter',

122
contracts/utils/contracts/src/Authorizable.sol
View File

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

159
contracts/utils/contracts/src/D18.sol
View File

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

251
contracts/utils/contracts/src/DeploymentConstants.sol
View File

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

46
contracts/utils/contracts/src/LibAddress.sol
View File

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

153
contracts/utils/contracts/src/LibAddressArray.sol
View File

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

31
contracts/utils/contracts/src/LibAddressArrayRichErrors.sol
View File

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

63
contracts/utils/contracts/src/LibAuthorizableRichErrors.sol
View File

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

25
contracts/utils/contracts/src/LibEIP1271.sol
View File

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

103
contracts/utils/contracts/src/LibEIP712.sol
View File

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

96
contracts/utils/contracts/src/LibFractions.sol
View File

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

174
contracts/utils/contracts/src/LibMath.sol
View File

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

21
contracts/utils/contracts/src/LibMathRichErrors.sol
View File

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

74
contracts/utils/contracts/src/Refundable.sol
View File

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

46
contracts/utils/contracts/src/interfaces/IAuthorizable.sol
View File

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

50
contracts/utils/contracts/src/v06/ReentrancyGuardV06.sol
View File

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

25
contracts/utils/contracts/test/TestAuthorizable.sol
View File

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

29
contracts/utils/contracts/test/TestLibAddress.sol
View File

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

89
contracts/utils/contracts/test/TestLibAddressArray.sol
View File

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

36
contracts/utils/contracts/test/TestLibEIP712.sol
View File

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

104
contracts/utils/contracts/test/TestLibMath.sol
View File

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

43
contracts/utils/contracts/test/TestLogDecoding.sol
View File

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

37
contracts/utils/contracts/test/TestLogDecodingDownstream.sol
View File

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

49
contracts/utils/contracts/test/TestRefundable.sol
View File

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

154
contracts/utils/contracts/test/TestRefundableReceiver.sol
View File

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

4
contracts/utils/package.json
View File

@ -30,9 +30,9 @@
"contracts:copy": "contracts-gen copy" "contracts:copy": "contracts-gen copy"
}, },
"config": { "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: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": { "repository": {
"type": "git", "type": "git",

24
contracts/utils/src/artifacts.ts
View File

@ -5,20 +5,9 @@
*/ */
import { ContractArtifact } from 'ethereum-types'; 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 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 LibBytes from '../generated-artifacts/LibBytes.json';
import * as LibBytesRichErrors from '../generated-artifacts/LibBytesRichErrors.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 LibOwnableRichErrors from '../generated-artifacts/LibOwnableRichErrors.json';
import * as LibReentrancyGuardRichErrors from '../generated-artifacts/LibReentrancyGuardRichErrors.json'; import * as LibReentrancyGuardRichErrors from '../generated-artifacts/LibReentrancyGuardRichErrors.json';
import * as LibRichErrors from '../generated-artifacts/LibRichErrors.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 LibSafeMathRichErrors from '../generated-artifacts/LibSafeMathRichErrors.json';
import * as Ownable from '../generated-artifacts/Ownable.json'; import * as Ownable from '../generated-artifacts/Ownable.json';
import * as ReentrancyGuard from '../generated-artifacts/ReentrancyGuard.json'; import * as ReentrancyGuard from '../generated-artifacts/ReentrancyGuard.json';
import * as Refundable from '../generated-artifacts/Refundable.json';
export const artifacts = { export const artifacts = {
Authorizable: Authorizable as ContractArtifact,
IAuthorizable: IAuthorizable as ContractArtifact,
IOwnable: IOwnable 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, LibBytes: LibBytes as ContractArtifact,
LibBytesRichErrors: LibBytesRichErrors as ContractArtifact, LibBytesRichErrors: LibBytesRichErrors as ContractArtifact,
LibEIP1271: LibEIP1271 as ContractArtifact,
LibEIP712: LibEIP712 as ContractArtifact,
LibFractions: LibFractions as ContractArtifact,
LibOwnableRichErrors: LibOwnableRichErrors as ContractArtifact, LibOwnableRichErrors: LibOwnableRichErrors as ContractArtifact,
LibReentrancyGuardRichErrors: LibReentrancyGuardRichErrors as ContractArtifact, LibReentrancyGuardRichErrors: LibReentrancyGuardRichErrors as ContractArtifact,
LibRichErrors: LibRichErrors as ContractArtifact, LibRichErrors: LibRichErrors as ContractArtifact,
LibMath: LibMath as ContractArtifact,
LibMathRichErrors: LibMathRichErrors as ContractArtifact,
LibSafeMath: LibSafeMath as ContractArtifact, LibSafeMath: LibSafeMath as ContractArtifact,
LibSafeMathRichErrors: LibSafeMathRichErrors as ContractArtifact, LibSafeMathRichErrors: LibSafeMathRichErrors as ContractArtifact,
Ownable: Ownable as ContractArtifact, Ownable: Ownable as ContractArtifact,
ReentrancyGuard: ReentrancyGuard as ContractArtifact, ReentrancyGuard: ReentrancyGuard as ContractArtifact,
Refundable: Refundable as ContractArtifact,
}; };

74
contracts/utils/src/reference_functions.ts
View File

@ -52,77 +52,3 @@ export function safeDiv(a: BigNumber, b: BigNumber): BigNumber {
} }
return a.dividedToIntegerBy(b); 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);
}

12
contracts/utils/src/wrappers.ts
View File

@ -3,20 +3,9 @@
* Warning: This file is auto-generated by contracts-gen. Don't edit manually. * 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/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';
export * from '../generated-wrappers/lib_bytes_rich_errors'; 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_ownable_rich_errors';
export * from '../generated-wrappers/lib_reentrancy_guard_rich_errors'; export * from '../generated-wrappers/lib_reentrancy_guard_rich_errors';
export * from '../generated-wrappers/lib_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/lib_safe_math_rich_errors';
export * from '../generated-wrappers/ownable'; export * from '../generated-wrappers/ownable';
export * from '../generated-wrappers/reentrancy_guard'; export * from '../generated-wrappers/reentrancy_guard';
export * from '../generated-wrappers/refundable';

48
contracts/utils/test/artifacts.ts
View File

@ -5,21 +5,13 @@
*/ */
import { ContractArtifact } from 'ethereum-types'; 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 AuthorizableV06 from '../test/generated-artifacts/AuthorizableV06.json';
import * as AuthorizableV08 from '../test/generated-artifacts/AuthorizableV08.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 IAuthorizableV06 from '../test/generated-artifacts/IAuthorizableV06.json';
import * as IAuthorizableV08 from '../test/generated-artifacts/IAuthorizableV08.json'; import * as IAuthorizableV08 from '../test/generated-artifacts/IAuthorizableV08.json';
import * as IOwnable from '../test/generated-artifacts/IOwnable.json'; import * as IOwnable from '../test/generated-artifacts/IOwnable.json';
import * as IOwnableV06 from '../test/generated-artifacts/IOwnableV06.json'; import * as IOwnableV06 from '../test/generated-artifacts/IOwnableV06.json';
import * as IOwnableV08 from '../test/generated-artifacts/IOwnableV08.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 LibAuthorizableRichErrorsV06 from '../test/generated-artifacts/LibAuthorizableRichErrorsV06.json';
import * as LibAuthorizableRichErrorsV08 from '../test/generated-artifacts/LibAuthorizableRichErrorsV08.json'; import * as LibAuthorizableRichErrorsV08 from '../test/generated-artifacts/LibAuthorizableRichErrorsV08.json';
import * as LibBytes from '../test/generated-artifacts/LibBytes.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 LibBytesRichErrorsV08 from '../test/generated-artifacts/LibBytesRichErrorsV08.json';
import * as LibBytesV06 from '../test/generated-artifacts/LibBytesV06.json'; import * as LibBytesV06 from '../test/generated-artifacts/LibBytesV06.json';
import * as LibBytesV08 from '../test/generated-artifacts/LibBytesV08.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 LibMathRichErrorsV06 from '../test/generated-artifacts/LibMathRichErrorsV06.json';
import * as LibMathRichErrorsV08 from '../test/generated-artifacts/LibMathRichErrorsV08.json'; import * as LibMathRichErrorsV08 from '../test/generated-artifacts/LibMathRichErrorsV08.json';
import * as LibMathV06 from '../test/generated-artifacts/LibMathV06.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 OwnableV06 from '../test/generated-artifacts/OwnableV06.json';
import * as OwnableV08 from '../test/generated-artifacts/OwnableV08.json'; import * as OwnableV08 from '../test/generated-artifacts/OwnableV08.json';
import * as ReentrancyGuard from '../test/generated-artifacts/ReentrancyGuard.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 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 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 TestLibRichErrors from '../test/generated-artifacts/TestLibRichErrors.json';
import * as TestLibSafeMath from '../test/generated-artifacts/TestLibSafeMath.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 TestOwnable from '../test/generated-artifacts/TestOwnable.json';
import * as TestReentrancyGuard from '../test/generated-artifacts/TestReentrancyGuard.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 = { 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, LibBytes: LibBytes as ContractArtifact,
LibBytesRichErrors: LibBytesRichErrors 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, LibOwnableRichErrors: LibOwnableRichErrors as ContractArtifact,
LibReentrancyGuardRichErrors: LibReentrancyGuardRichErrors as ContractArtifact, LibReentrancyGuardRichErrors: LibReentrancyGuardRichErrors as ContractArtifact,
LibRichErrors: LibRichErrors as ContractArtifact, LibRichErrors: LibRichErrors as ContractArtifact,
@ -94,15 +58,12 @@ export const artifacts = {
LibSafeMathRichErrors: LibSafeMathRichErrors as ContractArtifact, LibSafeMathRichErrors: LibSafeMathRichErrors as ContractArtifact,
Ownable: Ownable as ContractArtifact, Ownable: Ownable as ContractArtifact,
ReentrancyGuard: ReentrancyGuard as ContractArtifact, ReentrancyGuard: ReentrancyGuard as ContractArtifact,
Refundable: Refundable as ContractArtifact,
IAuthorizable: IAuthorizable as ContractArtifact,
IOwnable: IOwnable as ContractArtifact, IOwnable: IOwnable as ContractArtifact,
AuthorizableV06: AuthorizableV06 as ContractArtifact, AuthorizableV06: AuthorizableV06 as ContractArtifact,
LibBytesV06: LibBytesV06 as ContractArtifact, LibBytesV06: LibBytesV06 as ContractArtifact,
LibMathV06: LibMathV06 as ContractArtifact, LibMathV06: LibMathV06 as ContractArtifact,
LibSafeMathV06: LibSafeMathV06 as ContractArtifact, LibSafeMathV06: LibSafeMathV06 as ContractArtifact,
OwnableV06: OwnableV06 as ContractArtifact, OwnableV06: OwnableV06 as ContractArtifact,
ReentrancyGuardV06: ReentrancyGuardV06 as ContractArtifact,
LibAuthorizableRichErrorsV06: LibAuthorizableRichErrorsV06 as ContractArtifact, LibAuthorizableRichErrorsV06: LibAuthorizableRichErrorsV06 as ContractArtifact,
LibBytesRichErrorsV06: LibBytesRichErrorsV06 as ContractArtifact, LibBytesRichErrorsV06: LibBytesRichErrorsV06 as ContractArtifact,
LibMathRichErrorsV06: LibMathRichErrorsV06 as ContractArtifact, LibMathRichErrorsV06: LibMathRichErrorsV06 as ContractArtifact,
@ -126,18 +87,9 @@ export const artifacts = {
LibSafeMathRichErrorsV08: LibSafeMathRichErrorsV08 as ContractArtifact, LibSafeMathRichErrorsV08: LibSafeMathRichErrorsV08 as ContractArtifact,
IAuthorizableV08: IAuthorizableV08 as ContractArtifact, IAuthorizableV08: IAuthorizableV08 as ContractArtifact,
IOwnableV08: IOwnableV08 as ContractArtifact, IOwnableV08: IOwnableV08 as ContractArtifact,
TestAuthorizable: TestAuthorizable as ContractArtifact,
TestLibAddress: TestLibAddress as ContractArtifact,
TestLibAddressArray: TestLibAddressArray as ContractArtifact,
TestLibBytes: TestLibBytes as ContractArtifact, TestLibBytes: TestLibBytes as ContractArtifact,
TestLibEIP712: TestLibEIP712 as ContractArtifact,
TestLibMath: TestLibMath as ContractArtifact,
TestLibRichErrors: TestLibRichErrors as ContractArtifact, TestLibRichErrors: TestLibRichErrors as ContractArtifact,
TestLibSafeMath: TestLibSafeMath as ContractArtifact, TestLibSafeMath: TestLibSafeMath as ContractArtifact,
TestLogDecoding: TestLogDecoding as ContractArtifact,
TestLogDecodingDownstream: TestLogDecodingDownstream as ContractArtifact,
TestOwnable: TestOwnable as ContractArtifact, TestOwnable: TestOwnable as ContractArtifact,
TestReentrancyGuard: TestReentrancyGuard as ContractArtifact, TestReentrancyGuard: TestReentrancyGuard as ContractArtifact,
TestRefundable: TestRefundable as ContractArtifact,
TestRefundableReceiver: TestRefundableReceiver as ContractArtifact,
}; };

165
contracts/utils/test/authorizable.ts
View File

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

43
contracts/utils/test/lib_address.ts
View File

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

144
contracts/utils/test/lib_address_array.ts
View File

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

108
contracts/utils/test/lib_eip712.ts
View File

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

421
contracts/utils/test/lib_math.ts
View File

@ -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<T>(ref: (...args: any[]) => T): (...args: any[]) => Promise<T> {
return async (...args: any[]): Promise<T> => {
return ref(...args);
};
}
function createContractTestFunction<T>(name: string): (...args: any[]) => Promise<T> {
return async (...args: any[]): Promise<T> => {
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);
});
});
});
});

98
contracts/utils/test/log_decoding.ts
View File

@ -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<DecodedLogArgs>).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<DecodedLogArgs>).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<DecodedLogArgs>).args).to.be.deep.equal(expectedEvent);
expect((txReceipt.logs[1] as LogWithDecodedArgs<DecodedLogArgs>).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<DecodedLogArgs>).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<DecodedLogArgs>).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<DecodedLogArgs>).args).to.be.deep.equal(expectedEvent);
expect((txReceipt.logs[1] as LogWithDecodedArgs<DecodedLogArgs>).args).to.be.deep.equal(
expectedDownstreamEvent,
);
});
});
});

141
contracts/utils/test/refundable.ts
View File

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

24
contracts/utils/test/wrappers.ts
View File

@ -3,21 +3,13 @@
* Warning: This file is auto-generated by contracts-gen. Don't edit manually. * 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_v06';
export * from '../test/generated-wrappers/authorizable_v08'; 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_v06';
export * from '../test/generated-wrappers/i_authorizable_v08'; export * from '../test/generated-wrappers/i_authorizable_v08';
export * from '../test/generated-wrappers/i_ownable'; export * from '../test/generated-wrappers/i_ownable';
export * from '../test/generated-wrappers/i_ownable_v06'; export * from '../test/generated-wrappers/i_ownable_v06';
export * from '../test/generated-wrappers/i_ownable_v08'; 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_v06';
export * from '../test/generated-wrappers/lib_authorizable_rich_errors_v08'; export * from '../test/generated-wrappers/lib_authorizable_rich_errors_v08';
export * from '../test/generated-wrappers/lib_bytes'; 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_rich_errors_v08';
export * from '../test/generated-wrappers/lib_bytes_v06'; export * from '../test/generated-wrappers/lib_bytes_v06';
export * from '../test/generated-wrappers/lib_bytes_v08'; 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_v06';
export * from '../test/generated-wrappers/lib_math_rich_errors_v08'; export * from '../test/generated-wrappers/lib_math_rich_errors_v08';
export * from '../test/generated-wrappers/lib_math_v06'; 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_v06';
export * from '../test/generated-wrappers/ownable_v08'; export * from '../test/generated-wrappers/ownable_v08';
export * from '../test/generated-wrappers/reentrancy_guard'; 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/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_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_rich_errors';
export * from '../test/generated-wrappers/test_lib_safe_math'; 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_ownable';
export * from '../test/generated-wrappers/test_reentrancy_guard'; export * from '../test/generated-wrappers/test_reentrancy_guard';
export * from '../test/generated-wrappers/test_refundable';
export * from '../test/generated-wrappers/test_refundable_receiver';

38
contracts/utils/tsconfig.json
View File

@ -3,20 +3,9 @@
"compilerOptions": { "outDir": "lib", "rootDir": ".", "resolveJsonModule": true }, "compilerOptions": { "outDir": "lib", "rootDir": ".", "resolveJsonModule": true },
"include": ["./src/**/*", "./test/**/*", "./generated-wrappers/**/*"], "include": ["./src/**/*", "./test/**/*", "./generated-wrappers/**/*"],
"files": [ "files": [
"generated-artifacts/Authorizable.json",
"generated-artifacts/IAuthorizable.json",
"generated-artifacts/IOwnable.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/LibBytes.json",
"generated-artifacts/LibBytesRichErrors.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/LibOwnableRichErrors.json",
"generated-artifacts/LibReentrancyGuardRichErrors.json", "generated-artifacts/LibReentrancyGuardRichErrors.json",
"generated-artifacts/LibRichErrors.json", "generated-artifacts/LibRichErrors.json",
@ -24,22 +13,13 @@
"generated-artifacts/LibSafeMathRichErrors.json", "generated-artifacts/LibSafeMathRichErrors.json",
"generated-artifacts/Ownable.json", "generated-artifacts/Ownable.json",
"generated-artifacts/ReentrancyGuard.json", "generated-artifacts/ReentrancyGuard.json",
"generated-artifacts/Refundable.json",
"test/generated-artifacts/Authorizable.json",
"test/generated-artifacts/AuthorizableV06.json", "test/generated-artifacts/AuthorizableV06.json",
"test/generated-artifacts/AuthorizableV08.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/IAuthorizableV06.json",
"test/generated-artifacts/IAuthorizableV08.json", "test/generated-artifacts/IAuthorizableV08.json",
"test/generated-artifacts/IOwnable.json", "test/generated-artifacts/IOwnable.json",
"test/generated-artifacts/IOwnableV06.json", "test/generated-artifacts/IOwnableV06.json",
"test/generated-artifacts/IOwnableV08.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/LibAuthorizableRichErrorsV06.json",
"test/generated-artifacts/LibAuthorizableRichErrorsV08.json", "test/generated-artifacts/LibAuthorizableRichErrorsV08.json",
"test/generated-artifacts/LibBytes.json", "test/generated-artifacts/LibBytes.json",
@ -48,11 +28,6 @@
"test/generated-artifacts/LibBytesRichErrorsV08.json", "test/generated-artifacts/LibBytesRichErrorsV08.json",
"test/generated-artifacts/LibBytesV06.json", "test/generated-artifacts/LibBytesV06.json",
"test/generated-artifacts/LibBytesV08.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/LibMathRichErrorsV06.json",
"test/generated-artifacts/LibMathRichErrorsV08.json", "test/generated-artifacts/LibMathRichErrorsV08.json",
"test/generated-artifacts/LibMathV06.json", "test/generated-artifacts/LibMathV06.json",
@ -75,23 +50,12 @@
"test/generated-artifacts/OwnableV06.json", "test/generated-artifacts/OwnableV06.json",
"test/generated-artifacts/OwnableV08.json", "test/generated-artifacts/OwnableV08.json",
"test/generated-artifacts/ReentrancyGuard.json", "test/generated-artifacts/ReentrancyGuard.json",
"test/generated-artifacts/ReentrancyGuardV06.json",
"test/generated-artifacts/ReentrancyGuardV08.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/TestLibBytes.json",
"test/generated-artifacts/TestLibEIP712.json",
"test/generated-artifacts/TestLibMath.json",
"test/generated-artifacts/TestLibRichErrors.json", "test/generated-artifacts/TestLibRichErrors.json",
"test/generated-artifacts/TestLibSafeMath.json", "test/generated-artifacts/TestLibSafeMath.json",
"test/generated-artifacts/TestLogDecoding.json",
"test/generated-artifacts/TestLogDecodingDownstream.json",
"test/generated-artifacts/TestOwnable.json", "test/generated-artifacts/TestOwnable.json",
"test/generated-artifacts/TestReentrancyGuard.json", "test/generated-artifacts/TestReentrancyGuard.json"
"test/generated-artifacts/TestRefundable.json",
"test/generated-artifacts/TestRefundableReceiver.json"
], ],
"exclude": ["./deploy/solc/solc_bin"] "exclude": ["./deploy/solc/solc_bin"]
} }