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

chore: Configure prettier-solidity and run prettier-solidity [TKR-532] (#592)

Browse Source 
* add prettier-solidity + config

* run prettier

* update lockfile

* run prettier again

* Prettier missed one /:

* keep bridge adapter the same

* yarn prettier
This commit is contained in:
Elyas 2022-10-06 11:44:57 -04:00 committed by GitHub
parent d06f6c8b4d
commit b04455c36f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
288 changed files with 4198 additions and 10059 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.prettierignore
View File

@ -85,4 +85,3 @@ lib
package.json
packages/*/docs
docs/
*.sol

14
.prettierrc
View File

@ -4,5 +4,17 @@
"singleQuote": true,
"trailingComma": "all",
"bracketSpacing": true,
"arrowParens": "avoid"
"arrowParens": "avoid",
"overrides": [
{
"files": "**/*.sol",
"options": {
"printWidth": 120,
"tabWidth": 4,
"useTabs": false,
"singleQuote": false,
"bracketSpacing": false
}
}
]
}

85
contracts/erc20/contracts/src/ERC20Token.sol
View File

@ -20,12 +20,9 @@ pragma solidity ^0.5.9;
import "./interfaces/IERC20Token.sol";
contract ERC20Token is
IERC20Token
{
mapping (address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
contract ERC20Token is IERC20Token {
mapping(address => uint256) internal balances;
mapping(address => mapping(address => uint256)) internal allowed;
uint256 internal _totalSupply;
@ -33,27 +30,14 @@ contract ERC20Token is
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return True if transfer was successful
function transfer(address _to, uint256 _value)
external
returns (bool)
{
require(
balances[msg.sender] >= _value,
"ERC20_INSUFFICIENT_BALANCE"
);
require(
balances[_to] + _value >= balances[_to],
"UINT256_OVERFLOW"
);
function transfer(address _to, uint256 _value) external returns (bool) {
require(balances[msg.sender] >= _value, "ERC20_INSUFFICIENT_BALANCE");
require(balances[_to] + _value >= balances[_to], "UINT256_OVERFLOW");
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(
msg.sender,
_to,
_value
);
emit Transfer(msg.sender, _to, _value);
return true;
}
@ -67,32 +51,16 @@ contract ERC20Token is
address _from,
address _to,
uint256 _value
)
external
returns (bool)
{
require(
balances[_from] >= _value,
"ERC20_INSUFFICIENT_BALANCE"
);
require(
allowed[_from][msg.sender] >= _value,
"ERC20_INSUFFICIENT_ALLOWANCE"
);
require(
balances[_to] + _value >= balances[_to],
"UINT256_OVERFLOW"
);
) external returns (bool) {
require(balances[_from] >= _value, "ERC20_INSUFFICIENT_BALANCE");
require(allowed[_from][msg.sender] >= _value, "ERC20_INSUFFICIENT_ALLOWANCE");
require(balances[_to] + _value >= balances[_to], "UINT256_OVERFLOW");
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(
_from,
_to,
_value
);
emit Transfer(_from, _to, _value);
return true;
}
@ -101,48 +69,29 @@ contract ERC20Token is
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Always true if the call has enough gas to complete execution
function approve(address _spender, uint256 _value)
external
returns (bool)
{
function approve(address _spender, uint256 _value) external returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(
msg.sender,
_spender,
_value
);
emit Approval(msg.sender, _spender, _value);
return true;
}
/// @dev Query total supply of token
/// @return Total supply of token
function totalSupply()
external
view
returns (uint256)
{
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
/// @dev Query the balance of owner
/// @param _owner The address from which the balance will be retrieved
/// @return Balance of owner
function balanceOf(address _owner)
external
view
returns (uint256)
{
function balanceOf(address _owner) external view returns (uint256) {
return balances[_owner];
}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender)
external
view
returns (uint256)
{
function allowance(address _owner, address _spender) external view returns (uint256) {
return allowed[_owner][_spender];
}
}

78
contracts/erc20/contracts/src/LibERC20Token.sol
View File

@ -22,9 +22,8 @@ import "@0x/contracts-utils/contracts/src/LibRichErrors.sol";
import "@0x/contracts-utils/contracts/src/LibBytes.sol";
import "../src/interfaces/IERC20Token.sol";
library LibERC20Token {
bytes constant private DECIMALS_CALL_DATA = hex"313ce567";
bytes private constant DECIMALS_CALL_DATA = hex"313ce567";
/// @dev Calls `IERC20Token(token).approve()`.
/// Reverts if `false` is returned or if the return
@ -36,14 +35,8 @@ library LibERC20Token {
address token,
address spender,
uint256 allowance
)
internal
{
bytes memory callData = abi.encodeWithSelector(
IERC20Token(0).approve.selector,
spender,
allowance
);
) internal {
bytes memory callData = abi.encodeWithSelector(IERC20Token(0).approve.selector, spender, allowance);
_callWithOptionalBooleanResult(token, callData);
}
@ -58,9 +51,7 @@ library LibERC20Token {
address token,
address spender,
uint256 amount
)
internal
{
) internal {
if (IERC20Token(token).allowance(address(this), spender) < amount) {
approve(token, spender, uint256(-1));
}
@ -76,14 +67,8 @@ library LibERC20Token {
address token,
address to,
uint256 amount
)
internal
{
bytes memory callData = abi.encodeWithSelector(
IERC20Token(0).transfer.selector,
to,
amount
);
) internal {
bytes memory callData = abi.encodeWithSelector(IERC20Token(0).transfer.selector, to, amount);
_callWithOptionalBooleanResult(token, callData);
}
@ -99,15 +84,8 @@ library LibERC20Token {
address from,
address to,
uint256 amount
)
internal
{
bytes memory callData = abi.encodeWithSelector(
IERC20Token(0).transferFrom.selector,
from,
to,
amount
);
) internal {
bytes memory callData = abi.encodeWithSelector(IERC20Token(0).transferFrom.selector, from, to, amount);
_callWithOptionalBooleanResult(token, callData);
}
@ -115,11 +93,7 @@ library LibERC20Token {
/// Returns `18` if the call reverts.
/// @param token The address of the token contract.
/// @return tokenDecimals The number of decimals places for the token.
function decimals(address token)
internal
view
returns (uint8 tokenDecimals)
{
function decimals(address token) internal view returns (uint8 tokenDecimals) {
tokenDecimals = 18;
(bool didSucceed, bytes memory resultData) = token.staticcall(DECIMALS_CALL_DATA);
if (didSucceed && resultData.length == 32) {
@ -133,17 +107,13 @@ library LibERC20Token {
/// @param owner The owner of the tokens.
/// @param spender The address the spender.
/// @return allowance The allowance for a token, owner, and spender.
function allowance(address token, address owner, address spender)
internal
view
returns (uint256 allowance_)
{
function allowance(
address token,
address owner,
address spender
) internal view returns (uint256 allowance_) {
(bool didSucceed, bytes memory resultData) = token.staticcall(
abi.encodeWithSelector(
IERC20Token(0).allowance.selector,
owner,
spender
)
abi.encodeWithSelector(IERC20Token(0).allowance.selector, owner, spender)
);
if (didSucceed && resultData.length == 32) {
allowance_ = LibBytes.readUint256(resultData, 0);
@ -155,16 +125,9 @@ library LibERC20Token {
/// @param token The address of the token contract.
/// @param owner The owner of the tokens.
/// @return balance The token balance of an owner.
function balanceOf(address token, address owner)
internal
view
returns (uint256 balance)
{
function balanceOf(address token, address owner) internal view returns (uint256 balance) {
(bool didSucceed, bytes memory resultData) = token.staticcall(
abi.encodeWithSelector(
IERC20Token(0).balanceOf.selector,
owner
)
abi.encodeWithSelector(IERC20Token(0).balanceOf.selector, owner)
);
if (didSucceed && resultData.length == 32) {
balance = LibBytes.readUint256(resultData, 0);
@ -176,12 +139,7 @@ library LibERC20Token {
/// was returned equal to `true`.
/// @param target The call target.
/// @param callData The abi-encoded call data.
function _callWithOptionalBooleanResult(
address target,
bytes memory callData
)
private
{
function _callWithOptionalBooleanResult(address target, bytes memory callData) private {
(bool didSucceed, bytes memory resultData) = target.call(callData);
if (didSucceed) {
if (resultData.length == 0) {

25
contracts/erc20/contracts/src/MintableERC20Token.sol
View File

@ -21,41 +21,26 @@ pragma solidity ^0.5.9;
import "@0x/contracts-utils/contracts/src/LibSafeMath.sol";
import "./UnlimitedAllowanceERC20Token.sol";
contract MintableERC20Token is
UnlimitedAllowanceERC20Token
{
contract MintableERC20Token is UnlimitedAllowanceERC20Token {
using LibSafeMath for uint256;
/// @dev Mints new tokens
/// @param _to Address of the beneficiary that will own the minted token
/// @param _value Amount of tokens to mint
function _mint(address _to, uint256 _value)
internal
{
function _mint(address _to, uint256 _value) internal {
balances[_to] = _value.safeAdd(balances[_to]);
_totalSupply = _totalSupply.safeAdd(_value);
emit Transfer(
address(0),
_to,
_value
);
emit Transfer(address(0), _to, _value);
}
/// @dev Mints new tokens
/// @param _owner Owner of tokens that will be burned
/// @param _value Amount of tokens to burn
function _burn(address _owner, uint256 _value)
internal
{
function _burn(address _owner, uint256 _value) internal {
balances[_owner] = balances[_owner].safeSub(_value);
_totalSupply = _totalSupply.safeSub(_value);
emit Transfer(
_owner,
address(0),
_value
);
emit Transfer(_owner, address(0), _value);
}
}

33
contracts/erc20/contracts/src/UnlimitedAllowanceERC20Token.sol
View File

@ -20,11 +20,8 @@ pragma solidity ^0.5.9;
import "./ERC20Token.sol";
contract UnlimitedAllowanceERC20Token is
ERC20Token
{
uint256 constant internal MAX_UINT = 2**256 - 1;
contract UnlimitedAllowanceERC20Token is ERC20Token {
uint256 internal constant MAX_UINT = 2**256 - 1;
/// @dev ERC20 transferFrom, modified such that an allowance of MAX_UINT represents an unlimited allowance. See https://github.com/ethereum/EIPs/issues/717
/// @param _from Address to transfer from.
@ -35,23 +32,11 @@ contract UnlimitedAllowanceERC20Token is
address _from,
address _to,
uint256 _value
)
external
returns (bool)
{
) external returns (bool) {
uint256 allowance = allowed[_from][msg.sender];
require(
balances[_from] >= _value,
"ERC20_INSUFFICIENT_BALANCE"
);
require(
allowance >= _value,
"ERC20_INSUFFICIENT_ALLOWANCE"
);
require(
balances[_to] + _value >= balances[_to],
"UINT256_OVERFLOW"
);
require(balances[_from] >= _value, "ERC20_INSUFFICIENT_BALANCE");
require(allowance >= _value, "ERC20_INSUFFICIENT_ALLOWANCE");
require(balances[_to] + _value >= balances[_to], "UINT256_OVERFLOW");
balances[_to] += _value;
balances[_from] -= _value;
@ -59,11 +44,7 @@ contract UnlimitedAllowanceERC20Token is
allowed[_from][msg.sender] -= _value;
}
emit Transfer(
_from,
_to,
_value
);
emit Transfer(_from, _to, _value);
return true;
}

41
contracts/erc20/contracts/src/WETH9.sol
View File

@ -16,55 +16,57 @@
// solhint-disable
pragma solidity ^0.5.9;
contract WETH9 {
string public name = "Wrapped Ether";
string public symbol = "WETH";
uint8 public decimals = 18;
string public name = "Wrapped Ether";
string public symbol = "WETH";
uint8 public decimals = 18;
event Approval(address indexed _owner, address indexed _spender, uint _value);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Deposit(address indexed _owner, uint _value);
event Withdrawal(address indexed _owner, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Deposit(address indexed _owner, uint256 _value);
event Withdrawal(address indexed _owner, uint256 _value);
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
function() external payable {
deposit();
}
function deposit() public payable {
balanceOf[msg.sender] += msg.value;
emit Deposit(msg.sender, msg.value);
}
function withdraw(uint wad) public {
function withdraw(uint256 wad) public {
require(balanceOf[msg.sender] >= wad);
balanceOf[msg.sender] -= wad;
msg.sender.transfer(wad);
emit Withdrawal(msg.sender, wad);
}
function totalSupply() public view returns (uint) {
function totalSupply() public view returns (uint256) {
return address(this).balance;
}
function approve(address guy, uint wad) public returns (bool) {
function approve(address guy, uint256 wad) public returns (bool) {
allowance[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
function transfer(address dst, uint wad) public returns (bool) {
function transfer(address dst, uint256 wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
function transferFrom(
address src,
address dst,
uint256 wad
) public returns (bool) {
require(balanceOf[src] >= wad);
if (src != msg.sender && allowance[src][msg.sender] != uint(-1)) {
if (src != msg.sender && allowance[src][msg.sender] != uint256(-1)) {
require(allowance[src][msg.sender] >= wad);
allowance[src][msg.sender] -= wad;
}
@ -78,7 +80,6 @@ contract WETH9 {
}
}
/*
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007

93
contracts/erc20/contracts/src/ZRXToken.sol
View File

@ -18,105 +18,111 @@
pragma solidity 0.4.11;
contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint supply) {}
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint balance) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint _value) returns (bool success) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint _value) returns (bool success) {}
function transferFrom(
address _from,
address _to,
uint256 _value
) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint remaining) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract ERC20Token is Token {
function transfer(address _to, uint _value) returns (bool) {
function transfer(address _to, uint256 _value) returns (bool) {
//Default assumes totalSupply can't be over max (2^256 - 1).
if (balances[msg.sender] >= _value && balances[_to] + _value >= balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint _value) returns (bool) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value >= balances[_to]) {
function transferFrom(
address _from,
address _to,
uint256 _value
) returns (bool) {
if (
balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value >= balances[_to]
) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
} else {
return false;
}
}
function balanceOf(address _owner) constant returns (uint) {
function balanceOf(address _owner) constant returns (uint256) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool) {
function approve(address _spender, uint256 _value) returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint) {
function allowance(address _owner, address _spender) constant returns (uint256) {
return allowed[_owner][_spender];
}
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
uint public totalSupply;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
uint256 public totalSupply;
}
contract UnlimitedAllowanceToken is ERC20Token {
uint constant MAX_UINT = 2**256 - 1;
uint256 constant MAX_UINT = 2**256 - 1;
/// @dev ERC20 transferFrom, modified such that an allowance of MAX_UINT represents an unlimited allowance.
/// @param _from Address to transfer from.
/// @param _to Address to transfer to.
/// @param _value Amount to transfer.
/// @return Success of transfer.
function transferFrom(address _from, address _to, uint _value)
public
returns (bool)
{
uint allowance = allowed[_from][msg.sender];
if (balances[_from] >= _value
&& allowance >= _value
&& balances[_to] + _value >= balances[_to]
) {
function transferFrom(
address _from,
address _to,
uint256 _value
) public returns (bool) {
uint256 allowance = allowed[_from][msg.sender];
if (balances[_from] >= _value && allowance >= _value && balances[_to] + _value >= balances[_to]) {
balances[_to] += _value;
balances[_from] -= _value;
if (allowance < MAX_UINT) {
@ -130,21 +136,16 @@ contract UnlimitedAllowanceToken is ERC20Token {
}
}
contract ZRXToken is
UnlimitedAllowanceToken
{
contract ZRXToken is UnlimitedAllowanceToken {
// solhint-disable const-name-snakecase
uint8 constant public decimals = 18;
uint8 public constant decimals = 18;
uint256 public totalSupply = 10**27; // 1 billion tokens, 18 decimal places
string constant public name = "0x Protocol Token";
string constant public symbol = "ZRX";
string public constant name = "0x Protocol Token";
string public constant symbol = "ZRX";
// solhint-enableconst-name-snakecase
function ZRXToken()
public
{
function ZRXToken() public {
balances[msg.sender] = totalSupply;
}
}

41
contracts/erc20/contracts/src/interfaces/IERC20Token.sol
View File

@ -18,29 +18,17 @@
pragma solidity ^0.5.9;
contract IERC20Token {
// solhint-disable no-simple-event-func-name
event Transfer(
address indexed _from,
address indexed _to,
uint256 _value
);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _value
);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
/// @dev send `value` token to `to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return True if transfer was successful
function transfer(address _to, uint256 _value)
external
returns (bool);
function transfer(address _to, uint256 _value) external returns (bool);
/// @dev send `value` token to `to` from `from` on the condition it is approved by `from`
/// @param _from The address of the sender
@ -51,37 +39,24 @@ contract IERC20Token {
address _from,
address _to,
uint256 _value
)
external
returns (bool);
) external returns (bool);
/// @dev `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Always true if the call has enough gas to complete execution
function approve(address _spender, uint256 _value)
external
returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
/// @dev Query total supply of token
/// @return Total supply of token
function totalSupply()
external
view
returns (uint256);
function totalSupply() external view returns (uint256);
/// @param _owner The address from which the balance will be retrieved
/// @return Balance of owner
function balanceOf(address _owner)
external
view
returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender)
external
view
returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
}

12
contracts/erc20/contracts/src/interfaces/IEtherToken.sol
View File

@ -20,14 +20,8 @@ pragma solidity ^0.5.9;
import "./IERC20Token.sol";
contract IEtherToken is IERC20Token {
function deposit() public payable;
contract IEtherToken is
IERC20Token
{
function deposit()
public
payable;
function withdraw(uint256 amount)
public;
function withdraw(uint256 amount) public;
}

46
contracts/erc20/contracts/src/v06/IERC20TokenV06.sol
View File

@ -19,29 +19,17 @@
pragma solidity ^0.6.5;
interface IERC20TokenV06 {
// solhint-disable no-simple-event-func-name
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Approval(address indexed owner, address indexed spender, uint256 value);
/// @dev send `value` token to `to` from `msg.sender`
/// @param to The address of the recipient
/// @param value The amount of token to be transferred
/// @return True if transfer was successful
function transfer(address to, uint256 value)
external
returns (bool);
function transfer(address to, uint256 value) external returns (bool);
/// @dev send `value` token to `to` from `from` on the condition it is approved by `from`
/// @param from The address of the sender
@ -52,45 +40,29 @@ interface IERC20TokenV06 {
address from,
address to,
uint256 value
)
external
returns (bool);
) external returns (bool);
/// @dev `msg.sender` approves `spender` to spend `value` tokens
/// @param spender The address of the account able to transfer the tokens
/// @param value The amount of wei to be approved for transfer
/// @return Always true if the call has enough gas to complete execution
function approve(address spender, uint256 value)
external
returns (bool);
function approve(address spender, uint256 value) external returns (bool);
/// @dev Query total supply of token
/// @return Total supply of token
function totalSupply()
external
view
returns (uint256);
function totalSupply() external view returns (uint256);
/// @dev Get the balance of `owner`.
/// @param owner The address from which the balance will be retrieved
/// @return Balance of owner
function balanceOf(address owner)
external
view
returns (uint256);
function balanceOf(address owner) external view returns (uint256);
/// @dev Get the allowance for `spender` to spend from `owner`.
/// @param owner The address of the account owning tokens
/// @param spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address owner, address spender)
external
view
returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
/// @dev Get the number of decimals this token has.
function decimals()
external
view
returns (uint8);
function decimals() external view returns (uint8);
}

5
contracts/erc20/contracts/src/v06/IEtherTokenV06.sol
View File

@ -21,10 +21,7 @@ pragma solidity ^0.6.5;
import "./IERC20TokenV06.sol";
interface IEtherTokenV06 is
IERC20TokenV06
{
interface IEtherTokenV06 is IERC20TokenV06 {
/// @dev Wrap ether.
function deposit() external payable;

82
contracts/erc20/contracts/src/v06/LibERC20TokenV06.sol
View File

@ -23,9 +23,8 @@ import "@0x/contracts-utils/contracts/src/v06/errors/LibRichErrorsV06.sol";
import "@0x/contracts-utils/contracts/src/v06/LibBytesV06.sol";
import "./IERC20TokenV06.sol";
library LibERC20TokenV06 {
bytes constant private DECIMALS_CALL_DATA = hex"313ce567";
bytes private constant DECIMALS_CALL_DATA = hex"313ce567";
/// @dev Calls `IERC20TokenV06(token).approve()`.
/// Reverts if the return data is invalid or the call reverts.
@ -36,14 +35,8 @@ library LibERC20TokenV06 {
IERC20TokenV06 token,
address spender,
uint256 allowance
)
internal
{
bytes memory callData = abi.encodeWithSelector(
token.approve.selector,
spender,
allowance
);
) internal {
bytes memory callData = abi.encodeWithSelector(token.approve.selector, spender, allowance);
_callWithOptionalBooleanResult(address(token), callData);
}
@ -57,9 +50,7 @@ library LibERC20TokenV06 {
IERC20TokenV06 token,
address spender,
uint256 amount
)
internal
{
) internal {
if (token.allowance(address(this), spender) < amount) {
compatApprove(token, spender, uint256(-1));
}
@ -74,14 +65,8 @@ library LibERC20TokenV06 {
IERC20TokenV06 token,
address to,
uint256 amount
)
internal
{
bytes memory callData = abi.encodeWithSelector(
token.transfer.selector,
to,
amount
);
) internal {
bytes memory callData = abi.encodeWithSelector(token.transfer.selector, to, amount);
_callWithOptionalBooleanResult(address(token), callData);
}
@ -96,15 +81,8 @@ library LibERC20TokenV06 {
address from,
address to,
uint256 amount
)
internal
{
bytes memory callData = abi.encodeWithSelector(
token.transferFrom.selector,
from,
to,
amount
);
) internal {
bytes memory callData = abi.encodeWithSelector(token.transferFrom.selector, from, to, amount);
_callWithOptionalBooleanResult(address(token), callData);
}
@ -112,11 +90,7 @@ library LibERC20TokenV06 {
/// Returns `18` if the call reverts.
/// @param token The address of the token contract.
/// @return tokenDecimals The number of decimals places for the token.
function compatDecimals(IERC20TokenV06 token)
internal
view
returns (uint8 tokenDecimals)
{
function compatDecimals(IERC20TokenV06 token) internal view returns (uint8 tokenDecimals) {
tokenDecimals = 18;
(bool didSucceed, bytes memory resultData) = address(token).staticcall(DECIMALS_CALL_DATA);
if (didSucceed && resultData.length >= 32) {
@ -130,17 +104,13 @@ library LibERC20TokenV06 {
/// @param owner The owner of the tokens.
/// @param spender The address the spender.
/// @return allowance_ The allowance for a token, owner, and spender.
function compatAllowance(IERC20TokenV06 token, address owner, address spender)
internal
view
returns (uint256 allowance_)
{
function compatAllowance(
IERC20TokenV06 token,
address owner,
address spender
) internal view returns (uint256 allowance_) {
(bool didSucceed, bytes memory resultData) = address(token).staticcall(
abi.encodeWithSelector(
token.allowance.selector,
owner,
spender
)
abi.encodeWithSelector(token.allowance.selector, owner, spender)
);
if (didSucceed && resultData.length >= 32) {
allowance_ = LibBytesV06.readUint256(resultData, 0);
@ -152,16 +122,9 @@ library LibERC20TokenV06 {
/// @param token The address of the token contract.
/// @param owner The owner of the tokens.
/// @return balance The token balance of an owner.
function compatBalanceOf(IERC20TokenV06 token, address owner)
internal
view
returns (uint256 balance)
{
function compatBalanceOf(IERC20TokenV06 token, address owner) internal view returns (uint256 balance) {
(bool didSucceed, bytes memory resultData) = address(token).staticcall(
abi.encodeWithSelector(
token.balanceOf.selector,
owner
)
abi.encodeWithSelector(token.balanceOf.selector, owner)
);
if (didSucceed && resultData.length >= 32) {
balance = LibBytesV06.readUint256(resultData, 0);
@ -173,12 +136,7 @@ library LibERC20TokenV06 {
/// was returned equal to `true`.
/// @param target The call target.
/// @param callData The abi-encoded call data.
function _callWithOptionalBooleanResult(
address target,
bytes memory callData
)
private
{
function _callWithOptionalBooleanResult(address target, bytes memory callData) private {
(bool didSucceed, bytes memory resultData) = target.call(callData);
// Revert if the call reverted.
if (!didSucceed) {
@ -188,7 +146,9 @@ library LibERC20TokenV06 {
// does not return a boolean. Check that it at least contains code.
if (resultData.length == 0) {
uint256 size;
assembly { size := extcodesize(target) }
assembly {
size := extcodesize(target)
}
require(size > 0, "invalid token address, contains no code");
return;
}

26
contracts/erc20/contracts/test/DummyERC20Token.sol
View File

@ -22,11 +22,7 @@ import "@0x/contracts-utils/contracts/src/LibSafeMath.sol";
import "@0x/contracts-utils/contracts/src/Ownable.sol";
import "../src/MintableERC20Token.sol";
contract DummyERC20Token is
Ownable,
MintableERC20Token
{
contract DummyERC20Token is Ownable, MintableERC20Token {
using LibSafeMath for uint256;
string public name;
@ -34,14 +30,12 @@ contract DummyERC20Token is
uint256 public decimals;
uint256 public constant MAX_MINT_AMOUNT = 10000000000000000000000;
constructor (
constructor(
string memory _name,
string memory _symbol,
uint256 _decimals,
uint256 _totalSupply
)
public
{
) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
@ -52,10 +46,7 @@ contract DummyERC20Token is
/// @dev Sets the balance of target address
/// @param _target Address or which balance will be updated
/// @param _value New balance of target address
function setBalance(address _target, uint256 _value)
external
onlyOwner
{
function setBalance(address _target, uint256 _value) external onlyOwner {
uint256 currBalance = balances[_target];
if (_value < currBalance) {
_totalSupply = _totalSupply.safeSub(currBalance.safeSub(_value));
@ -67,13 +58,8 @@ contract DummyERC20Token is
/// @dev Mints new tokens for sender
/// @param _value Amount of tokens to mint
function mint(uint256 _value)
external
{
require(
_value <= MAX_MINT_AMOUNT,
"VALUE_TOO_LARGE"
);
function mint(uint256 _value) external {
require(_value <= MAX_MINT_AMOUNT, "VALUE_TOO_LARGE");
_mint(msg.sender, _value);
}

29
contracts/erc20/contracts/test/DummyMultipleReturnERC20Token.sol
View File

@ -20,25 +20,14 @@ pragma solidity ^0.5.5;
import "./DummyERC20Token.sol";
// solhint-disable no-empty-blocks
contract DummyMultipleReturnERC20Token is
DummyERC20Token
{
constructor (
contract DummyMultipleReturnERC20Token is DummyERC20Token {
constructor(
string memory _name,
string memory _symbol,
uint256 _decimals,
uint256 _totalSupply
)
public
DummyERC20Token(
_name,
_symbol,
_decimals,
_totalSupply
)
{}
) public DummyERC20Token(_name, _symbol, _decimals, _totalSupply) {}
/// @dev send `value` token to `to` from `from` on the condition it is approved by `from`
/// @param _from The address of the sender
@ -48,15 +37,8 @@ contract DummyMultipleReturnERC20Token is
address _from,
address _to,
uint256 _value
)
external
returns (bool)
{
emit Transfer(
_from,
_to,
_value
);
) external returns (bool) {
emit Transfer(_from, _to, _value);
// HACK: This contract will not compile if we remove `returns (bool)`, so we manually return 64 bytes (equiavalent to true, true)
assembly {
@ -66,4 +48,3 @@ contract DummyMultipleReturnERC20Token is
}
}
}

67
contracts/erc20/contracts/test/DummyNoReturnERC20Token.sol
View File

@ -20,50 +20,26 @@ pragma solidity ^0.5.5;
import "./DummyERC20Token.sol";
// solhint-disable no-empty-blocks
contract DummyNoReturnERC20Token is
DummyERC20Token
{
constructor (
contract DummyNoReturnERC20Token is DummyERC20Token {
constructor(
string memory _name,
string memory _symbol,
uint256 _decimals,
uint256 _totalSupply
)
public
DummyERC20Token(
_name,
_symbol,
_decimals,
_totalSupply
)
{}
) public DummyERC20Token(_name, _symbol, _decimals, _totalSupply) {}
/// @dev send `value` token to `to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
function transfer(address _to, uint256 _value)
external
returns (bool)
{
require(
balances[msg.sender] >= _value,
"ERC20_INSUFFICIENT_BALANCE"
);
require(
balances[_to] + _value >= balances[_to],
"UINT256_OVERFLOW"
);
function transfer(address _to, uint256 _value) external returns (bool) {
require(balances[msg.sender] >= _value, "ERC20_INSUFFICIENT_BALANCE");
require(balances[_to] + _value >= balances[_to], "UINT256_OVERFLOW");
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(
msg.sender,
_to,
_value
);
emit Transfer(msg.sender, _to, _value);
// HACK: This contract will not compile if we remove `returns (bool)`, so we manually return no data
assembly {
@ -79,32 +55,16 @@ contract DummyNoReturnERC20Token is
address _from,
address _to,
uint256 _value
)
external
returns (bool)
{
require(
balances[_from] >= _value,
"ERC20_INSUFFICIENT_BALANCE"
);
require(
allowed[_from][msg.sender] >= _value,
"ERC20_INSUFFICIENT_ALLOWANCE"
);
require(
balances[_to] + _value >= balances[_to],
"UINT256_OVERFLOW"
);
) external returns (bool) {
require(balances[_from] >= _value, "ERC20_INSUFFICIENT_BALANCE");
require(allowed[_from][msg.sender] >= _value, "ERC20_INSUFFICIENT_ALLOWANCE");
require(balances[_to] + _value >= balances[_to], "UINT256_OVERFLOW");
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(
_from,
_to,
_value
);
emit Transfer(_from, _to, _value);
// HACK: This contract will not compile if we remove `returns (bool)`, so we manually return no data
assembly {
@ -112,4 +72,3 @@ contract DummyNoReturnERC20Token is
}
}
}

19
contracts/erc20/contracts/test/TestLibERC20Token.sol
View File

@ -21,9 +21,7 @@ pragma solidity ^0.5.9;
import "../src/LibERC20Token.sol";
import "./TestLibERC20TokenTarget.sol";
contract TestLibERC20Token {
TestLibERC20TokenTarget public target;
constructor() public {
@ -36,9 +34,7 @@ contract TestLibERC20Token {
bytes calldata returnData,
address spender,
uint256 allowance
)
external
{
) external {
target.setBehavior(shouldRevert, revertData, returnData);
LibERC20Token.approve(address(target), spender, allowance);
}
@ -49,9 +45,7 @@ contract TestLibERC20Token {
bytes calldata returnData,
address to,
uint256 amount
)
external
{
) external {
target.setBehavior(shouldRevert, revertData, returnData);
LibERC20Token.transfer(address(target), to, amount);
}
@ -63,9 +57,7 @@ contract TestLibERC20Token {
address from,
address to,
uint256 amount
)
external
{
) external {
target.setBehavior(shouldRevert, revertData, returnData);
LibERC20Token.transferFrom(address(target), from, to, amount);
}
@ -74,10 +66,7 @@ contract TestLibERC20Token {
bool shouldRevert,
bytes calldata revertData,
bytes calldata returnData
)
external
returns (uint8)
{
) external returns (uint8) {
target.setBehavior(shouldRevert, revertData, returnData);
return LibERC20Token.decimals(address(target));
}

57
contracts/erc20/contracts/test/TestLibERC20TokenTarget.sol
View File

@ -18,24 +18,12 @@
pragma solidity ^0.5.9;
contract TestLibERC20TokenTarget {
event ApproveCalled(address spender, uint256 allowance);
event ApproveCalled(
address spender,
uint256 allowance
);
event TransferCalled(address to, uint256 amount);
event TransferCalled(
address to,
uint256 amount
);
event TransferFromCalled(
address from,
address to,
uint256 amount
);
event TransferFromCalled(address from, address to, uint256 amount);
bool private _shouldRevert;
bytes private _revertData;
@ -45,32 +33,18 @@ contract TestLibERC20TokenTarget {
bool shouldRevert,
bytes calldata revertData,
bytes calldata returnData
)
external
{
) external {
_shouldRevert = shouldRevert;
_revertData = revertData;
_returnData = returnData;
}
function approve(
address spender,
uint256 allowance
)
external
returns (bool)
{
function approve(address spender, uint256 allowance) external returns (bool) {
emit ApproveCalled(spender, allowance);
_execute();
}
function transfer(
address to,
uint256 amount
)
external
returns (bool)
{
function transfer(address to, uint256 amount) external returns (bool) {
emit TransferCalled(to, amount);
_execute();
}
@ -79,28 +53,25 @@ contract TestLibERC20TokenTarget {
address from,
address to,
uint256 amount
)
external
returns (bool)
{
) external returns (bool) {
emit TransferFromCalled(from, to, amount);
_execute();
}
function decimals()
external
view
returns (uint8)
{
function decimals() external view returns (uint8) {
_execute();
}
function _execute() private view {
if (_shouldRevert) {
bytes memory revertData = _revertData;
assembly { revert(add(revertData, 0x20), mload(revertData)) }
assembly {
revert(add(revertData, 0x20), mload(revertData))
}
}
bytes memory returnData = _returnData;
assembly { return(add(returnData, 0x20), mload(returnData)) }
assembly {
return(add(returnData, 0x20), mload(returnData))
}
}
}

28
contracts/erc20/contracts/test/UntransferrableDummyERC20Token.sol
View File

@ -20,26 +20,15 @@ pragma solidity ^0.5.5;
import "./DummyERC20Token.sol";
// solhint-disable no-empty-blocks
// solhint-disable no-unused-vars
contract UntransferrableDummyERC20Token is
DummyERC20Token
{
constructor (
contract UntransferrableDummyERC20Token is DummyERC20Token {
constructor(
string memory _name,
string memory _symbol,
uint256 _decimals,
uint256 _totalSupply
)
public
DummyERC20Token(
_name,
_symbol,
_decimals,
_totalSupply
)
{}
) public DummyERC20Token(_name, _symbol, _decimals, _totalSupply) {}
/// @dev send `value` token to `to` from `from` on the condition it is approved by `from`
/// @param _from The address of the sender
@ -49,14 +38,7 @@ contract UntransferrableDummyERC20Token is
address _from,
address _to,
uint256 _value
)
external
returns (bool)
{
require(
false,
"TRANSFER_DISABLED"
);
) external returns (bool) {
require(false, "TRANSFER_DISABLED");
}
}

2
contracts/erc20/src/artifacts.ts
View File

@ -15,7 +15,7 @@ export const artifacts = {
DummyERC20Token: DummyERC20Token as ContractArtifact,
ERC20Token: ERC20Token as ContractArtifact,
WETH9: WETH9 as ContractArtifact,
ZRXToken: (ZRXToken as any) as ContractArtifact,
ZRXToken: ZRXToken as any as ContractArtifact,
DummyNoReturnERC20Token: DummyNoReturnERC20Token as ContractArtifact,
DummyMultipleReturnERC20Token: DummyMultipleReturnERC20Token as ContractArtifact,
};

2
contracts/erc20/test/artifacts.ts
View File

@ -28,7 +28,7 @@ export const artifacts = {
MintableERC20Token: MintableERC20Token as ContractArtifact,
UnlimitedAllowanceERC20Token: UnlimitedAllowanceERC20Token as ContractArtifact,
WETH9: WETH9 as ContractArtifact,
ZRXToken: (ZRXToken as any) as ContractArtifact,
ZRXToken: ZRXToken as any as ContractArtifact,
IERC20Token: IERC20Token as ContractArtifact,
IEtherToken: IEtherToken as ContractArtifact,
IERC20TokenV06: IERC20TokenV06 as ContractArtifact,

12
contracts/treasury/contracts/external/ISablier.sol vendored
View File

@ -50,11 +50,15 @@ interface ISablier {
uint256 ratePerSecond
);
function createStream(address recipient, uint256 deposit, address tokenAddress, uint256 startTime, uint256 stopTime)
external
returns (uint256 streamId);
function createStream(
address recipient,
uint256 deposit,
address tokenAddress,
uint256 startTime,
uint256 stopTime
) external returns (uint256 streamId);
function withdrawFromStream(uint256 streamId, uint256 funds) external returns (bool);
function cancelStream(uint256 streamId) external returns (bool);
}
}

14
contracts/treasury/contracts/src/DefaultPoolOperator.sol
View File

@ -23,7 +23,6 @@ pragma experimental ABIEncoderV2;
import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
import "./IStaking.sol";
contract DefaultPoolOperator {
// Immutables
IStaking public immutable stakingProxy;
@ -33,16 +32,11 @@ contract DefaultPoolOperator {
/// @dev Initializes this contract and creates a staking pool.
/// @param stakingProxy_ The 0x staking proxy contract.
/// @param weth_ The WETH token contract.
constructor(
IStaking stakingProxy_,
IERC20TokenV06 weth_
)
public
{
constructor(IStaking stakingProxy_, IERC20TokenV06 weth_) public {
stakingProxy = stakingProxy_;
weth = weth_;
// operator share = 100%
poolId = stakingProxy_.createStakingPool(10 ** 6, false);
poolId = stakingProxy_.createStakingPool(10**6, false);
}
/// @dev Sends this contract's entire WETH balance to the
@ -51,9 +45,7 @@ contract DefaultPoolOperator {
/// market making for some reason, thus earning this contract
/// some staking rewards. Note that anyone can call this
/// function at any time.
function returnStakingRewards()
external
{
function returnStakingRewards() external {
uint256 wethBalance = weth.balanceOf(address(this));
weth.transfer(address(stakingProxy), wethBalance);
}

40
contracts/treasury/contracts/src/IStaking.sol
View File

@ -20,7 +20,6 @@
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
interface IStaking {
/// @dev Statuses that stake can exist in.
/// Any stake can be (re)delegated effective at the next epoch
@ -55,54 +54,34 @@ interface IStaking {
/// @param operatorShare Portion of rewards owned by the operator, in ppm.
/// @param addOperatorAsMaker Adds operator to the created pool as a maker for convenience iff true.
/// @return poolId The unique pool id generated for this pool.
function createStakingPool(uint32 operatorShare, bool addOperatorAsMaker)
external
returns (bytes32 poolId);
function createStakingPool(uint32 operatorShare, bool addOperatorAsMaker) external returns (bytes32 poolId);
/// @dev Returns the current staking epoch number.
/// @return epoch The current epoch.
function currentEpoch()
external
view
returns (uint256 epoch);
function currentEpoch() external view returns (uint256 epoch);
/// @dev Returns the time (in seconds) at which the current staking epoch started.
/// @return startTime The start time of the current epoch, in seconds.
function currentEpochStartTimeInSeconds()
external
view
returns (uint256 startTime);
function currentEpochStartTimeInSeconds() external view returns (uint256 startTime);
/// @dev Returns the duration of an epoch in seconds. This value can be updated.
/// @return duration The duration of an epoch, in seconds.
function epochDurationInSeconds()
external
view
returns (uint256 duration);
function epochDurationInSeconds() external view returns (uint256 duration);
/// @dev Returns a staking pool
/// @param poolId Unique id of pool.
function getStakingPool(bytes32 poolId)
external
view
returns (Pool memory);
function getStakingPool(bytes32 poolId) external view returns (Pool memory);
/// @dev Gets global stake for a given status.
/// @param stakeStatus UNDELEGATED or DELEGATED
/// @return balance Global stake for given status.
function getGlobalStakeByStatus(StakeStatus stakeStatus)
external
view
returns (StoredBalance memory balance);
function getGlobalStakeByStatus(StakeStatus stakeStatus) external view returns (StoredBalance memory balance);
/// @dev Gets an owner's stake balances by status.
/// @param staker Owner of stake.
/// @param stakeStatus UNDELEGATED or DELEGATED
/// @return balance Owner's stake balances for given status.
function getOwnerStakeByStatus(
address staker,
StakeStatus stakeStatus
)
function getOwnerStakeByStatus(address staker, StakeStatus stakeStatus)
external
view
returns (StoredBalance memory balance);
@ -111,10 +90,7 @@ interface IStaking {
/// across all members.
/// @param poolId Unique Id of pool.
/// @return balance Total stake delegated to pool.
function getTotalStakeDelegatedToPool(bytes32 poolId)
external
view
returns (StoredBalance memory balance);
function getTotalStakeDelegatedToPool(bytes32 poolId) external view returns (StoredBalance memory balance);
/// @dev Returns the stake delegated to a specific staking pool, by a given staker.
/// @param staker of stake.

65
contracts/treasury/contracts/src/IZrxTreasury.sol
View File

@ -23,9 +23,7 @@ pragma experimental ABIEncoderV2;
import "./DefaultPoolOperator.sol";
import "./IStaking.sol";
interface IZrxTreasury {
struct TreasuryParameters {
uint256 votingPeriod;
uint256 proposalThreshold;
@ -57,45 +55,21 @@ interface IZrxTreasury {
string description
);
event VoteCast(
address voter,
bytes32[] operatedPoolIds,
uint256 proposalId,
bool support,
uint256 votingPower
);
event VoteCast(address voter, bytes32[] operatedPoolIds, uint256 proposalId, bool support, uint256 votingPower);
event ProposalExecuted(uint256 proposalId);
function stakingProxy()
external
view
returns (IStaking);
function stakingProxy() external view returns (IStaking);
function defaultPoolOperator()
external
view
returns (DefaultPoolOperator);
function defaultPoolOperator() external view returns (DefaultPoolOperator);
function defaultPoolId()
external
view
returns (bytes32);
function defaultPoolId() external view returns (bytes32);
function votingPeriod()
external
view
returns (uint256);
function votingPeriod() external view returns (uint256);
function proposalThreshold()
external
view
returns (uint256);
function proposalThreshold() external view returns (uint256);
function quorumThreshold()
external
view
returns (uint256);
function quorumThreshold() external view returns (uint256);
/// @dev Updates the proposal and quorum thresholds to the given
/// values. Note that this function is only callable by the
@ -103,11 +77,7 @@ interface IZrxTreasury {
/// updated via a successful treasury proposal.
/// @param newProposalThreshold The new value for the proposal threshold.
/// @param newQuorumThreshold The new value for the quorum threshold.
function updateThresholds(
uint256 newProposalThreshold,
uint256 newQuorumThreshold
)
external;
function updateThresholds(uint256 newProposalThreshold, uint256 newQuorumThreshold) external;
/// @dev Creates a proposal to send ZRX from this treasury on the
/// the given actions. Must have at least `proposalThreshold`
@ -131,9 +101,7 @@ interface IZrxTreasury {
uint256 executionEpoch,
string calldata description,
bytes32[] calldata operatedPoolIds
)
external
returns (uint256 proposalId);
) external returns (uint256 proposalId);
/// @dev Casts a vote for the given proposal. Only callable
/// during the voting period for that proposal.
@ -148,8 +116,7 @@ interface IZrxTreasury {
uint256 proposalId,
bool support,
bytes32[] calldata operatedPoolIds
)
external;
) external;
/// @dev Casts a vote for the given proposal, by signature.
/// Only callable during the voting period for that proposal.
@ -170,23 +137,17 @@ interface IZrxTreasury {
uint8 v,
bytes32 r,
bytes32 s
)
external;
) external;
/// @dev Executes a proposal that has passed and is
/// currently executable.
/// @param proposalId The ID of the proposal to execute.
/// @param actions Actions associated with the proposal to execute.
function execute(uint256 proposalId, ProposedAction[] memory actions)
external
payable;
function execute(uint256 proposalId, ProposedAction[] memory actions) external payable;
/// @dev Returns the total number of proposals.
/// @return count The number of proposals.
function proposalCount()
external
view
returns (uint256 count);
function proposalCount() external view returns (uint256 count);
/// @dev Computes the current voting power of the given account.
/// Voting power is equal to:

188
contracts/treasury/contracts/src/ZrxTreasury.sol
View File

@ -26,10 +26,7 @@ import "@0x/contracts-utils/contracts/src/v06/errors/LibRichErrorsV06.sol";
import "@0x/contracts-zero-ex/contracts/src/features/libs/LibSignature.sol";
import "./IZrxTreasury.sol";
contract ZrxTreasury is
IZrxTreasury
{
contract ZrxTreasury is IZrxTreasury {
using LibSafeMathV06 for uint256;
using LibRichErrorsV06 for bytes;
using LibBytesV06 for bytes;
@ -41,10 +38,12 @@ contract ZrxTreasury is
string private constant CONTRACT_VERSION = "1.0.0";
/// The EIP-712 typehash for the contract's domain
bytes32 private constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 private constant DOMAIN_TYPEHASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
/// The EIP-712 typehash for the vote struct
bytes32 private constant VOTE_TYPEHASH = keccak256("TreasuryVote(uint256 proposalId,bool support,bytes32[] operatedPoolIds)");
bytes32 private constant VOTE_TYPEHASH =
keccak256("TreasuryVote(uint256 proposalId,bool support,bytes32[] operatedPoolIds)");
// Immutables
IStaking public immutable override stakingProxy;
@ -58,22 +57,14 @@ contract ZrxTreasury is
// Storage
Proposal[] public proposals;
mapping (uint256 => mapping (address => bool)) public hasVoted;
mapping(uint256 => mapping(address => bool)) public hasVoted;
/// @dev Initializes the ZRX treasury and creates the default
/// staking pool.
/// @param stakingProxy_ The 0x staking proxy contract.
/// @param params Immutable treasury parameters.
constructor(
IStaking stakingProxy_,
TreasuryParameters memory params
)
public
{
require(
params.votingPeriod < stakingProxy_.epochDurationInSeconds(),
"VOTING_PERIOD_TOO_LONG"
);
constructor(IStaking stakingProxy_, TreasuryParameters memory params) public {
require(params.votingPeriod < stakingProxy_.epochDurationInSeconds(), "VOTING_PERIOD_TOO_LONG");
stakingProxy = stakingProxy_;
votingPeriod = params.votingPeriod;
proposalThreshold = params.proposalThreshold;
@ -95,6 +86,7 @@ contract ZrxTreasury is
// solhint-disable
/// @dev Allows this contract to receive ether.
receive() external payable {}
// solhint-enable
/// @dev Updates the proposal and quorum thresholds to the given
@ -103,13 +95,7 @@ contract ZrxTreasury is
/// updated via a successful treasury proposal.
/// @param newProposalThreshold The new value for the proposal threshold.
/// @param newQuorumThreshold The new value for the quorum threshold.
function updateThresholds(
uint256 newProposalThreshold,
uint256 newQuorumThreshold
)
external
override
{
function updateThresholds(uint256 newProposalThreshold, uint256 newQuorumThreshold) external override {
require(msg.sender == address(this), "updateThresholds/ONLY_SELF");
proposalThreshold = newProposalThreshold;
quorumThreshold = newQuorumThreshold;
@ -137,24 +123,11 @@ contract ZrxTreasury is
uint256 executionEpoch,
string memory description,
bytes32[] memory operatedPoolIds
)
public
override
returns (uint256 proposalId)
{
require(
getVotingPower(msg.sender, operatedPoolIds) >= proposalThreshold,
"propose/INSUFFICIENT_VOTING_POWER"
);
require(
actions.length > 0,
"propose/NO_ACTIONS_PROPOSED"
);
) public override returns (uint256 proposalId) {
require(getVotingPower(msg.sender, operatedPoolIds) >= proposalThreshold, "propose/INSUFFICIENT_VOTING_POWER");
require(actions.length > 0, "propose/NO_ACTIONS_PROPOSED");
uint256 currentEpoch = stakingProxy.currentEpoch();
require(
executionEpoch >= currentEpoch + 2,
"propose/INVALID_EXECUTION_EPOCH"
);
require(executionEpoch >= currentEpoch + 2, "propose/INVALID_EXECUTION_EPOCH");
proposalId = proposalCount();
Proposal storage newProposal = proposals.push();
@ -162,14 +135,7 @@ contract ZrxTreasury is
newProposal.executionEpoch = executionEpoch;
newProposal.voteEpoch = currentEpoch + 2;
emit ProposalCreated(
msg.sender,
operatedPoolIds,
proposalId,
actions,
executionEpoch,
description
);
emit ProposalCreated(msg.sender, operatedPoolIds, proposalId, actions, executionEpoch, description);
}
/// @dev Casts a vote for the given proposal. Only callable
@ -185,10 +151,7 @@ contract ZrxTreasury is
uint256 proposalId,
bool support,
bytes32[] memory operatedPoolIds
)
public
override
{
) public override {
return _castVote(msg.sender, proposalId, support, operatedPoolIds);
}
@ -211,10 +174,7 @@ contract ZrxTreasury is
uint8 v,
bytes32 r,
bytes32 s
)
public
override
{
) public override {
bytes32 structHash = keccak256(
abi.encode(VOTE_TYPEHASH, proposalId, support, keccak256(abi.encodePacked(operatedPoolIds)))
);
@ -228,11 +188,7 @@ contract ZrxTreasury is
/// currently executable.
/// @param proposalId The ID of the proposal to execute.
/// @param actions Actions associated with the proposal to execute.
function execute(uint256 proposalId, ProposedAction[] memory actions)
public
payable
override
{
function execute(uint256 proposalId, ProposedAction[] memory actions) public payable override {
if (proposalId >= proposalCount()) {
revert("execute/INVALID_PROPOSAL_ID");
}
@ -244,10 +200,7 @@ contract ZrxTreasury is
for (uint256 i = 0; i != actions.length; i++) {
ProposedAction memory action = actions[i];
(bool didSucceed, ) = action.target.call{value: action.value}(action.data);
require(
didSucceed,
"execute/ACTION_EXECUTION_FAILED"
);
require(didSucceed, "execute/ACTION_EXECUTION_FAILED");
}
emit ProposalExecuted(proposalId);
@ -255,12 +208,7 @@ contract ZrxTreasury is
/// @dev Returns the total number of proposals.
/// @return count The number of proposals.
function proposalCount()
public
override
view
returns (uint256 count)
{
function proposalCount() public view override returns (uint256 count) {
return proposals.length;
}
@ -276,39 +224,29 @@ contract ZrxTreasury is
/// @return votingPower The current voting power of the given account.
function getVotingPower(address account, bytes32[] memory operatedPoolIds)
public
override
view
override
returns (uint256 votingPower)
{
uint256 delegatedBalance = stakingProxy.getOwnerStakeByStatus(
account,
IStaking.StakeStatus.DELEGATED
).currentEpochBalance;
uint256 balanceDelegatedToDefaultPool = stakingProxy.getStakeDelegatedToPoolByOwner(
account,
defaultPoolId
).currentEpochBalance;
uint256 delegatedBalance = stakingProxy
.getOwnerStakeByStatus(account, IStaking.StakeStatus.DELEGATED)
.currentEpochBalance;
uint256 balanceDelegatedToDefaultPool = stakingProxy
.getStakeDelegatedToPoolByOwner(account, defaultPoolId)
.currentEpochBalance;
// Voting power for ZRX delegated to the default pool is not diluted,
// so we double-count the balance delegated to the default pool before
// dividing by 2.
votingPower = delegatedBalance
.safeAdd(balanceDelegatedToDefaultPool)
.safeDiv(2);
votingPower = delegatedBalance.safeAdd(balanceDelegatedToDefaultPool).safeDiv(2);
// Add voting power for operated staking pools.
for (uint256 i = 0; i != operatedPoolIds.length; i++) {
for (uint256 j = 0; j != i; j++) {
require(
operatedPoolIds[i] != operatedPoolIds[j],
"getVotingPower/DUPLICATE_POOL_ID"
);
require(operatedPoolIds[i] != operatedPoolIds[j], "getVotingPower/DUPLICATE_POOL_ID");
}
IStaking.Pool memory pool = stakingProxy.getStakingPool(operatedPoolIds[i]);
require(
pool.operator == account,
"getVotingPower/POOL_NOT_OPERATED_BY_ACCOUNT"
);
require(pool.operator == account, "getVotingPower/POOL_NOT_OPERATED_BY_ACCOUNT");
uint96 stakeDelegatedToPool = stakingProxy
.getTotalStakeDelegatedToPool(operatedPoolIds[i])
.currentEpochBalance;
@ -322,25 +260,10 @@ contract ZrxTreasury is
/// @dev Checks whether the given proposal is executable.
/// Reverts if not.
/// @param proposal The proposal to check.
function _assertProposalExecutable(
Proposal memory proposal,
ProposedAction[] memory actions
)
private
view
{
require(
keccak256(abi.encode(actions)) == proposal.actionsHash,
"_assertProposalExecutable/INVALID_ACTIONS"
);
require(
_hasProposalPassed(proposal),
"_assertProposalExecutable/PROPOSAL_HAS_NOT_PASSED"
);
require(
!proposal.executed,
"_assertProposalExecutable/PROPOSAL_ALREADY_EXECUTED"
);
function _assertProposalExecutable(Proposal memory proposal, ProposedAction[] memory actions) private view {
require(keccak256(abi.encode(actions)) == proposal.actionsHash, "_assertProposalExecutable/INVALID_ACTIONS");
require(_hasProposalPassed(proposal), "_assertProposalExecutable/PROPOSAL_HAS_NOT_PASSED");
require(!proposal.executed, "_assertProposalExecutable/PROPOSAL_ALREADY_EXECUTED");
require(
stakingProxy.currentEpoch() == proposal.executionEpoch,
"_assertProposalExecutable/CANNOT_EXECUTE_THIS_EPOCH"
@ -350,11 +273,7 @@ contract ZrxTreasury is
/// @dev Checks whether the given proposal has passed or not.
/// @param proposal The proposal to check.
/// @return hasPassed Whether the proposal has passed.
function _hasProposalPassed(Proposal memory proposal)
private
view
returns (bool hasPassed)
{
function _hasProposalPassed(Proposal memory proposal) private view returns (bool hasPassed) {
// Proposal is not passed until the vote is over.
if (!_hasVoteEnded(proposal.voteEpoch)) {
return false;
@ -374,11 +293,7 @@ contract ZrxTreasury is
/// epoch has ended or not.
/// @param voteEpoch The epoch at which the vote started.
/// @return hasEnded Whether the vote has ended.
function _hasVoteEnded(uint256 voteEpoch)
private
view
returns (bool hasEnded)
{
function _hasVoteEnded(uint256 voteEpoch) private view returns (bool hasEnded) {
uint256 currentEpoch = stakingProxy.currentEpoch();
if (currentEpoch < voteEpoch) {
return false;
@ -388,9 +303,7 @@ contract ZrxTreasury is
}
// voteEpoch == currentEpoch
// Vote ends at currentEpochStartTime + votingPeriod
uint256 voteEndTime = stakingProxy
.currentEpochStartTimeInSeconds()
.safeAdd(votingPeriod);
uint256 voteEndTime = stakingProxy.currentEpochStartTimeInSeconds().safeAdd(votingPeriod);
return block.timestamp > voteEndTime;
}
@ -402,9 +315,7 @@ contract ZrxTreasury is
uint256 proposalId,
bool support,
bytes32[] memory operatedPoolIds
)
private
{
) private {
if (proposalId >= proposalCount()) {
revert("_castVote/INVALID_PROPOSAL_ID");
}
@ -413,10 +324,7 @@ contract ZrxTreasury is
}
Proposal memory proposal = proposals[proposalId];
if (
proposal.voteEpoch != stakingProxy.currentEpoch() ||
_hasVoteEnded(proposal.voteEpoch)
) {
if (proposal.voteEpoch != stakingProxy.currentEpoch() || _hasVoteEnded(proposal.voteEpoch)) {
revert("_castVote/VOTING_IS_CLOSED");
}
@ -426,27 +334,21 @@ contract ZrxTreasury is
}
if (support) {
proposals[proposalId].votesFor = proposals[proposalId].votesFor
.safeAdd(votingPower);
proposals[proposalId].votesFor = proposals[proposalId].votesFor.safeAdd(votingPower);
} else {
proposals[proposalId].votesAgainst = proposals[proposalId].votesAgainst
.safeAdd(votingPower);
proposals[proposalId].votesAgainst = proposals[proposalId].votesAgainst.safeAdd(votingPower);
}
hasVoted[proposalId][voter] = true;
emit VoteCast(
voter,
operatedPoolIds,
proposalId,
support,
votingPower
);
emit VoteCast(voter, operatedPoolIds, proposalId, support, votingPower);
}
/// @dev Gets the Ethereum chain id
function _getChainId() private pure returns (uint256) {
uint256 chainId;
assembly { chainId := chainid() }
assembly {
chainId := chainid()
}
return chainId;
}
}

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

@ -23,14 +23,10 @@ import "./LibAuthorizableRichErrors.sol";
import "./LibRichErrors.sol";
import "./Ownable.sol";
// solhint-disable no-empty-blocks
contract Authorizable is
Ownable,
IAuthorizable
{
contract Authorizable is Ownable, IAuthorizable {
/// @dev Only authorized addresses can invoke functions with this modifier.
modifier onlyAuthorized {
modifier onlyAuthorized() {
_assertSenderIsAuthorized();
_;
}
@ -38,33 +34,24 @@ contract Authorizable is
/// @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;
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()
{}
constructor() public Ownable() {}
/// @dev Authorizes an address.
/// @param target Address to authorize.
function addAuthorizedAddress(address target)
external
onlyOwner
{
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
{
function removeAuthorizedAddress(address target) external onlyOwner {
if (!authorized[target]) {
LibRichErrors.rrevert(LibAuthorizableRichErrors.TargetNotAuthorizedError(target));
}
@ -79,31 +66,18 @@ contract Authorizable is
/// @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
{
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)
{
function getAuthorizedAddresses() external view returns (address[] memory) {
return authorities;
}
/// @dev Reverts if msg.sender is not authorized.
function _assertSenderIsAuthorized()
internal
view
{
function _assertSenderIsAuthorized() internal view {
if (!authorized[msg.sender]) {
LibRichErrors.rrevert(LibAuthorizableRichErrors.SenderNotAuthorizedError(msg.sender));
}
@ -111,9 +85,7 @@ contract Authorizable is
/// @dev Authorizes an address.
/// @param target Address to authorize.
function _addAuthorizedAddress(address target)
internal
{
function _addAuthorizedAddress(address target) internal {
// Ensure that the target is not the zero address.
if (target == address(0)) {
LibRichErrors.rrevert(LibAuthorizableRichErrors.ZeroCantBeAuthorizedError());
@ -132,26 +104,15 @@ contract Authorizable is
/// @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
{
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
));
LibRichErrors.rrevert(LibAuthorizableRichErrors.IndexOutOfBoundsError(index, authorities.length));
}
if (authorities[index] != target) {
LibRichErrors.rrevert(LibAuthorizableRichErrors.AuthorizedAddressMismatchError(
authorities[index],
target
));
LibRichErrors.rrevert(LibAuthorizableRichErrors.AuthorizedAddressMismatchError(authorities[index], target));
}
delete authorized[target];

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

@ -18,201 +18,124 @@
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);
int256 private constant DECIMAL_ONE = int256(10**PRECISION);
/// @dev Minimum signed integer value.
int256 private constant MIN_INT256_VALUE = int256(0x8000000000000000000000000000000000000000000000000000000000000000);
int256 private constant MIN_INT256_VALUE =
int256(0x8000000000000000000000000000000000000000000000000000000000000000);
/// @dev Return `1.0`
function one()
internal
pure
returns (int256 r)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
function _mul(int256 a, int256 b) private pure returns (int256 r) {
if (a == 0 || b == 0) {
return 0;
}
@ -222,27 +145,15 @@ library D18 {
}
/// @dev Safely divide two signed integers.
function _div(int256 a, int256 b)
private
pure
returns (int256 r)
{
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)
{
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"
);
require(!((a < 0 && b < 0 && r > a) || (a > 0 && b > 0 && r < a)), "D18/DECIMAL_ADD_OVERFLOW");
}
}

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

@ -18,48 +18,46 @@
pragma solidity ^0.5.9;
contract DeploymentConstants {
// solhint-disable separate-by-one-line-in-contract
// Mainnet addresses ///////////////////////////////////////////////////////
/// @dev Mainnet address of the WETH contract.
address constant private WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address private constant WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
/// @dev Mainnet address of the KyberNetworkProxy contract.
address constant private KYBER_NETWORK_PROXY_ADDRESS = 0x9AAb3f75489902f3a48495025729a0AF77d4b11e;
address private constant KYBER_NETWORK_PROXY_ADDRESS = 0x9AAb3f75489902f3a48495025729a0AF77d4b11e;
/// @dev Mainnet address of the KyberHintHandler contract.
address constant private KYBER_HINT_HANDLER_ADDRESS = 0xa1C0Fa73c39CFBcC11ec9Eb1Afc665aba9996E2C;
address private constant KYBER_HINT_HANDLER_ADDRESS = 0xa1C0Fa73c39CFBcC11ec9Eb1Afc665aba9996E2C;
/// @dev Mainnet address of the `UniswapExchangeFactory` contract.
address constant private UNISWAP_EXCHANGE_FACTORY_ADDRESS = 0xc0a47dFe034B400B47bDaD5FecDa2621de6c4d95;
address private constant UNISWAP_EXCHANGE_FACTORY_ADDRESS = 0xc0a47dFe034B400B47bDaD5FecDa2621de6c4d95;
/// @dev Mainnet address of the `UniswapV2Router01` contract.
address constant private UNISWAP_V2_ROUTER_01_ADDRESS = 0xf164fC0Ec4E93095b804a4795bBe1e041497b92a;
address private constant UNISWAP_V2_ROUTER_01_ADDRESS = 0xf164fC0Ec4E93095b804a4795bBe1e041497b92a;
/// @dev Mainnet address of the Eth2Dai `MatchingMarket` contract.
address constant private ETH2DAI_ADDRESS = 0x794e6e91555438aFc3ccF1c5076A74F42133d08D;
address private constant ETH2DAI_ADDRESS = 0x794e6e91555438aFc3ccF1c5076A74F42133d08D;
/// @dev Mainnet address of the `ERC20BridgeProxy` contract
address constant private ERC20_BRIDGE_PROXY_ADDRESS = 0x8ED95d1746bf1E4dAb58d8ED4724f1Ef95B20Db0;
address private constant ERC20_BRIDGE_PROXY_ADDRESS = 0x8ED95d1746bf1E4dAb58d8ED4724f1Ef95B20Db0;
///@dev Mainnet address of the `Dai` (multi-collateral) contract
address constant private DAI_ADDRESS = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
address private constant DAI_ADDRESS = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
/// @dev Mainnet address of the `Chai` contract
address constant private CHAI_ADDRESS = 0x06AF07097C9Eeb7fD685c692751D5C66dB49c215;
address private constant CHAI_ADDRESS = 0x06AF07097C9Eeb7fD685c692751D5C66dB49c215;
/// @dev Mainnet address of the 0x DevUtils contract.
address constant private DEV_UTILS_ADDRESS = 0x74134CF88b21383713E096a5ecF59e297dc7f547;
address private constant DEV_UTILS_ADDRESS = 0x74134CF88b21383713E096a5ecF59e297dc7f547;
/// @dev Kyber ETH pseudo-address.
address constant internal KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address internal constant KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
/// @dev Mainnet address of the dYdX contract.
address constant private DYDX_ADDRESS = 0x1E0447b19BB6EcFdAe1e4AE1694b0C3659614e4e;
address private constant DYDX_ADDRESS = 0x1E0447b19BB6EcFdAe1e4AE1694b0C3659614e4e;
/// @dev Mainnet address of the GST2 contract
address constant private GST_ADDRESS = 0x0000000000b3F879cb30FE243b4Dfee438691c04;
address private constant GST_ADDRESS = 0x0000000000b3F879cb30FE243b4Dfee438691c04;
/// @dev Mainnet address of the GST Collector
address constant private GST_COLLECTOR_ADDRESS = 0x000000D3b08566BE75A6DB803C03C85C0c1c5B96;
address private constant GST_COLLECTOR_ADDRESS = 0x000000D3b08566BE75A6DB803C03C85C0c1c5B96;
/// @dev Mainnet address of the mStable mUSD contract.
address constant private MUSD_ADDRESS = 0xe2f2a5C287993345a840Db3B0845fbC70f5935a5;
address private constant MUSD_ADDRESS = 0xe2f2a5C287993345a840Db3B0845fbC70f5935a5;
/// @dev Mainnet address of the Mooniswap Registry contract
address constant private MOONISWAP_REGISTRY = 0x71CD6666064C3A1354a3B4dca5fA1E2D3ee7D303;
address private constant MOONISWAP_REGISTRY = 0x71CD6666064C3A1354a3B4dca5fA1E2D3ee7D303;
/// @dev Mainnet address of the DODO Registry (ZOO) contract
address constant private DODO_REGISTRY = 0x3A97247DF274a17C59A3bd12735ea3FcDFb49950;
address private constant DODO_REGISTRY = 0x3A97247DF274a17C59A3bd12735ea3FcDFb49950;
/// @dev Mainnet address of the DODO Helper contract
address constant private DODO_HELPER = 0x533dA777aeDCE766CEAe696bf90f8541A4bA80Eb;
address private constant DODO_HELPER = 0x533dA777aeDCE766CEAe696bf90f8541A4bA80Eb;
// // Ropsten addresses ///////////////////////////////////////////////////////
// /// @dev Mainnet address of the WETH contract.
@ -153,171 +151,103 @@ contract DeploymentConstants {
/// @dev Overridable way to get the `KyberNetworkProxy` address.
/// @return kyberAddress The `IKyberNetworkProxy` address.
function _getKyberNetworkProxyAddress()
internal
view
returns (address kyberAddress)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
function _getDODOHelperAddress() internal view returns (address) {
return DODO_HELPER;
}
}

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

@ -18,12 +18,10 @@
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,
@ -40,8 +38,9 @@ library LibAddress {
// 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) }
assembly {
size := extcodesize(account)
}
return size > 0;
}
}

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

@ -22,9 +22,7 @@ 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
@ -32,11 +30,7 @@ library LibAddressArray {
/// @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)
{
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;
@ -54,10 +48,7 @@ library LibAddressArray {
// `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
));
LibRichErrors.rrevert(LibAddressArrayRichErrors.MismanagedMemoryError(freeMemPtr, addressArrayEndPtr));
}
// If free memory begins at the end of `addressArray`
@ -92,13 +83,8 @@ library LibAddressArray {
/// @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)
{
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
@ -107,8 +93,11 @@ library LibAddressArray {
let arrayContentsEnd := add(arrayContentsStart, arrayByteLen)
// Loop through array
for {let i:= arrayContentsStart} lt(i, arrayContentsEnd) {i := add(i, 32)} {
for {
let i := arrayContentsStart
} lt(i, arrayContentsEnd) {
i := add(i, 32)
} {
// Load array element
let arrayElement := mload(i)
@ -134,7 +123,6 @@ library LibAddressArray {
returns (bool success, uint256 index)
{
assembly {
// Calculate byte length of array
let arrayByteLen := mul(mload(addressArray), 32)
// Calculate beginning of array contents
@ -143,8 +131,11 @@ library LibAddressArray {
let arrayContentsEnd := add(arrayContentsStart, arrayByteLen)
// Loop through array
for {let i:= arrayContentsStart} lt(i, arrayContentsEnd) {i := add(i, 32)} {
for {
let i := arrayContentsStart
} lt(i, arrayContentsEnd) {
i := add(i, 32)
} {
// Load array element
let arrayElement := mload(i)

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

@ -18,26 +18,16 @@
pragma solidity ^0.5.9;
library LibAddressArrayRichErrors {
// bytes4(keccak256("MismanagedMemoryError(uint256,uint256)"))
bytes4 internal constant MISMANAGED_MEMORY_ERROR_SELECTOR =
0x5fc83722;
bytes4 internal constant MISMANAGED_MEMORY_ERROR_SELECTOR = 0x5fc83722;
// solhint-disable func-name-mixedcase
function MismanagedMemoryError(
uint256 freeMemPtr,
uint256 addressArrayEndPtr
)
function MismanagedMemoryError(uint256 freeMemPtr, uint256 addressArrayEndPtr)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
MISMANAGED_MEMORY_ERROR_SELECTOR,
freeMemPtr,
addressArrayEndPtr
);
return abi.encodeWithSelector(MISMANAGED_MEMORY_ERROR_SELECTOR, freeMemPtr, addressArrayEndPtr);
}
}

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

@ -18,102 +18,47 @@
pragma solidity ^0.5.9;
library LibAuthorizableRichErrors {
// bytes4(keccak256("AuthorizedAddressMismatchError(address,address)"))
bytes4 internal constant AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR =
0x140a84db;
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 internal constant INDEX_OUT_OF_BOUNDS_ERROR_SELECTOR = 0xe9f83771;
// bytes4(keccak256("SenderNotAuthorizedError(address)"))
bytes4 internal constant SENDER_NOT_AUTHORIZED_ERROR_SELECTOR =
0xb65a25b9;
bytes4 internal constant SENDER_NOT_AUTHORIZED_ERROR_SELECTOR = 0xb65a25b9;
// bytes4(keccak256("TargetAlreadyAuthorizedError(address)"))
bytes4 internal constant TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR =
0xde16f1a0;
bytes4 internal constant TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR = 0xde16f1a0;
// bytes4(keccak256("TargetNotAuthorizedError(address)"))
bytes4 internal constant TARGET_NOT_AUTHORIZED_ERROR_SELECTOR =
0xeb5108a2;
bytes4 internal constant TARGET_NOT_AUTHORIZED_ERROR_SELECTOR = 0xeb5108a2;
// bytes4(keccak256("ZeroCantBeAuthorizedError()"))
bytes internal constant ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES =
hex"57654fe4";
bytes internal constant ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES = hex"57654fe4";
// solhint-disable func-name-mixedcase
function AuthorizedAddressMismatchError(
address authorized,
address target
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR,
authorized,
target
);
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 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 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 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 TargetNotAuthorizedError(address target) internal pure returns (bytes memory) {
return abi.encodeWithSelector(TARGET_NOT_AUTHORIZED_ERROR_SELECTOR, target);
}
function ZeroCantBeAuthorizedError()
internal
pure
returns (bytes memory)
{
function ZeroCantBeAuthorizedError() internal pure returns (bytes memory) {
return ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES;
}
}

240
contracts/utils/contracts/src/LibBytes.sol
View File

@ -21,9 +21,7 @@ pragma solidity ^0.5.9;
import "./LibBytesRichErrors.sol";
import "./LibRichErrors.sol";
library LibBytes {
using LibBytes for bytes;
/// @dev Gets the memory address for a byte array.
@ -31,11 +29,7 @@ library LibBytes {
/// @return memoryAddress Memory address of byte array. This
/// points to the header of the byte array which contains
/// the length.
function rawAddress(bytes memory input)
internal
pure
returns (uint256 memoryAddress)
{
function rawAddress(bytes memory input) internal pure returns (uint256 memoryAddress) {
assembly {
memoryAddress := input
}
@ -45,11 +39,7 @@ library LibBytes {
/// @dev Gets the memory address for the contents of a byte array.
/// @param input Byte array to lookup.
/// @return memoryAddress Memory address of the contents of the byte array.
function contentAddress(bytes memory input)
internal
pure
returns (uint256 memoryAddress)
{
function contentAddress(bytes memory input) internal pure returns (uint256 memoryAddress) {
assembly {
memoryAddress := add(input, 32)
}
@ -64,10 +54,7 @@ library LibBytes {
uint256 dest,
uint256 source,
uint256 length
)
internal
pure
{
) internal pure {
if (length < 32) {
// Handle a partial word by reading destination and masking
// off the bits we are interested in.
@ -119,7 +106,11 @@ library LibBytes {
// Note: the first check is always true,
// this could have been a do-while loop.
// solhint-disable-next-line no-empty-blocks
for {} lt(source, sEnd) {} {
for {
} lt(source, sEnd) {
} {
mstore(dest, mload(source))
source := add(source, 32)
dest := add(dest, 32)
@ -150,7 +141,11 @@ library LibBytes {
// Note: the first check is always true,
// this could have been a do-while loop.
// solhint-disable-next-line no-empty-blocks
for {} slt(dest, dEnd) {} {
for {
} slt(dest, dEnd) {
} {
mstore(dEnd, mload(sEnd))
sEnd := sub(sEnd, 32)
dEnd := sub(dEnd, 32)
@ -172,35 +167,31 @@ library LibBytes {
bytes memory b,
uint256 from,
uint256 to
)
internal
pure
returns (bytes memory result)
{
) internal pure returns (bytes memory result) {
// Ensure that the from and to positions are valid positions for a slice within
// the byte array that is being used.
if (from > to) {
LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
from,
to
));
LibRichErrors.rrevert(
LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
from,
to
)
);
}
if (to > b.length) {
LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
to,
b.length
));
LibRichErrors.rrevert(
LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
to,
b.length
)
);
}
// Create a new bytes structure and copy contents
result = new bytes(to - from);
memCopy(
result.contentAddress(),
b.contentAddress() + from,
result.length
);
memCopy(result.contentAddress(), b.contentAddress() + from, result.length);
return result;
}
@ -214,26 +205,26 @@ library LibBytes {
bytes memory b,
uint256 from,
uint256 to
)
internal
pure
returns (bytes memory result)
{
) internal pure returns (bytes memory result) {
// Ensure that the from and to positions are valid positions for a slice within
// the byte array that is being used.
if (from > to) {
LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
from,
to
));
LibRichErrors.rrevert(
LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
from,
to
)
);
}
if (to > b.length) {
LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
to,
b.length
));
LibRichErrors.rrevert(
LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
to,
b.length
)
);
}
// Create a new bytes structure around [from, to) in-place.
@ -247,17 +238,15 @@ library LibBytes {
/// @dev Pops the last byte off of a byte array by modifying its length.
/// @param b Byte array that will be modified.
/// @return The byte that was popped off.
function popLastByte(bytes memory b)
internal
pure
returns (bytes1 result)
{
function popLastByte(bytes memory b) internal pure returns (bytes1 result) {
if (b.length == 0) {
LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanZeroRequired,
b.length,
0
));
LibRichErrors.rrevert(
LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanZeroRequired,
b.length,
0
)
);
}
// Store last byte.
@ -275,14 +264,7 @@ library LibBytes {
/// @param lhs First byte array to compare.
/// @param rhs Second byte array to compare.
/// @return True if arrays are the same. False otherwise.
function equals(
bytes memory lhs,
bytes memory rhs
)
internal
pure
returns (bool equal)
{
function equals(bytes memory lhs, bytes memory rhs) internal pure returns (bool equal) {
// Keccak gas cost is 30 + numWords * 6. This is a cheap way to compare.
// We early exit on unequal lengths, but keccak would also correctly
// handle this.
@ -293,20 +275,15 @@ library LibBytes {
/// @param b Byte array containing an address.
/// @param index Index in byte array of address.
/// @return address from byte array.
function readAddress(
bytes memory b,
uint256 index
)
internal
pure
returns (address result)
{
function readAddress(bytes memory b, uint256 index) internal pure returns (address result) {
if (b.length < index + 20) {
LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
b.length,
index + 20 // 20 is length of address
));
LibRichErrors.rrevert(
LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
b.length,
index + 20 // 20 is length of address
)
);
}
// Add offset to index:
@ -332,16 +309,15 @@ library LibBytes {
bytes memory b,
uint256 index,
address input
)
internal
pure
{
) internal pure {
if (b.length < index + 20) {
LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
b.length,
index + 20 // 20 is length of address
));
LibRichErrors.rrevert(
LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
b.length,
index + 20 // 20 is length of address
)
);
}
// Add offset to index:
@ -377,20 +353,15 @@ library LibBytes {
/// @param b Byte array containing a bytes32 value.
/// @param index Index in byte array of bytes32 value.
/// @return bytes32 value from byte array.
function readBytes32(
bytes memory b,
uint256 index
)
internal
pure
returns (bytes32 result)
{
function readBytes32(bytes memory b, uint256 index) internal pure returns (bytes32 result) {
if (b.length < index + 32) {
LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
b.length,
index + 32
));
LibRichErrors.rrevert(
LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
b.length,
index + 32
)
);
}
// Arrays are prefixed by a 256 bit length parameter
@ -411,16 +382,15 @@ library LibBytes {
bytes memory b,
uint256 index,
bytes32 input
)
internal
pure
{
) internal pure {
if (b.length < index + 32) {
LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
b.length,
index + 32
));
LibRichErrors.rrevert(
LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
b.length,
index + 32
)
);
}
// Arrays are prefixed by a 256 bit length parameter
@ -436,14 +406,7 @@ library LibBytes {
/// @param b Byte array containing a uint256 value.
/// @param index Index in byte array of uint256 value.
/// @return uint256 value from byte array.
function readUint256(
bytes memory b,
uint256 index
)
internal
pure
returns (uint256 result)
{
function readUint256(bytes memory b, uint256 index) internal pure returns (uint256 result) {
result = uint256(readBytes32(b, index));
return result;
}
@ -456,10 +419,7 @@ library LibBytes {
bytes memory b,
uint256 index,
uint256 input
)
internal
pure
{
) internal pure {
writeBytes32(b, index, bytes32(input));
}
@ -467,20 +427,15 @@ library LibBytes {
/// @param b Byte array containing a bytes4 value.
/// @param index Index in byte array of bytes4 value.
/// @return bytes4 value from byte array.
function readBytes4(
bytes memory b,
uint256 index
)
internal
pure
returns (bytes4 result)
{
function readBytes4(bytes memory b, uint256 index) internal pure returns (bytes4 result) {
if (b.length < index + 4) {
LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsFourRequired,
b.length,
index + 4
));
LibRichErrors.rrevert(
LibBytesRichErrors.InvalidByteOperationError(
LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsFourRequired,
b.length,
index + 4
)
);
}
// Arrays are prefixed by a 32 byte length field
@ -501,10 +456,7 @@ library LibBytes {
/// Increasing length may lead to appending adjacent in-memory bytes to the end of the byte array.
/// @param b Bytes array to write new length to.
/// @param length New length of byte array.
function writeLength(bytes memory b, uint256 length)
internal
pure
{
function writeLength(bytes memory b, uint256 length) internal pure {
assembly {
mstore(b, length)
}

18
contracts/utils/contracts/src/LibBytesRichErrors.sol
View File

@ -18,9 +18,7 @@
pragma solidity ^0.5.9;
library LibBytesRichErrors {
enum InvalidByteOperationErrorCodes {
FromLessThanOrEqualsToRequired,
ToLessThanOrEqualsLengthRequired,
@ -33,24 +31,14 @@ library LibBytesRichErrors {
}
// bytes4(keccak256("InvalidByteOperationError(uint8,uint256,uint256)"))
bytes4 internal constant INVALID_BYTE_OPERATION_ERROR_SELECTOR =
0x28006595;
bytes4 internal constant INVALID_BYTE_OPERATION_ERROR_SELECTOR = 0x28006595;
// solhint-disable func-name-mixedcase
function InvalidByteOperationError(
InvalidByteOperationErrorCodes errorCode,
uint256 offset,
uint256 required
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
INVALID_BYTE_OPERATION_ERROR_SELECTOR,
errorCode,
offset,
required
);
) internal pure returns (bytes memory) {
return abi.encodeWithSelector(INVALID_BYTE_OPERATION_ERROR_SELECTOR, errorCode, offset, required);
}
}

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

@ -18,10 +18,8 @@
pragma solidity ^0.5.9;
contract LibEIP1271 {
/// @dev Magic bytes returned by EIP1271 wallets on success.
/// @return 0 Magic bytes.
bytes4 constant public EIP1271_MAGIC_VALUE = 0x20c13b0b;
bytes4 public constant EIP1271_MAGIC_VALUE = 0x20c13b0b;
}

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

@ -18,9 +18,7 @@
pragma solidity ^0.5.9;
library LibEIP712 {
// Hash of the EIP712 Domain Separator Schema
// keccak256(abi.encodePacked(
// "EIP712Domain(",
@ -30,7 +28,8 @@ library LibEIP712 {
// "address verifyingContract",
// ")"
// ))
bytes32 constant internal _EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH = 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;
bytes32 internal constant _EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH =
0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;
/// @dev Calculates a EIP712 domain separator.
/// @param name The EIP712 domain name.
@ -42,11 +41,7 @@ library LibEIP712 {
string memory version,
uint256 chainId,
address verifyingContract
)
internal
pure
returns (bytes32 result)
{
) internal pure returns (bytes32 result) {
bytes32 schemaHash = _EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH;
// Assembly for more efficient computing:
@ -84,11 +79,7 @@ library LibEIP712 {
/// 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)
{
function hashEIP712Message(bytes32 eip712DomainHash, bytes32 hashStruct) internal pure returns (bytes32 result) {
// Assembly for more efficient computing:
// keccak256(abi.encodePacked(
// EIP191_HEADER,
@ -100,9 +91,9 @@ library LibEIP712 {
// 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
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)

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

@ -2,9 +2,7 @@ pragma solidity ^0.5.9;
import "./LibSafeMath.sol";
library LibFractions {
using LibSafeMath for uint256;
/// @dev Safely adds two fractions `n1/d1 + n2/d2`
@ -19,23 +17,14 @@ library LibFractions {
uint256 d1,
uint256 n2,
uint256 d2
)
internal
pure
returns (
uint256 numerator,
uint256 denominator
)
{
) 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));
numerator = n1.safeMul(d2).safeAdd(n2.safeMul(d1));
denominator = d1.safeMul(d2);
return (numerator, denominator);
}
@ -52,14 +41,7 @@ library LibFractions {
uint256 numerator,
uint256 denominator,
uint256 maxValue
)
internal
pure
returns (
uint256 scaledNumerator,
uint256 scaledDenominator
)
{
) 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) {
@ -80,18 +62,12 @@ library LibFractions {
/// @param denominator The denominator.
/// @return scaledNumerator The rescaled numerator.
/// @return scaledDenominator The rescaled denominator.
function normalize(
uint256 numerator,
uint256 denominator
)
function normalize(uint256 numerator, uint256 denominator)
internal
pure
returns (
uint256 scaledNumerator,
uint256 scaledDenominator
)
returns (uint256 scaledNumerator, uint256 scaledDenominator)
{
return normalize(numerator, denominator, 2 ** 127);
return normalize(numerator, denominator, 2**127);
}
/// @dev Safely scales the difference between two fractions.
@ -107,25 +83,15 @@ library LibFractions {
uint256 n2,
uint256 d2,
uint256 s
)
internal
pure
returns (uint256 result)
{
) internal pure returns (uint256 result) {
if (s == 0) {
return 0;
}
if (n2 == 0) {
return result = s
.safeMul(n1)
.safeDiv(d1);
return result = s.safeMul(n1).safeDiv(d1);
}
uint256 numerator = n1
.safeMul(d2)
.safeSub(n2.safeMul(d1));
uint256 numerator = n1.safeMul(d2).safeSub(n2.safeMul(d1));
uint256 tmp = numerator.safeDiv(d2);
return s
.safeMul(tmp)
.safeDiv(d1);
return s.safeMul(tmp).safeDiv(d1);
}
}

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

@ -22,9 +22,7 @@ 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.
@ -37,21 +35,9 @@ library LibMath {
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256 partialAmount)
{
if (isRoundingErrorFloor(
numerator,
denominator,
target
)) {
LibRichErrors.rrevert(LibMathRichErrors.RoundingError(
numerator,
denominator,
target
));
) internal pure returns (uint256 partialAmount) {
if (isRoundingErrorFloor(numerator, denominator, target)) {
LibRichErrors.rrevert(LibMathRichErrors.RoundingError(numerator, denominator, target));
}
partialAmount = numerator.safeMul(target).safeDiv(denominator);
@ -68,29 +54,15 @@ library LibMath {
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256 partialAmount)
{
if (isRoundingErrorCeil(
numerator,
denominator,
target
)) {
LibRichErrors.rrevert(LibMathRichErrors.RoundingError(
numerator,
denominator,
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);
partialAmount = numerator.safeMul(target).safeAdd(denominator.safeSub(1)).safeDiv(denominator);
return partialAmount;
}
@ -104,11 +76,7 @@ library LibMath {
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256 partialAmount)
{
) internal pure returns (uint256 partialAmount) {
partialAmount = numerator.safeMul(target).safeDiv(denominator);
return partialAmount;
}
@ -122,17 +90,11 @@ library LibMath {
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256 partialAmount)
{
) 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);
partialAmount = numerator.safeMul(target).safeAdd(denominator.safeSub(1)).safeDiv(denominator);
return partialAmount;
}
@ -146,11 +108,7 @@ library LibMath {
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (bool isError)
{
) internal pure returns (bool isError) {
if (denominator == 0) {
LibRichErrors.rrevert(LibMathRichErrors.DivisionByZeroError());
}
@ -181,11 +139,7 @@ library LibMath {
// 1000 * remainder < numerator * target
// so we have a rounding error iff:
// 1000 * remainder >= numerator * target
uint256 remainder = mulmod(
target,
numerator,
denominator
);
uint256 remainder = mulmod(target, numerator, denominator);
isError = remainder.safeMul(1000) >= numerator.safeMul(target);
return isError;
}
@ -199,11 +153,7 @@ library LibMath {
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (bool isError)
{
) internal pure returns (bool isError) {
if (denominator == 0) {
LibRichErrors.rrevert(LibMathRichErrors.DivisionByZeroError());
}
@ -216,11 +166,7 @@ library LibMath {
return false;
}
// Compute remainder as before
uint256 remainder = mulmod(
target,
numerator,
denominator
);
uint256 remainder = mulmod(target, numerator, denominator);
remainder = denominator.safeSub(remainder) % denominator;
isError = remainder.safeMul(1000) >= numerator.safeMul(target);
return isError;

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

@ -1,22 +1,14 @@
pragma solidity ^0.5.9;
library LibMathRichErrors {
// bytes4(keccak256("DivisionByZeroError()"))
bytes internal constant DIVISION_BY_ZERO_ERROR =
hex"a791837c";
bytes internal constant DIVISION_BY_ZERO_ERROR = hex"a791837c";
// bytes4(keccak256("RoundingError(uint256,uint256,uint256)"))
bytes4 internal constant ROUNDING_ERROR_SELECTOR =
0x339f3de2;
bytes4 internal constant ROUNDING_ERROR_SELECTOR = 0x339f3de2;
// solhint-disable func-name-mixedcase
function DivisionByZeroError()
internal
pure
returns (bytes memory)
{
function DivisionByZeroError() internal pure returns (bytes memory) {
return DIVISION_BY_ZERO_ERROR;
}
@ -24,16 +16,7 @@ library LibMathRichErrors {
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
ROUNDING_ERROR_SELECTOR,
numerator,
denominator,
target
);
) internal pure returns (bytes memory) {
return abi.encodeWithSelector(ROUNDING_ERROR_SELECTOR, numerator, denominator, target);
}
}

29
contracts/utils/contracts/src/LibOwnableRichErrors.sol
View File

@ -1,37 +1,18 @@
pragma solidity ^0.5.9;
library LibOwnableRichErrors {
// bytes4(keccak256("OnlyOwnerError(address,address)"))
bytes4 internal constant ONLY_OWNER_ERROR_SELECTOR =
0x1de45ad1;
bytes4 internal constant ONLY_OWNER_ERROR_SELECTOR = 0x1de45ad1;
// bytes4(keccak256("TransferOwnerToZeroError()"))
bytes internal constant TRANSFER_OWNER_TO_ZERO_ERROR_BYTES =
hex"e69edc3e";
bytes internal constant TRANSFER_OWNER_TO_ZERO_ERROR_BYTES = hex"e69edc3e";
// solhint-disable func-name-mixedcase
function OnlyOwnerError(
address sender,
address owner
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
ONLY_OWNER_ERROR_SELECTOR,
sender,
owner
);
function OnlyOwnerError(address sender, address owner) internal pure returns (bytes memory) {
return abi.encodeWithSelector(ONLY_OWNER_ERROR_SELECTOR, sender, owner);
}
function TransferOwnerToZeroError()
internal
pure
returns (bytes memory)
{
function TransferOwnerToZeroError() internal pure returns (bytes memory) {
return TRANSFER_OWNER_TO_ZERO_ERROR_BYTES;
}
}

11
contracts/utils/contracts/src/LibReentrancyGuardRichErrors.sol
View File

@ -18,19 +18,12 @@
pragma solidity ^0.5.9;
library LibReentrancyGuardRichErrors {
// bytes4(keccak256("IllegalReentrancyError()"))
bytes internal constant ILLEGAL_REENTRANCY_ERROR_SELECTOR_BYTES =
hex"0c3b823f";
bytes internal constant ILLEGAL_REENTRANCY_ERROR_SELECTOR_BYTES = hex"0c3b823f";
// solhint-disable func-name-mixedcase
function IllegalReentrancyError()
internal
pure
returns (bytes memory)
{
function IllegalReentrancyError() internal pure returns (bytes memory) {
return ILLEGAL_REENTRANCY_ERROR_SELECTOR_BYTES;
}
}

24
contracts/utils/contracts/src/LibRichErrors.sol
View File

@ -18,12 +18,9 @@
pragma solidity ^0.5.9;
library LibRichErrors {
// bytes4(keccak256("Error(string)"))
bytes4 internal constant STANDARD_ERROR_SELECTOR =
0x08c379a0;
bytes4 internal constant STANDARD_ERROR_SELECTOR = 0x08c379a0;
// solhint-disable func-name-mixedcase
/// @dev ABI encode a standard, string revert error payload.
@ -31,26 +28,15 @@ library LibRichErrors {
/// solidity statement. It has the function signature `Error(string)`.
/// @param message The error string.
/// @return The ABI encoded error.
function StandardError(
string memory message
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
STANDARD_ERROR_SELECTOR,
bytes(message)
);
function StandardError(string memory message) internal pure returns (bytes memory) {
return abi.encodeWithSelector(STANDARD_ERROR_SELECTOR, bytes(message));
}
// solhint-enable func-name-mixedcase
/// @dev Reverts an encoded rich revert reason `errorData`.
/// @param errorData ABI encoded error data.
function rrevert(bytes memory errorData)
internal
pure
{
function rrevert(bytes memory errorData) internal pure {
assembly {
revert(add(errorData, 0x20), mload(errorData))
}

78
contracts/utils/contracts/src/LibSafeMath.sol
View File

@ -3,88 +3,62 @@ pragma solidity ^0.5.9;
import "./LibRichErrors.sol";
import "./LibSafeMathRichErrors.sol";
library LibSafeMath {
function safeMul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
if (c / a != b) {
LibRichErrors.rrevert(LibSafeMathRichErrors.Uint256BinOpError(
LibSafeMathRichErrors.BinOpErrorCodes.MULTIPLICATION_OVERFLOW,
a,
b
));
LibRichErrors.rrevert(
LibSafeMathRichErrors.Uint256BinOpError(
LibSafeMathRichErrors.BinOpErrorCodes.MULTIPLICATION_OVERFLOW,
a,
b
)
);
}
return c;
}
function safeDiv(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
LibRichErrors.rrevert(LibSafeMathRichErrors.Uint256BinOpError(
LibSafeMathRichErrors.BinOpErrorCodes.DIVISION_BY_ZERO,
a,
b
));
LibRichErrors.rrevert(
LibSafeMathRichErrors.Uint256BinOpError(LibSafeMathRichErrors.BinOpErrorCodes.DIVISION_BY_ZERO, a, b)
);
}
uint256 c = a / b;
return c;
}
function safeSub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
if (b > a) {
LibRichErrors.rrevert(LibSafeMathRichErrors.Uint256BinOpError(
LibSafeMathRichErrors.BinOpErrorCodes.SUBTRACTION_UNDERFLOW,
a,
b
));
LibRichErrors.rrevert(
LibSafeMathRichErrors.Uint256BinOpError(
LibSafeMathRichErrors.BinOpErrorCodes.SUBTRACTION_UNDERFLOW,
a,
b
)
);
}
return a - b;
}
function safeAdd(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
if (c < a) {
LibRichErrors.rrevert(LibSafeMathRichErrors.Uint256BinOpError(
LibSafeMathRichErrors.BinOpErrorCodes.ADDITION_OVERFLOW,
a,
b
));
LibRichErrors.rrevert(
LibSafeMathRichErrors.Uint256BinOpError(LibSafeMathRichErrors.BinOpErrorCodes.ADDITION_OVERFLOW, a, b)
);
}
return c;
}
function max256(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}

36
contracts/utils/contracts/src/LibSafeMathRichErrors.sol
View File

@ -1,15 +1,11 @@
pragma solidity ^0.5.9;
library LibSafeMathRichErrors {
// bytes4(keccak256("Uint256BinOpError(uint8,uint256,uint256)"))
bytes4 internal constant UINT256_BINOP_ERROR_SELECTOR =
0xe946c1bb;
bytes4 internal constant UINT256_BINOP_ERROR_SELECTOR = 0xe946c1bb;
// bytes4(keccak256("Uint256DowncastError(uint8,uint256)"))
bytes4 internal constant UINT256_DOWNCAST_ERROR_SELECTOR =
0xc996af7b;
bytes4 internal constant UINT256_DOWNCAST_ERROR_SELECTOR = 0xc996af7b;
enum BinOpErrorCodes {
ADDITION_OVERFLOW,
@ -29,31 +25,11 @@ library LibSafeMathRichErrors {
BinOpErrorCodes errorCode,
uint256 a,
uint256 b
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
UINT256_BINOP_ERROR_SELECTOR,
errorCode,
a,
b
);
) internal pure returns (bytes memory) {
return abi.encodeWithSelector(UINT256_BINOP_ERROR_SELECTOR, errorCode, a, b);
}
function Uint256DowncastError(
DowncastErrorCodes errorCode,
uint256 a
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
UINT256_DOWNCAST_ERROR_SELECTOR,
errorCode,
a
);
function Uint256DowncastError(DowncastErrorCodes errorCode, uint256 a) internal pure returns (bytes memory) {
return abi.encodeWithSelector(UINT256_DOWNCAST_ERROR_SELECTOR, errorCode, a);
}
}

24
contracts/utils/contracts/src/Ownable.sol
View File

@ -22,17 +22,12 @@ import "./interfaces/IOwnable.sol";
import "./LibOwnableRichErrors.sol";
import "./LibRichErrors.sol";
contract Ownable is
IOwnable
{
contract Ownable is IOwnable {
/// @dev The owner of this contract.
/// @return 0 The owner address.
address public owner;
constructor ()
public
{
constructor() public {
owner = msg.sender;
}
@ -43,10 +38,7 @@ contract Ownable is
/// @dev Change the owner of this contract.
/// @param newOwner New owner address.
function transferOwnership(address newOwner)
public
onlyOwner
{
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner == address(0)) {
LibRichErrors.rrevert(LibOwnableRichErrors.TransferOwnerToZeroError());
} else {
@ -55,15 +47,9 @@ contract Ownable is
}
}
function _assertSenderIsOwner()
internal
view
{
function _assertSenderIsOwner() internal view {
if (msg.sender != owner) {
LibRichErrors.rrevert(LibOwnableRichErrors.OnlyOwnerError(
msg.sender,
owner
));
LibRichErrors.rrevert(LibOwnableRichErrors.OnlyOwnerError(msg.sender, owner));
}
}
}

14
contracts/utils/contracts/src/ReentrancyGuard.sol
View File

@ -21,9 +21,7 @@ pragma solidity ^0.5.9;
import "./LibReentrancyGuardRichErrors.sol";
import "./LibRichErrors.sol";
contract ReentrancyGuard {
// Locked state of mutex.
bool private _locked = false;
@ -35,22 +33,16 @@ contract ReentrancyGuard {
_unlockMutex();
}
function _lockMutexOrThrowIfAlreadyLocked()
internal
{
function _lockMutexOrThrowIfAlreadyLocked() internal {
// Ensure mutex is unlocked.
if (_locked) {
LibRichErrors.rrevert(
LibReentrancyGuardRichErrors.IllegalReentrancyError()
);
LibRichErrors.rrevert(LibReentrancyGuardRichErrors.IllegalReentrancyError());
}
// Lock mutex.
_locked = true;
}
function _unlockMutex()
internal
{
function _unlockMutex() internal {
// Unlock mutex.
_locked = false;
}

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

@ -20,27 +20,23 @@ pragma solidity ^0.5.9;
import "./ReentrancyGuard.sol";
contract Refundable is
ReentrancyGuard
{
contract Refundable is ReentrancyGuard {
// This bool is used by the refund modifier to allow for lazily evaluated refunds.
bool internal _shouldNotRefund;
modifier refundFinalBalance {
modifier refundFinalBalance() {
_;
_refundNonZeroBalanceIfEnabled();
}
modifier refundFinalBalanceNoReentry {
modifier refundFinalBalanceNoReentry() {
_lockMutexOrThrowIfAlreadyLocked();
_;
_refundNonZeroBalanceIfEnabled();
_unlockMutex();
}
modifier disableRefundUntilEnd {
modifier disableRefundUntilEnd() {
if (_areRefundsDisabled()) {
_;
} else {
@ -50,41 +46,29 @@ contract Refundable is
}
}
function _refundNonZeroBalanceIfEnabled()
internal
{
function _refundNonZeroBalanceIfEnabled() internal {
if (!_areRefundsDisabled()) {
_refundNonZeroBalance();
}
}
function _refundNonZeroBalance()
internal
{
function _refundNonZeroBalance() internal {
uint256 balance = address(this).balance;
if (balance > 0) {
msg.sender.transfer(balance);
}
}
function _disableRefund()
internal
{
function _disableRefund() internal {
_shouldNotRefund = true;
}
function _enableAndRefundNonZeroBalance()
internal
{
function _enableAndRefundNonZeroBalance() internal {
_shouldNotRefund = false;
_refundNonZeroBalance();
}
function _areRefundsDisabled()
internal
view
returns (bool)
{
function _areRefundsDisabled() internal view returns (bool) {
return _shouldNotRefund;
}
}

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

@ -20,45 +20,27 @@ pragma solidity ^0.5.9;
import "./IOwnable.sol";
contract IAuthorizable is
IOwnable
{
contract IAuthorizable is IOwnable {
// Event logged when a new address is authorized.
event AuthorizedAddressAdded(
address indexed target,
address indexed caller
);
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
);
event AuthorizedAddressRemoved(address indexed target, address indexed caller);
/// @dev Authorizes an address.
/// @param target Address to authorize.
function addAuthorizedAddress(address target)
external;
function addAuthorizedAddress(address target) external;
/// @dev Removes authorizion of an address.
/// @param target Address to remove authorization from.
function removeAuthorizedAddress(address target)
external;
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;
function removeAuthorizedAddressAtIndex(address target, uint256 index) external;
/// @dev Gets all authorized addresses.
/// @return Array of authorized addresses.
function getAuthorizedAddresses()
external
view
returns (address[] memory);
function getAuthorizedAddresses() external view returns (address[] memory);
}

5
contracts/utils/contracts/src/interfaces/IOwnable.sol
View File

@ -18,9 +18,7 @@
pragma solidity ^0.5.9;
contract IOwnable {
/// @dev Emitted by Ownable when ownership is transferred.
/// @param previousOwner The previous owner of the contract.
/// @param newOwner The new owner of the contract.
@ -28,6 +26,5 @@ contract IOwnable {
/// @dev Transfers ownership of the contract to a new address.
/// @param newOwner The address that will become the owner.
function transferOwnership(address newOwner)
public;
function transferOwnership(address newOwner) public;
}

71
contracts/utils/contracts/src/v06/AuthorizableV06.sol
View File

@ -24,14 +24,10 @@ import "./errors/LibRichErrorsV06.sol";
import "./errors/LibAuthorizableRichErrorsV06.sol";
import "./OwnableV06.sol";
// solhint-disable no-empty-blocks
contract AuthorizableV06 is
OwnableV06,
IAuthorizableV06
{
contract AuthorizableV06 is OwnableV06, IAuthorizableV06 {
/// @dev Only authorized addresses can invoke functions with this modifier.
modifier onlyAuthorized {
modifier onlyAuthorized() {
_assertSenderIsAuthorized();
_;
}
@ -39,35 +35,24 @@ contract AuthorizableV06 is
// @dev Whether an address is authorized to call privileged functions.
// @param 0 Address to query.
// @return 0 Whether the address is authorized.
mapping (address => bool) public override authorized;
mapping(address => bool) public override authorized;
// @dev Whether an address is authorized to call privileged functions.
// @param 0 Index of authorized address.
// @return 0 Authorized address.
address[] public override authorities;
/// @dev Initializes the `owner` address.
constructor()
public
OwnableV06()
{}
constructor() public OwnableV06() {}
/// @dev Authorizes an address.
/// @param target Address to authorize.
function addAuthorizedAddress(address target)
external
override
onlyOwner
{
function addAuthorizedAddress(address target) external override onlyOwner {
_addAuthorizedAddress(target);
}
/// @dev Removes authorizion of an address.
/// @param target Address to remove authorization from.
function removeAuthorizedAddress(address target)
external
override
onlyOwner
{
function removeAuthorizedAddress(address target) external override onlyOwner {
if (!authorized[target]) {
LibRichErrorsV06.rrevert(LibAuthorizableRichErrorsV06.TargetNotAuthorizedError(target));
}
@ -82,33 +67,18 @@ contract AuthorizableV06 is
/// @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
override
onlyOwner
{
function removeAuthorizedAddressAtIndex(address target, uint256 index) external override onlyOwner {
_removeAuthorizedAddressAtIndex(target, index);
}
/// @dev Gets all authorized addresses.
/// @return Array of authorized addresses.
function getAuthorizedAddresses()
external
override
view
returns (address[] memory)
{
function getAuthorizedAddresses() external view override returns (address[] memory) {
return authorities;
}
/// @dev Reverts if msg.sender is not authorized.
function _assertSenderIsAuthorized()
internal
view
{
function _assertSenderIsAuthorized() internal view {
if (!authorized[msg.sender]) {
LibRichErrorsV06.rrevert(LibAuthorizableRichErrorsV06.SenderNotAuthorizedError(msg.sender));
}
@ -116,9 +86,7 @@ contract AuthorizableV06 is
/// @dev Authorizes an address.
/// @param target Address to authorize.
function _addAuthorizedAddress(address target)
internal
{
function _addAuthorizedAddress(address target) internal {
// Ensure that the target is not the zero address.
if (target == address(0)) {
LibRichErrorsV06.rrevert(LibAuthorizableRichErrorsV06.ZeroCantBeAuthorizedError());
@ -137,26 +105,17 @@ contract AuthorizableV06 is
/// @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
{
function _removeAuthorizedAddressAtIndex(address target, uint256 index) internal {
if (!authorized[target]) {
LibRichErrorsV06.rrevert(LibAuthorizableRichErrorsV06.TargetNotAuthorizedError(target));
}
if (index >= authorities.length) {
LibRichErrorsV06.rrevert(LibAuthorizableRichErrorsV06.IndexOutOfBoundsError(
index,
authorities.length
));
LibRichErrorsV06.rrevert(LibAuthorizableRichErrorsV06.IndexOutOfBoundsError(index, authorities.length));
}
if (authorities[index] != target) {
LibRichErrorsV06.rrevert(LibAuthorizableRichErrorsV06.AuthorizedAddressMismatchError(
authorities[index],
target
));
LibRichErrorsV06.rrevert(
LibAuthorizableRichErrorsV06.AuthorizedAddressMismatchError(authorities[index], target)
);
}
delete authorized[target];

240
contracts/utils/contracts/src/v06/LibBytesV06.sol
View File

@ -22,9 +22,7 @@ pragma solidity ^0.6.5;
import "./errors/LibBytesRichErrorsV06.sol";
import "./errors/LibRichErrorsV06.sol";
library LibBytesV06 {
using LibBytesV06 for bytes;
/// @dev Gets the memory address for a byte array.
@ -32,11 +30,7 @@ library LibBytesV06 {
/// @return memoryAddress Memory address of byte array. This
/// points to the header of the byte array which contains
/// the length.
function rawAddress(bytes memory input)
internal
pure
returns (uint256 memoryAddress)
{
function rawAddress(bytes memory input) internal pure returns (uint256 memoryAddress) {
assembly {
memoryAddress := input
}
@ -46,11 +40,7 @@ library LibBytesV06 {
/// @dev Gets the memory address for the contents of a byte array.
/// @param input Byte array to lookup.
/// @return memoryAddress Memory address of the contents of the byte array.
function contentAddress(bytes memory input)
internal
pure
returns (uint256 memoryAddress)
{
function contentAddress(bytes memory input) internal pure returns (uint256 memoryAddress) {
assembly {
memoryAddress := add(input, 32)
}
@ -65,10 +55,7 @@ library LibBytesV06 {
uint256 dest,
uint256 source,
uint256 length
)
internal
pure
{
) internal pure {
if (length < 32) {
// Handle a partial word by reading destination and masking
// off the bits we are interested in.
@ -120,7 +107,11 @@ library LibBytesV06 {
// Note: the first check is always true,
// this could have been a do-while loop.
// solhint-disable-next-line no-empty-blocks
for {} lt(source, sEnd) {} {
for {
} lt(source, sEnd) {
} {
mstore(dest, mload(source))
source := add(source, 32)
dest := add(dest, 32)
@ -151,7 +142,11 @@ library LibBytesV06 {
// Note: the first check is always true,
// this could have been a do-while loop.
// solhint-disable-next-line no-empty-blocks
for {} slt(dest, dEnd) {} {
for {
} slt(dest, dEnd) {
} {
mstore(dEnd, mload(sEnd))
sEnd := sub(sEnd, 32)
dEnd := sub(dEnd, 32)
@ -173,35 +168,31 @@ library LibBytesV06 {
bytes memory b,
uint256 from,
uint256 to
)
internal
pure
returns (bytes memory result)
{
) internal pure returns (bytes memory result) {
// Ensure that the from and to positions are valid positions for a slice within
// the byte array that is being used.
if (from > to) {
LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
from,
to
));
LibRichErrorsV06.rrevert(
LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
from,
to
)
);
}
if (to > b.length) {
LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
to,
b.length
));
LibRichErrorsV06.rrevert(
LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
to,
b.length
)
);
}
// Create a new bytes structure and copy contents
result = new bytes(to - from);
memCopy(
result.contentAddress(),
b.contentAddress() + from,
result.length
);
memCopy(result.contentAddress(), b.contentAddress() + from, result.length);
return result;
}
@ -216,26 +207,26 @@ library LibBytesV06 {
bytes memory b,
uint256 from,
uint256 to
)
internal
pure
returns (bytes memory result)
{
) internal pure returns (bytes memory result) {
// Ensure that the from and to positions are valid positions for a slice within
// the byte array that is being used.
if (from > to) {
LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
from,
to
));
LibRichErrorsV06.rrevert(
LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
from,
to
)
);
}
if (to > b.length) {
LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
to,
b.length
));
LibRichErrorsV06.rrevert(
LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
to,
b.length
)
);
}
// Create a new bytes structure around [from, to) in-place.
@ -249,17 +240,15 @@ library LibBytesV06 {
/// @dev Pops the last byte off of a byte array by modifying its length.
/// @param b Byte array that will be modified.
/// @return result The byte that was popped off.
function popLastByte(bytes memory b)
internal
pure
returns (bytes1 result)
{
function popLastByte(bytes memory b) internal pure returns (bytes1 result) {
if (b.length == 0) {
LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanZeroRequired,
b.length,
0
));
LibRichErrorsV06.rrevert(
LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanZeroRequired,
b.length,
0
)
);
}
// Store last byte.
@ -277,14 +266,7 @@ library LibBytesV06 {
/// @param lhs First byte array to compare.
/// @param rhs Second byte array to compare.
/// @return equal True if arrays are the same. False otherwise.
function equals(
bytes memory lhs,
bytes memory rhs
)
internal
pure
returns (bool equal)
{
function equals(bytes memory lhs, bytes memory rhs) internal pure returns (bool equal) {
// Keccak gas cost is 30 + numWords * 6. This is a cheap way to compare.
// We early exit on unequal lengths, but keccak would also correctly
// handle this.
@ -295,20 +277,15 @@ library LibBytesV06 {
/// @param b Byte array containing an address.
/// @param index Index in byte array of address.
/// @return result address from byte array.
function readAddress(
bytes memory b,
uint256 index
)
internal
pure
returns (address result)
{
function readAddress(bytes memory b, uint256 index) internal pure returns (address result) {
if (b.length < index + 20) {
LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
b.length,
index + 20 // 20 is length of address
));
LibRichErrorsV06.rrevert(
LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
b.length,
index + 20 // 20 is length of address
)
);
}
// Add offset to index:
@ -334,16 +311,15 @@ library LibBytesV06 {
bytes memory b,
uint256 index,
address input
)
internal
pure
{
) internal pure {
if (b.length < index + 20) {
LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
b.length,
index + 20 // 20 is length of address
));
LibRichErrorsV06.rrevert(
LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
b.length,
index + 20 // 20 is length of address
)
);
}
// Add offset to index:
@ -379,20 +355,15 @@ library LibBytesV06 {
/// @param b Byte array containing a bytes32 value.
/// @param index Index in byte array of bytes32 value.
/// @return result bytes32 value from byte array.
function readBytes32(
bytes memory b,
uint256 index
)
internal
pure
returns (bytes32 result)
{
function readBytes32(bytes memory b, uint256 index) internal pure returns (bytes32 result) {
if (b.length < index + 32) {
LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
b.length,
index + 32
));
LibRichErrorsV06.rrevert(
LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
b.length,
index + 32
)
);
}
// Arrays are prefixed by a 256 bit length parameter
@ -413,16 +384,15 @@ library LibBytesV06 {
bytes memory b,
uint256 index,
bytes32 input
)
internal
pure
{
) internal pure {
if (b.length < index + 32) {
LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
b.length,
index + 32
));
LibRichErrorsV06.rrevert(
LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
b.length,
index + 32
)
);
}
// Arrays are prefixed by a 256 bit length parameter
@ -438,14 +408,7 @@ library LibBytesV06 {
/// @param b Byte array containing a uint256 value.
/// @param index Index in byte array of uint256 value.
/// @return result uint256 value from byte array.
function readUint256(
bytes memory b,
uint256 index
)
internal
pure
returns (uint256 result)
{
function readUint256(bytes memory b, uint256 index) internal pure returns (uint256 result) {
result = uint256(readBytes32(b, index));
return result;
}
@ -458,10 +421,7 @@ library LibBytesV06 {
bytes memory b,
uint256 index,
uint256 input
)
internal
pure
{
) internal pure {
writeBytes32(b, index, bytes32(input));
}
@ -469,20 +429,15 @@ library LibBytesV06 {
/// @param b Byte array containing a bytes4 value.
/// @param index Index in byte array of bytes4 value.
/// @return result bytes4 value from byte array.
function readBytes4(
bytes memory b,
uint256 index
)
internal
pure
returns (bytes4 result)
{
function readBytes4(bytes memory b, uint256 index) internal pure returns (bytes4 result) {
if (b.length < index + 4) {
LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsFourRequired,
b.length,
index + 4
));
LibRichErrorsV06.rrevert(
LibBytesRichErrorsV06.InvalidByteOperationError(
LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsFourRequired,
b.length,
index + 4
)
);
}
// Arrays are prefixed by a 32 byte length field
@ -503,10 +458,7 @@ library LibBytesV06 {
/// Increasing length may lead to appending adjacent in-memory bytes to the end of the byte array.
/// @param b Bytes array to write new length to.
/// @param length New length of byte array.
function writeLength(bytes memory b, uint256 length)
internal
pure
{
function writeLength(bytes memory b, uint256 length) internal pure {
assembly {
mstore(b, length)
}

82
contracts/utils/contracts/src/v06/LibMathV06.sol
View File

@ -23,9 +23,7 @@ import "./LibSafeMathV06.sol";
import "./errors/LibRichErrorsV06.sol";
import "./errors/LibMathRichErrorsV06.sol";
library LibMathV06 {
using LibSafeMathV06 for uint256;
/// @dev Calculates partial value given a numerator and denominator rounded down.
@ -38,21 +36,9 @@ library LibMathV06 {
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256 partialAmount)
{
if (isRoundingErrorFloor(
numerator,
denominator,
target
)) {
LibRichErrorsV06.rrevert(LibMathRichErrorsV06.RoundingError(
numerator,
denominator,
target
));
) internal pure returns (uint256 partialAmount) {
if (isRoundingErrorFloor(numerator, denominator, target)) {
LibRichErrorsV06.rrevert(LibMathRichErrorsV06.RoundingError(numerator, denominator, target));
}
partialAmount = numerator.safeMul(target).safeDiv(denominator);
@ -69,29 +55,15 @@ library LibMathV06 {
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256 partialAmount)
{
if (isRoundingErrorCeil(
numerator,
denominator,
target
)) {
LibRichErrorsV06.rrevert(LibMathRichErrorsV06.RoundingError(
numerator,
denominator,
target
));
) internal pure returns (uint256 partialAmount) {
if (isRoundingErrorCeil(numerator, denominator, target)) {
LibRichErrorsV06.rrevert(LibMathRichErrorsV06.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);
partialAmount = numerator.safeMul(target).safeAdd(denominator.safeSub(1)).safeDiv(denominator);
return partialAmount;
}
@ -105,11 +77,7 @@ library LibMathV06 {
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256 partialAmount)
{
) internal pure returns (uint256 partialAmount) {
partialAmount = numerator.safeMul(target).safeDiv(denominator);
return partialAmount;
}
@ -123,17 +91,11 @@ library LibMathV06 {
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256 partialAmount)
{
) 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);
partialAmount = numerator.safeMul(target).safeAdd(denominator.safeSub(1)).safeDiv(denominator);
return partialAmount;
}
@ -147,11 +109,7 @@ library LibMathV06 {
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (bool isError)
{
) internal pure returns (bool isError) {
if (denominator == 0) {
LibRichErrorsV06.rrevert(LibMathRichErrorsV06.DivisionByZeroError());
}
@ -182,11 +140,7 @@ library LibMathV06 {
// 1000 * remainder < numerator * target
// so we have a rounding error iff:
// 1000 * remainder >= numerator * target
uint256 remainder = mulmod(
target,
numerator,
denominator
);
uint256 remainder = mulmod(target, numerator, denominator);
isError = remainder.safeMul(1000) >= numerator.safeMul(target);
return isError;
}
@ -200,11 +154,7 @@ library LibMathV06 {
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (bool isError)
{
) internal pure returns (bool isError) {
if (denominator == 0) {
LibRichErrorsV06.rrevert(LibMathRichErrorsV06.DivisionByZeroError());
}
@ -217,11 +167,7 @@ library LibMathV06 {
return false;
}
// Compute remainder as before
uint256 remainder = mulmod(
target,
numerator,
denominator
);
uint256 remainder = mulmod(target, numerator, denominator);
remainder = denominator.safeSub(remainder) % denominator;
isError = remainder.safeMul(1000) >= numerator.safeMul(target);
return isError;

186
contracts/utils/contracts/src/v06/LibSafeMathV06.sol
View File

@ -22,183 +22,147 @@ pragma solidity ^0.6.5;
import "./errors/LibRichErrorsV06.sol";
import "./errors/LibSafeMathRichErrorsV06.sol";
library LibSafeMathV06 {
function safeMul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
if (c / a != b) {
LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.MULTIPLICATION_OVERFLOW,
a,
b
));
LibRichErrorsV06.rrevert(
LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.MULTIPLICATION_OVERFLOW,
a,
b
)
);
}
return c;
}
function safeDiv(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.DIVISION_BY_ZERO,
a,
b
));
LibRichErrorsV06.rrevert(
LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.DIVISION_BY_ZERO,
a,
b
)
);
}
uint256 c = a / b;
return c;
}
function safeSub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
if (b > a) {
LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.SUBTRACTION_UNDERFLOW,
a,
b
));
LibRichErrorsV06.rrevert(
LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.SUBTRACTION_UNDERFLOW,
a,
b
)
);
}
return a - b;
}
function safeAdd(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
if (c < a) {
LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.ADDITION_OVERFLOW,
a,
b
));
LibRichErrorsV06.rrevert(
LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.ADDITION_OVERFLOW,
a,
b
)
);
}
return c;
}
function max256(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function safeMul128(uint128 a, uint128 b)
internal
pure
returns (uint128)
{
function safeMul128(uint128 a, uint128 b) internal pure returns (uint128) {
if (a == 0) {
return 0;
}
uint128 c = a * b;
if (c / a != b) {
LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.MULTIPLICATION_OVERFLOW,
a,
b
));
LibRichErrorsV06.rrevert(
LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.MULTIPLICATION_OVERFLOW,
a,
b
)
);
}
return c;
}
function safeDiv128(uint128 a, uint128 b)
internal
pure
returns (uint128)
{
function safeDiv128(uint128 a, uint128 b) internal pure returns (uint128) {
if (b == 0) {
LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.DIVISION_BY_ZERO,
a,
b
));
LibRichErrorsV06.rrevert(
LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.DIVISION_BY_ZERO,
a,
b
)
);
}
uint128 c = a / b;
return c;
}
function safeSub128(uint128 a, uint128 b)
internal
pure
returns (uint128)
{
function safeSub128(uint128 a, uint128 b) internal pure returns (uint128) {
if (b > a) {
LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.SUBTRACTION_UNDERFLOW,
a,
b
));
LibRichErrorsV06.rrevert(
LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.SUBTRACTION_UNDERFLOW,
a,
b
)
);
}
return a - b;
}
function safeAdd128(uint128 a, uint128 b)
internal
pure
returns (uint128)
{
function safeAdd128(uint128 a, uint128 b) internal pure returns (uint128) {
uint128 c = a + b;
if (c < a) {
LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.ADDITION_OVERFLOW,
a,
b
));
LibRichErrorsV06.rrevert(
LibSafeMathRichErrorsV06.Uint256BinOpError(
LibSafeMathRichErrorsV06.BinOpErrorCodes.ADDITION_OVERFLOW,
a,
b
)
);
}
return c;
}
function max128(uint128 a, uint128 b)
internal
pure
returns (uint128)
{
function max128(uint128 a, uint128 b) internal pure returns (uint128) {
return a >= b ? a : b;
}
function min128(uint128 a, uint128 b)
internal
pure
returns (uint128)
{
function min128(uint128 a, uint128 b) internal pure returns (uint128) {
return a < b ? a : b;
}
function safeDowncastToUint128(uint256 a)
internal
pure
returns (uint128)
{
function safeDowncastToUint128(uint256 a) internal pure returns (uint128) {
if (a > type(uint128).max) {
LibRichErrorsV06.rrevert(LibSafeMathRichErrorsV06.Uint256DowncastError(
LibSafeMathRichErrorsV06.DowncastErrorCodes.VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT128,
a
));
LibRichErrorsV06.rrevert(
LibSafeMathRichErrorsV06.Uint256DowncastError(
LibSafeMathRichErrorsV06.DowncastErrorCodes.VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT128,
a
)
);
}
return uint128(a);
}

21
contracts/utils/contracts/src/v06/OwnableV06.sol
View File

@ -23,10 +23,7 @@ import "./interfaces/IOwnableV06.sol";
import "./errors/LibRichErrorsV06.sol";
import "./errors/LibOwnableRichErrorsV06.sol";
contract OwnableV06 is
IOwnableV06
{
contract OwnableV06 is IOwnableV06 {
/// @dev The owner of this contract.
/// @return 0 The owner address.
address public override owner;
@ -42,11 +39,7 @@ contract OwnableV06 is
/// @dev Change the owner of this contract.
/// @param newOwner New owner address.
function transferOwnership(address newOwner)
public
override
onlyOwner
{
function transferOwnership(address newOwner) public override onlyOwner {
if (newOwner == address(0)) {
LibRichErrorsV06.rrevert(LibOwnableRichErrorsV06.TransferOwnerToZeroError());
} else {
@ -55,15 +48,9 @@ contract OwnableV06 is
}
}
function _assertSenderIsOwner()
internal
view
{
function _assertSenderIsOwner() internal view {
if (msg.sender != owner) {
LibRichErrorsV06.rrevert(LibOwnableRichErrorsV06.OnlyOwnerError(
msg.sender,
owner
));
LibRichErrorsV06.rrevert(LibOwnableRichErrorsV06.OnlyOwnerError(msg.sender, owner));
}
}
}

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

@ -22,9 +22,7 @@ pragma solidity ^0.6.5;
import "./errors/LibReentrancyGuardRichErrorsV06.sol";
import "./errors/LibRichErrorsV06.sol";
contract ReentrancyGuardV06 {
// Locked state of mutex.
bool private _locked = false;
@ -36,22 +34,16 @@ contract ReentrancyGuardV06 {
_unlockMutex();
}
function _lockMutexOrThrowIfAlreadyLocked()
internal
{
function _lockMutexOrThrowIfAlreadyLocked() internal {
// Ensure mutex is unlocked.
if (_locked) {
LibRichErrorsV06.rrevert(
LibReentrancyGuardRichErrorsV06.IllegalReentrancyError()
);
LibRichErrorsV06.rrevert(LibReentrancyGuardRichErrorsV06.IllegalReentrancyError());
}
// Lock mutex.
_locked = true;
}
function _unlockMutex()
internal
{
function _unlockMutex() internal {
// Unlock mutex.
_locked = false;
}

89
contracts/utils/contracts/src/v06/errors/LibAuthorizableRichErrorsV06.sol
View File

@ -19,102 +19,47 @@
pragma solidity ^0.6.5;
library LibAuthorizableRichErrorsV06 {
// bytes4(keccak256("AuthorizedAddressMismatchError(address,address)"))
bytes4 internal constant AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR =
0x140a84db;
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 internal constant INDEX_OUT_OF_BOUNDS_ERROR_SELECTOR = 0xe9f83771;
// bytes4(keccak256("SenderNotAuthorizedError(address)"))
bytes4 internal constant SENDER_NOT_AUTHORIZED_ERROR_SELECTOR =
0xb65a25b9;
bytes4 internal constant SENDER_NOT_AUTHORIZED_ERROR_SELECTOR = 0xb65a25b9;
// bytes4(keccak256("TargetAlreadyAuthorizedError(address)"))
bytes4 internal constant TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR =
0xde16f1a0;
bytes4 internal constant TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR = 0xde16f1a0;
// bytes4(keccak256("TargetNotAuthorizedError(address)"))
bytes4 internal constant TARGET_NOT_AUTHORIZED_ERROR_SELECTOR =
0xeb5108a2;
bytes4 internal constant TARGET_NOT_AUTHORIZED_ERROR_SELECTOR = 0xeb5108a2;
// bytes4(keccak256("ZeroCantBeAuthorizedError()"))
bytes internal constant ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES =
hex"57654fe4";
bytes internal constant ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES = hex"57654fe4";
// solhint-disable func-name-mixedcase
function AuthorizedAddressMismatchError(
address authorized,
address target
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR,
authorized,
target
);
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 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 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 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 TargetNotAuthorizedError(address target) internal pure returns (bytes memory) {
return abi.encodeWithSelector(TARGET_NOT_AUTHORIZED_ERROR_SELECTOR, target);
}
function ZeroCantBeAuthorizedError()
internal
pure
returns (bytes memory)
{
function ZeroCantBeAuthorizedError() internal pure returns (bytes memory) {
return ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES;
}
}

18
contracts/utils/contracts/src/v06/errors/LibBytesRichErrorsV06.sol
View File

@ -19,9 +19,7 @@
pragma solidity ^0.6.5;
library LibBytesRichErrorsV06 {
enum InvalidByteOperationErrorCodes {
FromLessThanOrEqualsToRequired,
ToLessThanOrEqualsLengthRequired,
@ -34,24 +32,14 @@ library LibBytesRichErrorsV06 {
}
// bytes4(keccak256("InvalidByteOperationError(uint8,uint256,uint256)"))
bytes4 internal constant INVALID_BYTE_OPERATION_ERROR_SELECTOR =
0x28006595;
bytes4 internal constant INVALID_BYTE_OPERATION_ERROR_SELECTOR = 0x28006595;
// solhint-disable func-name-mixedcase
function InvalidByteOperationError(
InvalidByteOperationErrorCodes errorCode,
uint256 offset,
uint256 required
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
INVALID_BYTE_OPERATION_ERROR_SELECTOR,
errorCode,
offset,
required
);
) internal pure returns (bytes memory) {
return abi.encodeWithSelector(INVALID_BYTE_OPERATION_ERROR_SELECTOR, errorCode, offset, required);
}
}

27
contracts/utils/contracts/src/v06/errors/LibMathRichErrorsV06.sol
View File

@ -19,23 +19,15 @@
pragma solidity ^0.6.5;
library LibMathRichErrorsV06 {
// bytes4(keccak256("DivisionByZeroError()"))
bytes internal constant DIVISION_BY_ZERO_ERROR =
hex"a791837c";
bytes internal constant DIVISION_BY_ZERO_ERROR = hex"a791837c";
// bytes4(keccak256("RoundingError(uint256,uint256,uint256)"))
bytes4 internal constant ROUNDING_ERROR_SELECTOR =
0x339f3de2;
bytes4 internal constant ROUNDING_ERROR_SELECTOR = 0x339f3de2;
// solhint-disable func-name-mixedcase
function DivisionByZeroError()
internal
pure
returns (bytes memory)
{
function DivisionByZeroError() internal pure returns (bytes memory) {
return DIVISION_BY_ZERO_ERROR;
}
@ -43,16 +35,7 @@ library LibMathRichErrorsV06 {
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
ROUNDING_ERROR_SELECTOR,
numerator,
denominator,
target
);
) internal pure returns (bytes memory) {
return abi.encodeWithSelector(ROUNDING_ERROR_SELECTOR, numerator, denominator, target);
}
}

29
contracts/utils/contracts/src/v06/errors/LibOwnableRichErrorsV06.sol
View File

@ -18,38 +18,19 @@
*/
pragma solidity ^0.6.5;
library LibOwnableRichErrorsV06 {
// bytes4(keccak256("OnlyOwnerError(address,address)"))
bytes4 internal constant ONLY_OWNER_ERROR_SELECTOR =
0x1de45ad1;
bytes4 internal constant ONLY_OWNER_ERROR_SELECTOR = 0x1de45ad1;
// bytes4(keccak256("TransferOwnerToZeroError()"))
bytes internal constant TRANSFER_OWNER_TO_ZERO_ERROR_BYTES =
hex"e69edc3e";
bytes internal constant TRANSFER_OWNER_TO_ZERO_ERROR_BYTES = hex"e69edc3e";
// solhint-disable func-name-mixedcase
function OnlyOwnerError(
address sender,
address owner
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
ONLY_OWNER_ERROR_SELECTOR,
sender,
owner
);
function OnlyOwnerError(address sender, address owner) internal pure returns (bytes memory) {
return abi.encodeWithSelector(ONLY_OWNER_ERROR_SELECTOR, sender, owner);
}
function TransferOwnerToZeroError()
internal
pure
returns (bytes memory)
{
function TransferOwnerToZeroError() internal pure returns (bytes memory) {
return TRANSFER_OWNER_TO_ZERO_ERROR_BYTES;
}
}

11
contracts/utils/contracts/src/v06/errors/LibReentrancyGuardRichErrorsV06.sol
View File

@ -19,19 +19,12 @@
pragma solidity ^0.6.5;
library LibReentrancyGuardRichErrorsV06 {
// bytes4(keccak256("IllegalReentrancyError()"))
bytes internal constant ILLEGAL_REENTRANCY_ERROR_SELECTOR_BYTES =
hex"0c3b823f";
bytes internal constant ILLEGAL_REENTRANCY_ERROR_SELECTOR_BYTES = hex"0c3b823f";
// solhint-disable func-name-mixedcase
function IllegalReentrancyError()
internal
pure
returns (bytes memory)
{
function IllegalReentrancyError() internal pure returns (bytes memory) {
return ILLEGAL_REENTRANCY_ERROR_SELECTOR_BYTES;
}
}

19
contracts/utils/contracts/src/v06/errors/LibRichErrorsV06.sol
View File

@ -19,9 +19,7 @@
pragma solidity ^0.6.5;
library LibRichErrorsV06 {
// bytes4(keccak256("Error(string)"))
bytes4 internal constant STANDARD_ERROR_SELECTOR = 0x08c379a0;
@ -31,24 +29,15 @@ library LibRichErrorsV06 {
/// solidity statement. It has the function signature `Error(string)`.
/// @param message The error string.
/// @return The ABI encoded error.
function StandardError(string memory message)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
STANDARD_ERROR_SELECTOR,
bytes(message)
);
function StandardError(string memory message) internal pure returns (bytes memory) {
return abi.encodeWithSelector(STANDARD_ERROR_SELECTOR, bytes(message));
}
// solhint-enable func-name-mixedcase
/// @dev Reverts an encoded rich revert reason `errorData`.
/// @param errorData ABI encoded error data.
function rrevert(bytes memory errorData)
internal
pure
{
function rrevert(bytes memory errorData) internal pure {
assembly {
revert(add(errorData, 0x20), mload(errorData))
}

36
contracts/utils/contracts/src/v06/errors/LibSafeMathRichErrorsV06.sol
View File

@ -19,16 +19,12 @@
pragma solidity ^0.6.5;
library LibSafeMathRichErrorsV06 {
// bytes4(keccak256("Uint256BinOpError(uint8,uint256,uint256)"))
bytes4 internal constant UINT256_BINOP_ERROR_SELECTOR =
0xe946c1bb;
bytes4 internal constant UINT256_BINOP_ERROR_SELECTOR = 0xe946c1bb;
// bytes4(keccak256("Uint256DowncastError(uint8,uint256)"))
bytes4 internal constant UINT256_DOWNCAST_ERROR_SELECTOR =
0xc996af7b;
bytes4 internal constant UINT256_DOWNCAST_ERROR_SELECTOR = 0xc996af7b;
enum BinOpErrorCodes {
ADDITION_OVERFLOW,
@ -49,31 +45,11 @@ library LibSafeMathRichErrorsV06 {
BinOpErrorCodes errorCode,
uint256 a,
uint256 b
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
UINT256_BINOP_ERROR_SELECTOR,
errorCode,
a,
b
);
) internal pure returns (bytes memory) {
return abi.encodeWithSelector(UINT256_BINOP_ERROR_SELECTOR, errorCode, a, b);
}
function Uint256DowncastError(
DowncastErrorCodes errorCode,
uint256 a
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
UINT256_DOWNCAST_ERROR_SELECTOR,
errorCode,
a
);
function Uint256DowncastError(DowncastErrorCodes errorCode, uint256 a) internal pure returns (bytes memory) {
return abi.encodeWithSelector(UINT256_DOWNCAST_ERROR_SELECTOR, errorCode, a);
}
}

33
contracts/utils/contracts/src/v06/interfaces/IAuthorizableV06.sol
View File

@ -21,47 +21,29 @@ pragma solidity ^0.6.5;
import "./IOwnableV06.sol";
interface IAuthorizableV06 is
IOwnableV06
{
interface IAuthorizableV06 is IOwnableV06 {
// Event logged when a new address is authorized.
event AuthorizedAddressAdded(
address indexed target,
address indexed caller
);
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
);
event AuthorizedAddressRemoved(address indexed target, address indexed caller);
/// @dev Authorizes an address.
/// @param target Address to authorize.
function addAuthorizedAddress(address target)
external;
function addAuthorizedAddress(address target) external;
/// @dev Removes authorizion of an address.
/// @param target Address to remove authorization from.
function removeAuthorizedAddress(address target)
external;
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;
function removeAuthorizedAddressAtIndex(address target, uint256 index) external;
/// @dev Gets all authorized addresses.
/// @return authorizedAddresses Array of authorized addresses.
function getAuthorizedAddresses()
external
view
returns (address[] memory authorizedAddresses);
function getAuthorizedAddresses() external view returns (address[] memory authorizedAddresses);
/// @dev Whether an adderss is authorized to call privileged functions.
/// @param addr Address to query.
@ -72,5 +54,4 @@ interface IAuthorizableV06 is
/// @param idx Index of authorized address.
/// @return addr Authorized address.
function authorities(uint256 idx) external view returns (address addr);
}

2
contracts/utils/contracts/src/v06/interfaces/IOwnableV06.sol
View File

@ -19,9 +19,7 @@
pragma solidity ^0.6.5;
interface IOwnableV06 {
/// @dev Emitted by Ownable when ownership is transferred.
/// @param previousOwner The previous owner of the contract.
/// @param newOwner The new owner of the contract.

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

@ -20,14 +20,7 @@ pragma solidity ^0.5.9;
import "../src/Authorizable.sol";
// solhint-disable no-empty-blocks
contract TestAuthorizable is
Authorizable
{
function onlyAuthorizedFn()
external
view
onlyAuthorized
{}
contract TestAuthorizable is Authorizable {
function onlyAuthorizedFn() external view onlyAuthorized {}
}

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

@ -20,16 +20,10 @@ pragma solidity ^0.5.9;
import "../src/LibAddress.sol";
contract TestLibAddress {
using LibAddress for address;
function externalIsContract(address account)
external
view
returns (bool)
{
function externalIsContract(address account) external view returns (bool) {
return account.isContract();
}
}

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

@ -20,9 +20,7 @@ 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.
@ -83,11 +81,7 @@ contract TestLibAddressArray {
/// @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)
{
function publicContains(address[] memory addressArray, address target) public pure returns (bool success) {
return addressArray.contains(target);
}
@ -102,5 +96,4 @@ contract TestLibAddressArray {
{
(success, index) = addressArray.indexOf(target);
}
}

108
contracts/utils/contracts/test/TestLibBytes.sol
View File

@ -20,19 +20,13 @@ pragma solidity ^0.5.9;
import "../src/LibBytes.sol";
contract TestLibBytes {
using LibBytes for bytes;
/// @dev Pops the last byte off of a byte array by modifying its length.
/// @param b Byte array that will be modified.
/// @return The byte that was popped off.
function publicPopLastByte(bytes memory b)
public
pure
returns (bytes memory, bytes1 result)
{
function publicPopLastByte(bytes memory b) public pure returns (bytes memory, bytes1 result) {
result = b.popLastByte();
return (b, result);
}
@ -41,20 +35,12 @@ contract TestLibBytes {
/// @param lhs First byte array to compare.
/// @param rhs Second byte array to compare.
/// @return True if arrays are the same. False otherwise.
function publicEquals(bytes memory lhs, bytes memory rhs)
public
pure
returns (bool equal)
{
function publicEquals(bytes memory lhs, bytes memory rhs) public pure returns (bool equal) {
equal = lhs.equals(rhs);
return equal;
}
function publicEqualsPop1(bytes memory lhs, bytes memory rhs)
public
pure
returns (bool equal)
{
function publicEqualsPop1(bytes memory lhs, bytes memory rhs) public pure returns (bool equal) {
lhs.popLastByte();
rhs.popLastByte();
equal = lhs.equals(rhs);
@ -65,14 +51,7 @@ contract TestLibBytes {
/// @param b Byte array containing an address.
/// @param index Index in byte array of address.
/// @return address from byte array.
function publicReadAddress(
bytes memory b,
uint256 index
)
public
pure
returns (address result)
{
function publicReadAddress(bytes memory b, uint256 index) public pure returns (address result) {
result = b.readAddress(index);
return result;
}
@ -85,11 +64,7 @@ contract TestLibBytes {
bytes memory b,
uint256 index,
address input
)
public
pure
returns (bytes memory)
{
) public pure returns (bytes memory) {
b.writeAddress(index, input);
return b;
}
@ -98,14 +73,7 @@ contract TestLibBytes {
/// @param b Byte array containing a bytes32 value.
/// @param index Index in byte array of bytes32 value.
/// @return bytes32 value from byte array.
function publicReadBytes32(
bytes memory b,
uint256 index
)
public
pure
returns (bytes32 result)
{
function publicReadBytes32(bytes memory b, uint256 index) public pure returns (bytes32 result) {
result = b.readBytes32(index);
return result;
}
@ -118,11 +86,7 @@ contract TestLibBytes {
bytes memory b,
uint256 index,
bytes32 input
)
public
pure
returns (bytes memory)
{
) public pure returns (bytes memory) {
b.writeBytes32(index, input);
return b;
}
@ -131,14 +95,7 @@ contract TestLibBytes {
/// @param b Byte array containing a uint256 value.
/// @param index Index in byte array of uint256 value.
/// @return uint256 value from byte array.
function publicReadUint256(
bytes memory b,
uint256 index
)
public
pure
returns (uint256 result)
{
function publicReadUint256(bytes memory b, uint256 index) public pure returns (uint256 result) {
result = b.readUint256(index);
return result;
}
@ -151,11 +108,7 @@ contract TestLibBytes {
bytes memory b,
uint256 index,
uint256 input
)
public
pure
returns (bytes memory)
{
) public pure returns (bytes memory) {
b.writeUint256(index, input);
return b;
}
@ -164,14 +117,7 @@ contract TestLibBytes {
/// @param b Byte array containing a bytes4 value.
/// @param index Index in byte array of bytes4 value.
/// @return bytes4 value from byte array.
function publicReadBytes4(
bytes memory b,
uint256 index
)
public
pure
returns (bytes4 result)
{
function publicReadBytes4(bytes memory b, uint256 index) public pure returns (bytes4 result) {
result = b.readBytes4(index);
return result;
}
@ -186,12 +132,8 @@ contract TestLibBytes {
bytes memory mem,
uint256 dest,
uint256 source,
uint256 length
)
public // not external, we need input in memory
pure
returns (bytes memory)
{
uint256 length // not external, we need input in memory
) public pure returns (bytes memory) {
// Sanity check. Overflows are not checked.
require(source + length <= mem.length);
require(dest + length <= mem.length);
@ -215,11 +157,7 @@ contract TestLibBytes {
bytes memory b,
uint256 from,
uint256 to
)
public
pure
returns (bytes memory result, bytes memory original)
{
) public pure returns (bytes memory result, bytes memory original) {
result = LibBytes.slice(b, from, to);
return (result, b);
}
@ -234,11 +172,7 @@ contract TestLibBytes {
bytes memory b,
uint256 from,
uint256 to
)
public
pure
returns (bytes memory result, bytes memory original)
{
) public pure returns (bytes memory result, bytes memory original) {
result = LibBytes.sliceDestructive(b, from, to);
return (result, b);
}
@ -254,24 +188,14 @@ contract TestLibBytes {
bytes memory b,
uint256 length,
bytes memory extraBytes
)
public
pure
returns (bytes memory)
{
) public pure returns (bytes memory) {
uint256 bEnd = b.contentAddress() + b.length;
LibBytes.memCopy(bEnd, extraBytes.contentAddress(), extraBytes.length);
b.writeLength(length);
return b;
}
function assertBytesUnchangedAfterLengthReset(
bytes memory b,
uint256 tempLength
)
public
pure
{
function assertBytesUnchangedAfterLengthReset(bytes memory b, uint256 tempLength) public pure {
uint256 length = b.length;
bytes memory bCopy = b.slice(0, length);
b.writeLength(tempLength);

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

@ -20,32 +20,17 @@ 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
);
) external pure returns (bytes32) {
return LibEIP712.hashEIP712Domain(name, version, chainid, verifyingcontractaddress);
}
function externalHashEIP712Message(bytes32 eip712DomainHash, bytes32 hashStruct)
external
pure
returns (bytes32)
{
function externalHashEIP712Message(bytes32 eip712DomainHash, bytes32 hashStruct) external pure returns (bytes32) {
return LibEIP712.hashEIP712Message(eip712DomainHash, hashStruct);
}
}

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

@ -21,9 +21,7 @@ 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.
@ -34,11 +32,7 @@ contract TestLibMath {
uint256 numerator,
uint256 denominator,
uint256 target
)
public
pure
returns (uint256 partialAmount)
{
) public pure returns (uint256 partialAmount) {
return LibMath.safeGetPartialAmountFloor(numerator, denominator, target);
}
@ -52,11 +46,7 @@ contract TestLibMath {
uint256 numerator,
uint256 denominator,
uint256 target
)
public
pure
returns (uint256 partialAmount)
{
) public pure returns (uint256 partialAmount) {
return LibMath.safeGetPartialAmountCeil(numerator, denominator, target);
}
@ -69,11 +59,7 @@ contract TestLibMath {
uint256 numerator,
uint256 denominator,
uint256 target
)
public
pure
returns (uint256 partialAmount)
{
) public pure returns (uint256 partialAmount) {
return LibMath.getPartialAmountFloor(numerator, denominator, target);
}
@ -86,11 +72,7 @@ contract TestLibMath {
uint256 numerator,
uint256 denominator,
uint256 target
)
public
pure
returns (uint256 partialAmount)
{
) public pure returns (uint256 partialAmount) {
return LibMath.getPartialAmountCeil(numerator, denominator, target);
}
@ -103,11 +85,7 @@ contract TestLibMath {
uint256 numerator,
uint256 denominator,
uint256 target
)
public
pure
returns (bool isError)
{
) public pure returns (bool isError) {
return LibMath.isRoundingErrorFloor(numerator, denominator, target);
}
@ -120,11 +98,7 @@ contract TestLibMath {
uint256 numerator,
uint256 denominator,
uint256 target
)
public
pure
returns (bool isError)
{
) public pure returns (bool isError) {
return LibMath.isRoundingErrorCeil(numerator, denominator, target);
}
}

7
contracts/utils/contracts/test/TestLibRichErrors.sol
View File

@ -20,13 +20,8 @@ pragma solidity ^0.5.9;
import "../src/LibRichErrors.sol";
contract TestLibRichErrors {
function externalRRevert(bytes calldata errorData)
external
pure
{
function externalRRevert(bytes calldata errorData) external pure {
LibRichErrors.rrevert(errorData);
}
}

38
contracts/utils/contracts/test/TestLibSafeMath.sol
View File

@ -20,56 +20,30 @@ pragma solidity ^0.5.9;
import "../src/LibSafeMath.sol";
contract TestLibSafeMath {
using LibSafeMath for uint256;
function externalSafeMul(uint256 a, uint256 b)
external
pure
returns (uint256)
{
function externalSafeMul(uint256 a, uint256 b) external pure returns (uint256) {
return a.safeMul(b);
}
function externalSafeDiv(uint256 a, uint256 b)
external
pure
returns (uint256)
{
function externalSafeDiv(uint256 a, uint256 b) external pure returns (uint256) {
return a.safeDiv(b);
}
function externalSafeSub(uint256 a, uint256 b)
external
pure
returns (uint256)
{
function externalSafeSub(uint256 a, uint256 b) external pure returns (uint256) {
return a.safeSub(b);
}
function externalSafeAdd(uint256 a, uint256 b)
external
pure
returns (uint256)
{
function externalSafeAdd(uint256 a, uint256 b) external pure returns (uint256) {
return a.safeAdd(b);
}
function externalMaxUint256(uint256 a, uint256 b)
external
pure
returns (uint256)
{
function externalMaxUint256(uint256 a, uint256 b) external pure returns (uint256) {
return a.max256(b);
}
function externalMinUint256(uint256 a, uint256 b)
external
pure
returns (uint256)
{
function externalMinUint256(uint256 a, uint256 b) external pure returns (uint256) {
return a.min256(b);
}
}

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

@ -20,36 +20,24 @@ 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
);
event TestEvent(uint256 foo, bytes bar, string car);
/// @dev Emits a local event
function emitEvent()
public
{
emit TestEvent(256, hex'1234', "4321");
function emitEvent() public {
emit TestEvent(256, hex"1234", "4321");
}
/// @dev Emits an event in a downstream contract
function emitEventDownstream()
public
{
function emitEventDownstream() public {
TestLogDecodingDownstream testLogDecodingDownstream = new TestLogDecodingDownstream();
ITestLogDecodingDownstream(testLogDecodingDownstream).emitEvent();
}
/// @dev Emits a local event and a downstream event
function emitEventsLocalAndDownstream()
public
{
function emitEventsLocalAndDownstream() public {
emitEvent();
emitEventDownstream();
}
}
}

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

@ -18,31 +18,20 @@
pragma solidity ^0.5.5;
contract ITestLogDecodingDownstream {
/// @dev Emits a local event
function emitEvent() external;
}
contract TestLogDecodingDownstream is
ITestLogDecodingDownstream
{
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
);
event TestEvent2(uint256 lorem, string ipsum);
/// @dev Emits a local event
function emitEvent()
external
{
function emitEvent() external {
emit TestEvent2(256, "4321");
}
}
}

12
contracts/utils/contracts/test/TestOwnable.sol
View File

@ -2,16 +2,8 @@ pragma solidity ^0.5.9;
import "../src/Ownable.sol";
contract TestOwnable is
Ownable
{
function externalOnlyOwner()
external
onlyOwner
view
returns (bool)
{
contract TestOwnable is Ownable {
function externalOnlyOwner() external view onlyOwner returns (bool) {
return true;
}
}

22
contracts/utils/contracts/test/TestReentrancyGuard.sol
View File

@ -20,18 +20,11 @@ pragma solidity ^0.5.9;
import "../src/ReentrancyGuard.sol";
contract TestReentrancyGuard is
ReentrancyGuard
{
contract TestReentrancyGuard is ReentrancyGuard {
/// @dev Exposes the nonReentrant modifier publicly.
/// @param shouldBeAttacked True if the contract should be attacked.
/// @return True if successful.
function guarded(bool shouldBeAttacked)
external
nonReentrant
returns (bool)
{
function guarded(bool shouldBeAttacked) external nonReentrant returns (bool) {
if (shouldBeAttacked) {
return this.exploitive();
} else {
@ -41,20 +34,13 @@ contract TestReentrancyGuard is
/// @dev This is a function that will reenter the current contract.
/// @return True if successful.
function exploitive()
external
returns (bool)
{
function exploitive() external returns (bool) {
return this.guarded(true);
}
/// @dev This is a function that will not reenter the current contract.
/// @return True if successful.
function nonExploitive()
external
pure
returns (bool)
{
function nonExploitive() external pure returns (bool) {
return true;
}
}

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

@ -20,59 +20,29 @@ pragma solidity ^0.5.9;
import "../src/Refundable.sol";
contract TestRefundable is
Refundable
{
function refundNonZeroBalanceExternal()
external
payable
{
contract TestRefundable is Refundable {
function refundNonZeroBalanceExternal() external payable {
_refundNonZeroBalance();
}
function setShouldNotRefund(bool shouldNotRefundNew)
external
{
function setShouldNotRefund(bool shouldNotRefundNew) external {
_shouldNotRefund = shouldNotRefundNew;
}
function getShouldNotRefund()
external
view
returns (bool)
{
function getShouldNotRefund() external view returns (bool) {
return _shouldNotRefund;
}
function refundFinalBalanceFunction()
public
payable
refundFinalBalance
{} // solhint-disable-line no-empty-blocks
function refundFinalBalanceFunction() public payable refundFinalBalance {} // solhint-disable-line no-empty-blocks
function disableRefundUntilEndFunction()
public
payable
disableRefundUntilEnd
{} // solhint-disable-line no-empty-blocks
function disableRefundUntilEndFunction() public payable disableRefundUntilEnd {} // solhint-disable-line no-empty-blocks
function nestedDisableRefundUntilEndFunction()
public
payable
disableRefundUntilEnd
returns (uint256)
{
function nestedDisableRefundUntilEndFunction() public payable disableRefundUntilEnd returns (uint256) {
disableRefundUntilEndFunction();
return address(this).balance;
}
function mixedRefundModifierFunction()
public
payable
disableRefundUntilEnd
returns (uint256)
{
function mixedRefundModifierFunction() public payable disableRefundUntilEnd returns (uint256) {
refundFinalBalanceFunction();
return address(this).balance;
}

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

@ -20,16 +20,11 @@ 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
{
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.");
}
@ -37,10 +32,7 @@ contract TestRefundableReceiver {
/// @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
{
function testRefundNonZeroBalance(TestRefundable testRefundable) external payable {
// Call `refundNonzeroBalance()` and forward all of the eth sent to the contract.
testRefundable.refundNonZeroBalanceExternal.value(msg.value)();
@ -58,13 +50,7 @@ contract TestRefundableReceiver {
/// 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
{
function testRefundFinalBalance(TestRefundable testRefundable, bool shouldNotRefund) external payable {
// Set `shouldNotRefund` to the specified bool.
testRefundable.setShouldNotRefund(shouldNotRefund);
@ -82,13 +68,7 @@ contract TestRefundableReceiver {
/// 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
{
function testDisableRefundUntilEnd(TestRefundable testRefundable, bool shouldNotRefund) external payable {
// Set `shouldNotRefund` to the specified bool.
testRefundable.setShouldNotRefund(shouldNotRefund);
@ -105,13 +85,7 @@ contract TestRefundableReceiver {
/// 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
{
function testNestedDisableRefundUntilEnd(TestRefundable testRefundable, bool shouldNotRefund) external payable {
// Set `shouldNotRefund` to the specified bool.
testRefundable.setShouldNotRefund(shouldNotRefund);
@ -132,13 +106,7 @@ contract TestRefundableReceiver {
/// 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
{
function testMixedRefunds(TestRefundable testRefundable, bool shouldNotRefund) external payable {
// Set `shouldNotRefund` to the specified bool.
testRefundable.setShouldNotRefund(shouldNotRefund);
@ -158,12 +126,7 @@ contract TestRefundableReceiver {
/// 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
{
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.

1
contracts/zero-ex/contracts/src/IZeroEx.sol
View File

@ -38,7 +38,6 @@ import "./features/interfaces/IERC721OrdersFeature.sol";
import "./features/interfaces/IERC1155OrdersFeature.sol";
import "./features/interfaces/IERC165Feature.sol";
/// @dev Interface for a fully featured Exchange Proxy.
interface IZeroEx is
IOwnableFeature,

18
contracts/zero-ex/contracts/src/ZeroEx.sol
View File

@ -26,7 +26,6 @@ import "./features/BootstrapFeature.sol";
import "./storage/LibProxyStorage.sol";
import "./errors/LibProxyRichErrors.sol";
/// @dev An extensible proxy contract that serves as a universal entry point for
/// interacting with the 0x protocol.
contract ZeroEx {
@ -41,8 +40,7 @@ contract ZeroEx {
// Temporarily create and register the bootstrap feature.
// It will deregister itself after `bootstrap()` has been called.
BootstrapFeature bootstrap = new BootstrapFeature(bootstrapper);
LibProxyStorage.getStorage().impls[bootstrap.bootstrap.selector] =
address(bootstrap);
LibProxyStorage.getStorage().impls[bootstrap.bootstrap.selector] = address(bootstrap);
}
// solhint-disable state-visibility
@ -70,23 +68,23 @@ contract ZeroEx {
/// @dev Get the implementation contract of a registered function.
/// @param selector The function selector.
/// @return impl The implementation contract address.
function getFunctionImplementation(bytes4 selector)
public
view
returns (address impl)
{
function getFunctionImplementation(bytes4 selector) public view returns (address impl) {
return LibProxyStorage.getStorage().impls[selector];
}
/// @dev Revert with arbitrary bytes.
/// @param data Revert data.
function _revertWithData(bytes memory data) private pure {
assembly { revert(add(data, 32), mload(data)) }
assembly {
revert(add(data, 32), mload(data))
}
}
/// @dev Return with arbitrary bytes.
/// @param data Return data.
function _returnWithData(bytes memory data) private pure {
assembly { return(add(data, 32), mload(data)) }
assembly {
return(add(data, 32), mload(data))
}
}
}

14
contracts/zero-ex/contracts/src/ZeroExOptimized.sol
View File

@ -34,18 +34,15 @@ contract ZeroExOptimized {
// Temporarily create and register the bootstrap feature.
// It will deregister itself after `bootstrap()` has been called.
BootstrapFeature bootstrap = new BootstrapFeature(bootstrapper);
LibProxyStorage.getStorage().impls[bootstrap.bootstrap.selector] =
address(bootstrap);
LibProxyStorage.getStorage().impls[bootstrap.bootstrap.selector] = address(bootstrap);
}
// solhint-disable state-visibility
/// @dev Forwards calls to the appropriate implementation contract.
fallback() external payable {
// This is used in assembly below as impls_slot.
mapping(bytes4 => address) storage impls =
LibProxyStorage.getStorage().impls;
mapping(bytes4 => address) storage impls = LibProxyStorage.getStorage().impls;
assembly {
let cdlen := calldatasize()
@ -75,12 +72,7 @@ contract ZeroExOptimized {
revert(0, 0x24)
}
let success := delegatecall(
gas(),
delegate,
0x40, cdlen,
0, 0
)
let success := delegatecall(gas(), delegate, 0x40, cdlen, 0, 0)
let rdlen := returndatasize()
returndatacopy(0, 0, rdlen)
if success {

30
contracts/zero-ex/contracts/src/errors/LibCommonRichErrors.sol
View File

@ -19,31 +19,19 @@
pragma solidity ^0.6.5;
library LibCommonRichErrors {
// solhint-disable func-name-mixedcase
function OnlyCallableBySelfError(address sender)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("OnlyCallableBySelfError(address)")),
sender
);
function OnlyCallableBySelfError(address sender) internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("OnlyCallableBySelfError(address)")), sender);
}
function IllegalReentrancyError(bytes4 selector, uint256 reentrancyFlags)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("IllegalReentrancyError(bytes4,uint256)")),
selector,
reentrancyFlags
);
function IllegalReentrancyError(bytes4 selector, uint256 reentrancyFlags) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("IllegalReentrancyError(bytes4,uint256)")),
selector,
reentrancyFlags
);
}
}

29
contracts/zero-ex/contracts/src/errors/LibLiquidityProviderRichErrors.sol
View File

@ -19,9 +19,7 @@
pragma solidity ^0.6.5;
library LibLiquidityProviderRichErrors {
// solhint-disable func-name-mixedcase
function LiquidityProviderIncompleteSellError(
@ -31,19 +29,18 @@ library LibLiquidityProviderRichErrors {
uint256 sellAmount,
uint256 boughtAmount,
uint256 minBuyAmount
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("LiquidityProviderIncompleteSellError(address,address,address,uint256,uint256,uint256)")),
providerAddress,
makerToken,
takerToken,
sellAmount,
boughtAmount,
minBuyAmount
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(
keccak256("LiquidityProviderIncompleteSellError(address,address,address,uint256,uint256,uint256)")
),
providerAddress,
makerToken,
takerToken,
sellAmount,
boughtAmount,
minBuyAmount
);
}
}

166
contracts/zero-ex/contracts/src/errors/LibMetaTransactionsRichErrors.sol
View File

@ -19,73 +19,61 @@
pragma solidity ^0.6.5;
library LibMetaTransactionsRichErrors {
// solhint-disable func-name-mixedcase
function InvalidMetaTransactionsArrayLengthsError(
uint256 mtxCount,
uint256 signatureCount
)
function InvalidMetaTransactionsArrayLengthsError(uint256 mtxCount, uint256 signatureCount)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("InvalidMetaTransactionsArrayLengthsError(uint256,uint256)")),
mtxCount,
signatureCount
);
return
abi.encodeWithSelector(
bytes4(keccak256("InvalidMetaTransactionsArrayLengthsError(uint256,uint256)")),
mtxCount,
signatureCount
);
}
function MetaTransactionUnsupportedFunctionError(
bytes32 mtxHash,
bytes4 selector
)
function MetaTransactionUnsupportedFunctionError(bytes32 mtxHash, bytes4 selector)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionUnsupportedFunctionError(bytes32,bytes4)")),
mtxHash,
selector
);
return
abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionUnsupportedFunctionError(bytes32,bytes4)")),
mtxHash,
selector
);
}
function MetaTransactionWrongSenderError(
bytes32 mtxHash,
address sender,
address expectedSender
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionWrongSenderError(bytes32,address,address)")),
mtxHash,
sender,
expectedSender
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionWrongSenderError(bytes32,address,address)")),
mtxHash,
sender,
expectedSender
);
}
function MetaTransactionExpiredError(
bytes32 mtxHash,
uint256 time,
uint256 expirationTime
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionExpiredError(bytes32,uint256,uint256)")),
mtxHash,
time,
expirationTime
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionExpiredError(bytes32,uint256,uint256)")),
mtxHash,
time,
expirationTime
);
}
function MetaTransactionGasPriceError(
@ -93,83 +81,69 @@ library LibMetaTransactionsRichErrors {
uint256 gasPrice,
uint256 minGasPrice,
uint256 maxGasPrice
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionGasPriceError(bytes32,uint256,uint256,uint256)")),
mtxHash,
gasPrice,
minGasPrice,
maxGasPrice
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionGasPriceError(bytes32,uint256,uint256,uint256)")),
mtxHash,
gasPrice,
minGasPrice,
maxGasPrice
);
}
function MetaTransactionInsufficientEthError(
bytes32 mtxHash,
uint256 ethBalance,
uint256 ethRequired
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionInsufficientEthError(bytes32,uint256,uint256)")),
mtxHash,
ethBalance,
ethRequired
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionInsufficientEthError(bytes32,uint256,uint256)")),
mtxHash,
ethBalance,
ethRequired
);
}
function MetaTransactionInvalidSignatureError(
bytes32 mtxHash,
bytes memory signature,
bytes memory errData
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionInvalidSignatureError(bytes32,bytes,bytes)")),
mtxHash,
signature,
errData
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionInvalidSignatureError(bytes32,bytes,bytes)")),
mtxHash,
signature,
errData
);
}
function MetaTransactionAlreadyExecutedError(
bytes32 mtxHash,
uint256 executedBlockNumber
)
function MetaTransactionAlreadyExecutedError(bytes32 mtxHash, uint256 executedBlockNumber)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionAlreadyExecutedError(bytes32,uint256)")),
mtxHash,
executedBlockNumber
);
return
abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionAlreadyExecutedError(bytes32,uint256)")),
mtxHash,
executedBlockNumber
);
}
function MetaTransactionCallFailedError(
bytes32 mtxHash,
bytes memory callData,
bytes memory returnData
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionCallFailedError(bytes32,bytes,bytes)")),
mtxHash,
callData,
returnData
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionCallFailedError(bytes32,bytes,bytes)")),
mtxHash,
callData,
returnData
);
}
}

222
contracts/zero-ex/contracts/src/errors/LibNFTOrdersRichErrors.sol
View File

@ -19,176 +19,81 @@
pragma solidity ^0.6.5;
library LibNFTOrdersRichErrors {
// solhint-disable func-name-mixedcase
function OverspentEthError(
uint256 ethSpent,
uint256 ethAvailable
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("OverspentEthError(uint256,uint256)")),
ethSpent,
ethAvailable
);
function OverspentEthError(uint256 ethSpent, uint256 ethAvailable) internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("OverspentEthError(uint256,uint256)")), ethSpent, ethAvailable);
}
function InsufficientEthError(
uint256 ethAvailable,
uint256 orderAmount
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("InsufficientEthError(uint256,uint256)")),
ethAvailable,
orderAmount
);
function InsufficientEthError(uint256 ethAvailable, uint256 orderAmount) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("InsufficientEthError(uint256,uint256)")),
ethAvailable,
orderAmount
);
}
function ERC721TokenMismatchError(
address token1,
address token2
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("ERC721TokenMismatchError(address,address)")),
token1,
token2
);
function ERC721TokenMismatchError(address token1, address token2) internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("ERC721TokenMismatchError(address,address)")), token1, token2);
}
function ERC1155TokenMismatchError(
address token1,
address token2
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("ERC1155TokenMismatchError(address,address)")),
token1,
token2
);
function ERC1155TokenMismatchError(address token1, address token2) internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("ERC1155TokenMismatchError(address,address)")), token1, token2);
}
function ERC20TokenMismatchError(
address token1,
address token2
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("ERC20TokenMismatchError(address,address)")),
token1,
token2
);
function ERC20TokenMismatchError(address token1, address token2) internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("ERC20TokenMismatchError(address,address)")), token1, token2);
}
function NegativeSpreadError(
uint256 sellOrderAmount,
uint256 buyOrderAmount
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("NegativeSpreadError(uint256,uint256)")),
sellOrderAmount,
buyOrderAmount
);
function NegativeSpreadError(uint256 sellOrderAmount, uint256 buyOrderAmount) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("NegativeSpreadError(uint256,uint256)")),
sellOrderAmount,
buyOrderAmount
);
}
function SellOrderFeesExceedSpreadError(
uint256 sellOrderFees,
uint256 spread
)
function SellOrderFeesExceedSpreadError(uint256 sellOrderFees, uint256 spread)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("SellOrderFeesExceedSpreadError(uint256,uint256)")),
sellOrderFees,
spread
);
return
abi.encodeWithSelector(
bytes4(keccak256("SellOrderFeesExceedSpreadError(uint256,uint256)")),
sellOrderFees,
spread
);
}
function OnlyTakerError(
address sender,
address taker
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("OnlyTakerError(address,address)")),
sender,
taker
);
function OnlyTakerError(address sender, address taker) internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("OnlyTakerError(address,address)")), sender, taker);
}
function InvalidSignerError(
address maker,
address signer
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("InvalidSignerError(address,address)")),
maker,
signer
);
function InvalidSignerError(address maker, address signer) internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("InvalidSignerError(address,address)")), maker, signer);
}
function OrderNotFillableError(
address maker,
uint256 nonce,
uint8 orderStatus
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("OrderNotFillableError(address,uint256,uint8)")),
maker,
nonce,
orderStatus
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("OrderNotFillableError(address,uint256,uint8)")),
maker,
nonce,
orderStatus
);
}
function TokenIdMismatchError(
uint256 tokenId,
uint256 orderTokenId
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("TokenIdMismatchError(uint256,uint256)")),
tokenId,
orderTokenId
);
function TokenIdMismatchError(uint256 tokenId, uint256 orderTokenId) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(bytes4(keccak256("TokenIdMismatchError(uint256,uint256)")), tokenId, orderTokenId);
}
function PropertyValidationFailedError(
@ -197,33 +102,28 @@ library LibNFTOrdersRichErrors {
uint256 tokenId,
bytes memory propertyData,
bytes memory errorData
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("PropertyValidationFailedError(address,address,uint256,bytes,bytes)")),
propertyValidator,
token,
tokenId,
propertyData,
errorData
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("PropertyValidationFailedError(address,address,uint256,bytes,bytes)")),
propertyValidator,
token,
tokenId,
propertyData,
errorData
);
}
function ExceedsRemainingOrderAmount(
uint128 remainingOrderAmount,
uint128 fillAmount
)
function ExceedsRemainingOrderAmount(uint128 remainingOrderAmount, uint128 fillAmount)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("ExceedsRemainingOrderAmount(uint128,uint128)")),
remainingOrderAmount,
fillAmount
);
return
abi.encodeWithSelector(
bytes4(keccak256("ExceedsRemainingOrderAmount(uint128,uint128)")),
remainingOrderAmount,
fillAmount
);
}
}

206
contracts/zero-ex/contracts/src/errors/LibNativeOrdersRichErrors.sol
View File

@ -19,187 +19,131 @@
pragma solidity ^0.6.5;
library LibNativeOrdersRichErrors {
// solhint-disable func-name-mixedcase
function ProtocolFeeRefundFailed(
address receiver,
uint256 refundAmount
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("ProtocolFeeRefundFailed(address,uint256)")),
receiver,
refundAmount
);
function ProtocolFeeRefundFailed(address receiver, uint256 refundAmount) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("ProtocolFeeRefundFailed(address,uint256)")),
receiver,
refundAmount
);
}
function OrderNotFillableByOriginError(
bytes32 orderHash,
address txOrigin,
address orderTxOrigin
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("OrderNotFillableByOriginError(bytes32,address,address)")),
orderHash,
txOrigin,
orderTxOrigin
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("OrderNotFillableByOriginError(bytes32,address,address)")),
orderHash,
txOrigin,
orderTxOrigin
);
}
function OrderNotFillableError(
bytes32 orderHash,
uint8 orderStatus
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("OrderNotFillableError(bytes32,uint8)")),
orderHash,
orderStatus
);
function OrderNotFillableError(bytes32 orderHash, uint8 orderStatus) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(bytes4(keccak256("OrderNotFillableError(bytes32,uint8)")), orderHash, orderStatus);
}
function OrderNotSignedByMakerError(
bytes32 orderHash,
address signer,
address maker
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("OrderNotSignedByMakerError(bytes32,address,address)")),
orderHash,
signer,
maker
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("OrderNotSignedByMakerError(bytes32,address,address)")),
orderHash,
signer,
maker
);
}
function InvalidSignerError(
address maker,
address signer
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("InvalidSignerError(address,address)")),
maker,
signer
);
function InvalidSignerError(address maker, address signer) internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("InvalidSignerError(address,address)")), maker, signer);
}
function OrderNotFillableBySenderError(
bytes32 orderHash,
address sender,
address orderSender
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("OrderNotFillableBySenderError(bytes32,address,address)")),
orderHash,
sender,
orderSender
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("OrderNotFillableBySenderError(bytes32,address,address)")),
orderHash,
sender,
orderSender
);
}
function OrderNotFillableByTakerError(
bytes32 orderHash,
address taker,
address orderTaker
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("OrderNotFillableByTakerError(bytes32,address,address)")),
orderHash,
taker,
orderTaker
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("OrderNotFillableByTakerError(bytes32,address,address)")),
orderHash,
taker,
orderTaker
);
}
function CancelSaltTooLowError(
uint256 minValidSalt,
uint256 oldMinValidSalt
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("CancelSaltTooLowError(uint256,uint256)")),
minValidSalt,
oldMinValidSalt
);
function CancelSaltTooLowError(uint256 minValidSalt, uint256 oldMinValidSalt) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("CancelSaltTooLowError(uint256,uint256)")),
minValidSalt,
oldMinValidSalt
);
}
function FillOrKillFailedError(
bytes32 orderHash,
uint256 takerTokenFilledAmount,
uint256 takerTokenFillAmount
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("FillOrKillFailedError(bytes32,uint256,uint256)")),
orderHash,
takerTokenFilledAmount,
takerTokenFillAmount
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("FillOrKillFailedError(bytes32,uint256,uint256)")),
orderHash,
takerTokenFilledAmount,
takerTokenFillAmount
);
}
function OnlyOrderMakerAllowed(
bytes32 orderHash,
address sender,
address maker
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("OnlyOrderMakerAllowed(bytes32,address,address)")),
orderHash,
sender,
maker
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("OnlyOrderMakerAllowed(bytes32,address,address)")),
orderHash,
sender,
maker
);
}
function BatchFillIncompleteError(
bytes32 orderHash,
uint256 takerTokenFilledAmount,
uint256 takerTokenFillAmount
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("BatchFillIncompleteError(bytes32,uint256,uint256)")),
orderHash,
takerTokenFilledAmount,
takerTokenFillAmount
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("BatchFillIncompleteError(bytes32,uint256,uint256)")),
orderHash,
takerTokenFilledAmount,
takerTokenFillAmount
);
}
}

39
contracts/zero-ex/contracts/src/errors/LibOwnableRichErrors.sol
View File

@ -19,45 +19,18 @@
pragma solidity ^0.6.5;
library LibOwnableRichErrors {
// solhint-disable func-name-mixedcase
function OnlyOwnerError(
address sender,
address owner
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("OnlyOwnerError(address,address)")),
sender,
owner
);
function OnlyOwnerError(address sender, address owner) internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("OnlyOwnerError(address,address)")), sender, owner);
}
function TransferOwnerToZeroError()
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("TransferOwnerToZeroError()"))
);
function TransferOwnerToZeroError() internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("TransferOwnerToZeroError()")));
}
function MigrateCallFailedError(address target, bytes memory resultData)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("MigrateCallFailedError(address,bytes)")),
target,
resultData
);
function MigrateCallFailedError(address target, bytes memory resultData) internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("MigrateCallFailedError(address,bytes)")), target, resultData);
}
}

50
contracts/zero-ex/contracts/src/errors/LibProxyRichErrors.sol
View File

@ -19,55 +19,23 @@
pragma solidity ^0.6.5;
library LibProxyRichErrors {
// solhint-disable func-name-mixedcase
function NotImplementedError(bytes4 selector)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("NotImplementedError(bytes4)")),
selector
);
function NotImplementedError(bytes4 selector) internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("NotImplementedError(bytes4)")), selector);
}
function InvalidBootstrapCallerError(address actual, address expected)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("InvalidBootstrapCallerError(address,address)")),
actual,
expected
);
function InvalidBootstrapCallerError(address actual, address expected) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(bytes4(keccak256("InvalidBootstrapCallerError(address,address)")), actual, expected);
}
function InvalidDieCallerError(address actual, address expected)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("InvalidDieCallerError(address,address)")),
actual,
expected
);
function InvalidDieCallerError(address actual, address expected) internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("InvalidDieCallerError(address,address)")), actual, expected);
}
function BootstrapCallFailedError(address target, bytes memory resultData)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("BootstrapCallFailedError(address,bytes)")),
target,
resultData
);
function BootstrapCallFailedError(address target, bytes memory resultData) internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("BootstrapCallFailedError(address,bytes)")), target, resultData);
}
}

34
contracts/zero-ex/contracts/src/errors/LibSignatureRichErrors.sol
View File

@ -19,9 +19,7 @@
pragma solidity ^0.6.5;
library LibSignatureRichErrors {
enum SignatureValidationErrorCodes {
ALWAYS_INVALID,
INVALID_LENGTH,
@ -38,32 +36,22 @@ library LibSignatureRichErrors {
bytes32 hash,
address signerAddress,
bytes memory signature
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("SignatureValidationError(uint8,bytes32,address,bytes)")),
code,
hash,
signerAddress,
signature
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("SignatureValidationError(uint8,bytes32,address,bytes)")),
code,
hash,
signerAddress,
signature
);
}
function SignatureValidationError(
SignatureValidationErrorCodes code,
bytes32 hash
)
function SignatureValidationError(SignatureValidationErrorCodes code, bytes32 hash)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("SignatureValidationError(uint8,bytes32)")),
code,
hash
);
return abi.encodeWithSelector(bytes4(keccak256("SignatureValidationError(uint8,bytes32)")), code, hash);
}
}

19
contracts/zero-ex/contracts/src/errors/LibSimpleFunctionRegistryRichErrors.sol
View File

@ -19,20 +19,15 @@
pragma solidity ^0.6.5;
library LibSimpleFunctionRegistryRichErrors {
// solhint-disable func-name-mixedcase
function NotInRollbackHistoryError(bytes4 selector, address targetImpl)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("NotInRollbackHistoryError(bytes4,address)")),
selector,
targetImpl
);
function NotInRollbackHistoryError(bytes4 selector, address targetImpl) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("NotInRollbackHistoryError(bytes4,address)")),
selector,
targetImpl
);
}
}

224
contracts/zero-ex/contracts/src/errors/LibTransformERC20RichErrors.sol
View File

@ -19,105 +19,77 @@
pragma solidity ^0.6.5;
library LibTransformERC20RichErrors {
// solhint-disable func-name-mixedcase,separate-by-one-line-in-contract
function InsufficientEthAttachedError(
uint256 ethAttached,
uint256 ethNeeded
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("InsufficientEthAttachedError(uint256,uint256)")),
ethAttached,
ethNeeded
);
function InsufficientEthAttachedError(uint256 ethAttached, uint256 ethNeeded) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("InsufficientEthAttachedError(uint256,uint256)")),
ethAttached,
ethNeeded
);
}
function IncompleteTransformERC20Error(
address outputToken,
uint256 outputTokenAmount,
uint256 minOutputTokenAmount
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("IncompleteTransformERC20Error(address,uint256,uint256)")),
outputToken,
outputTokenAmount,
minOutputTokenAmount
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("IncompleteTransformERC20Error(address,uint256,uint256)")),
outputToken,
outputTokenAmount,
minOutputTokenAmount
);
}
function NegativeTransformERC20OutputError(
address outputToken,
uint256 outputTokenLostAmount
)
function NegativeTransformERC20OutputError(address outputToken, uint256 outputTokenLostAmount)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("NegativeTransformERC20OutputError(address,uint256)")),
outputToken,
outputTokenLostAmount
);
return
abi.encodeWithSelector(
bytes4(keccak256("NegativeTransformERC20OutputError(address,uint256)")),
outputToken,
outputTokenLostAmount
);
}
function TransformerFailedError(
address transformer,
bytes memory transformerData,
bytes memory resultData
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("TransformerFailedError(address,bytes,bytes)")),
transformer,
transformerData,
resultData
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("TransformerFailedError(address,bytes,bytes)")),
transformer,
transformerData,
resultData
);
}
// Common Transformer errors ///////////////////////////////////////////////
function OnlyCallableByDeployerError(
address caller,
address deployer
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("OnlyCallableByDeployerError(address,address)")),
caller,
deployer
);
function OnlyCallableByDeployerError(address caller, address deployer) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(bytes4(keccak256("OnlyCallableByDeployerError(address,address)")), caller, deployer);
}
function InvalidExecutionContextError(
address actualContext,
address expectedContext
)
function InvalidExecutionContextError(address actualContext, address expectedContext)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("InvalidExecutionContextError(address,address)")),
actualContext,
expectedContext
);
return
abi.encodeWithSelector(
bytes4(keccak256("InvalidExecutionContextError(address,address)")),
actualContext,
expectedContext
);
}
enum InvalidTransformDataErrorCode {
@ -125,19 +97,17 @@ library LibTransformERC20RichErrors {
INVALID_ARRAY_LENGTH
}
function InvalidTransformDataError(
InvalidTransformDataErrorCode errorCode,
bytes memory transformData
)
function InvalidTransformDataError(InvalidTransformDataErrorCode errorCode, bytes memory transformData)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("InvalidTransformDataError(uint8,bytes)")),
errorCode,
transformData
);
return
abi.encodeWithSelector(
bytes4(keccak256("InvalidTransformDataError(uint8,bytes)")),
errorCode,
transformData
);
}
// FillQuoteTransformer errors /////////////////////////////////////////////
@ -146,89 +116,57 @@ library LibTransformERC20RichErrors {
address sellToken,
uint256 soldAmount,
uint256 sellAmount
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("IncompleteFillSellQuoteError(address,uint256,uint256)")),
sellToken,
soldAmount,
sellAmount
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("IncompleteFillSellQuoteError(address,uint256,uint256)")),
sellToken,
soldAmount,
sellAmount
);
}
function IncompleteFillBuyQuoteError(
address buyToken,
uint256 boughtAmount,
uint256 buyAmount
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("IncompleteFillBuyQuoteError(address,uint256,uint256)")),
buyToken,
boughtAmount,
buyAmount
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("IncompleteFillBuyQuoteError(address,uint256,uint256)")),
buyToken,
boughtAmount,
buyAmount
);
}
function InsufficientTakerTokenError(
uint256 tokenBalance,
uint256 tokensNeeded
)
function InsufficientTakerTokenError(uint256 tokenBalance, uint256 tokensNeeded)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("InsufficientTakerTokenError(uint256,uint256)")),
tokenBalance,
tokensNeeded
);
return
abi.encodeWithSelector(
bytes4(keccak256("InsufficientTakerTokenError(uint256,uint256)")),
tokenBalance,
tokensNeeded
);
}
function InsufficientProtocolFeeError(
uint256 ethBalance,
uint256 ethNeeded
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("InsufficientProtocolFeeError(uint256,uint256)")),
ethBalance,
ethNeeded
);
function InsufficientProtocolFeeError(uint256 ethBalance, uint256 ethNeeded) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("InsufficientProtocolFeeError(uint256,uint256)")),
ethBalance,
ethNeeded
);
}
function InvalidERC20AssetDataError(
bytes memory assetData
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("InvalidERC20AssetDataError(bytes)")),
assetData
);
function InvalidERC20AssetDataError(bytes memory assetData) internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("InvalidERC20AssetDataError(bytes)")), assetData);
}
function InvalidTakerFeeTokenError(
address token
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("InvalidTakerFeeTokenError(address)")),
token
);
function InvalidTakerFeeTokenError(address token) internal pure returns (bytes memory) {
return abi.encodeWithSelector(bytes4(keccak256("InvalidTakerFeeTokenError(address)")), token);
}
}

46
contracts/zero-ex/contracts/src/errors/LibWalletRichErrors.sol
View File

@ -19,9 +19,7 @@
pragma solidity ^0.6.5;
library LibWalletRichErrors {
// solhint-disable func-name-mixedcase
function WalletExecuteCallFailedError(
@ -30,19 +28,16 @@ library LibWalletRichErrors {
bytes memory callData,
uint256 callValue,
bytes memory errorData
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("WalletExecuteCallFailedError(address,address,bytes,uint256,bytes)")),
wallet,
callTarget,
callData,
callValue,
errorData
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("WalletExecuteCallFailedError(address,address,bytes,uint256,bytes)")),
wallet,
callTarget,
callData,
callValue,
errorData
);
}
function WalletExecuteDelegateCallFailedError(
@ -50,17 +45,14 @@ library LibWalletRichErrors {
address callTarget,
bytes memory callData,
bytes memory errorData
)
internal
pure
returns (bytes memory)
{
return abi.encodeWithSelector(
bytes4(keccak256("WalletExecuteDelegateCallFailedError(address,address,bytes,bytes)")),
wallet,
callTarget,
callData,
errorData
);
) internal pure returns (bytes memory) {
return
abi.encodeWithSelector(
bytes4(keccak256("WalletExecuteDelegateCallFailedError(address,address,bytes,bytes)")),
wallet,
callTarget,
callData,
errorData
);
}
}

14
contracts/zero-ex/contracts/src/external/FeeCollector.sol vendored
View File

@ -27,7 +27,7 @@ import "../vendor/v3/IStaking.sol";
/// @dev The collector contract for protocol fees
contract FeeCollector is AuthorizableV06 {
/// @dev Allow ether transfers to the collector.
receive() external payable { }
receive() external payable {}
constructor() public {
_addAuthorizedAddress(msg.sender);
@ -42,22 +42,14 @@ contract FeeCollector is AuthorizableV06 {
IEtherTokenV06 weth,
IStaking staking,
bytes32 poolId
)
external
onlyAuthorized
{
) external onlyAuthorized {
weth.approve(address(staking), type(uint256).max);
staking.joinStakingPoolAsMaker(poolId);
}
/// @dev Convert all held ether to WETH. Only an authority can call this.
/// @param weth The WETH contract.
function convertToWeth(
IEtherTokenV06 weth
)
external
onlyAuthorized
{
function convertToWeth(IEtherTokenV06 weth) external onlyAuthorized {
if (address(this).balance > 0) {
weth.deposit{value: address(this).balance}();
}

27
contracts/zero-ex/contracts/src/external/FeeCollectorController.sol vendored
View File

@ -25,10 +25,8 @@ import "../vendor/v3/IStaking.sol";
import "./FeeCollector.sol";
import "./LibFeeCollector.sol";
/// @dev A contract that manages `FeeCollector` contracts.
contract FeeCollectorController {
/// @dev Hash of the fee collector init code.
bytes32 public immutable FEE_COLLECTOR_INIT_CODE_HASH;
/// @dev The WETH contract.
@ -36,12 +34,7 @@ contract FeeCollectorController {
/// @dev The staking contract.
IStaking private immutable STAKING;
constructor(
IEtherTokenV06 weth,
IStaking staking
)
public
{
constructor(IEtherTokenV06 weth, IStaking staking) public {
FEE_COLLECTOR_INIT_CODE_HASH = keccak256(type(FeeCollector).creationCode);
WETH = weth;
STAKING = staking;
@ -51,10 +44,7 @@ contract FeeCollectorController {
/// and wrap its ETH into WETH. Anyone may call this.
/// @param poolId The pool ID associated with the staking pool.
/// @return feeCollector The `FeeCollector` contract instance.
function prepareFeeCollectorToPayFees(bytes32 poolId)
external
returns (FeeCollector feeCollector)
{
function prepareFeeCollectorToPayFees(bytes32 poolId) external returns (FeeCollector feeCollector) {
feeCollector = getFeeCollector(poolId);
uint256 codeSize;
assembly {
@ -79,15 +69,8 @@ contract FeeCollectorController {
/// has been called once.
/// @param poolId The pool ID associated with the staking pool.
/// @return feeCollector The `FeeCollector` contract instance.
function getFeeCollector(bytes32 poolId)
public
view
returns (FeeCollector feeCollector)
{
return FeeCollector(LibFeeCollector.getFeeCollectorAddress(
address(this),
FEE_COLLECTOR_INIT_CODE_HASH,
poolId
));
function getFeeCollector(bytes32 poolId) public view returns (FeeCollector feeCollector) {
return
FeeCollector(LibFeeCollector.getFeeCollectorAddress(address(this), FEE_COLLECTOR_INIT_CODE_HASH, poolId));
}
}

74
contracts/zero-ex/contracts/src/external/FlashWallet.sol vendored
View File

@ -25,17 +25,15 @@ import "@0x/contracts-utils/contracts/src/v06/errors/LibOwnableRichErrorsV06.sol
import "../errors/LibWalletRichErrors.sol";
import "./IFlashWallet.sol";
/// @dev A contract that can execute arbitrary calls from its owner.
contract FlashWallet is
IFlashWallet
{
contract FlashWallet is IFlashWallet {
// solhint-disable no-unused-vars,indent,no-empty-blocks
using LibRichErrorsV06 for bytes;
// solhint-disable
/// @dev Store the owner/deployer as an immutable to make this contract stateless.
address public override immutable owner;
address public immutable override owner;
// solhint-enable
constructor() public {
@ -46,10 +44,7 @@ contract FlashWallet is
/// @dev Allows only the (immutable) owner to call a function.
modifier onlyOwner() virtual {
if (msg.sender != owner) {
LibOwnableRichErrorsV06.OnlyOwnerError(
msg.sender,
owner
).rrevert();
LibOwnableRichErrorsV06.OnlyOwnerError(msg.sender, owner).rrevert();
}
_;
}
@ -63,24 +58,12 @@ contract FlashWallet is
address payable target,
bytes calldata callData,
uint256 value
)
external
payable
override
onlyOwner
returns (bytes memory resultData)
{
) external payable override onlyOwner returns (bytes memory resultData) {
bool success;
(success, resultData) = target.call{value: value}(callData);
if (!success) {
LibWalletRichErrors
.WalletExecuteCallFailedError(
address(this),
target,
callData,
value,
resultData
)
.WalletExecuteCallFailedError(address(this), target, callData, value, resultData)
.rrevert();
}
}
@ -90,10 +73,7 @@ contract FlashWallet is
/// @param target The call target.
/// @param callData The call data.
/// @return resultData The data returned by the call.
function executeDelegateCall(
address payable target,
bytes calldata callData
)
function executeDelegateCall(address payable target, bytes calldata callData)
external
payable
override
@ -104,32 +84,25 @@ contract FlashWallet is
(success, resultData) = target.delegatecall(callData);
if (!success) {
LibWalletRichErrors
.WalletExecuteDelegateCallFailedError(
address(this),
target,
callData,
resultData
)
.WalletExecuteDelegateCallFailedError(address(this), target, callData, resultData)
.rrevert();
}
}
// solhint-disable
/// @dev Allows this contract to receive ether.
receive() external override payable {}
receive() external payable override {}
// solhint-enable
/// @dev Signal support for receiving ERC1155 tokens.
/// @param interfaceID The interface ID, as per ERC-165 rules.
/// @return hasSupport `true` if this contract supports an ERC-165 interface.
function supportsInterface(bytes4 interfaceID)
external
pure
returns (bool hasSupport)
{
return interfaceID == this.supportsInterface.selector ||
interfaceID == this.onERC1155Received.selector ^ this.onERC1155BatchReceived.selector ||
interfaceID == this.tokenFallback.selector;
function supportsInterface(bytes4 interfaceID) external pure returns (bool hasSupport) {
return
interfaceID == this.supportsInterface.selector ||
interfaceID == this.onERC1155Received.selector ^ this.onERC1155BatchReceived.selector ||
interfaceID == this.tokenFallback.selector;
}
/// @dev Allow this contract to receive ERC1155 tokens.
@ -140,11 +113,7 @@ contract FlashWallet is
uint256, // id,
uint256, // value,
bytes calldata //data
)
external
pure
returns (bytes4 success)
{
) external pure returns (bytes4 success) {
return this.onERC1155Received.selector;
}
@ -156,11 +125,7 @@ contract FlashWallet is
uint256[] calldata, // ids,
uint256[] calldata, // values,
bytes calldata // data
)
external
pure
returns (bytes4 success)
{
) external pure returns (bytes4 success) {
return this.onERC1155BatchReceived.selector;
}
@ -169,8 +134,5 @@ contract FlashWallet is
address, // from,
uint256, // value,
bytes calldata // value
)
external
pure
{}
) external pure {}
}

12
contracts/zero-ex/contracts/src/external/IFlashWallet.sol vendored
View File

@ -22,10 +22,8 @@ pragma experimental ABIEncoderV2;
import "@0x/contracts-utils/contracts/src/v06/interfaces/IOwnableV06.sol";
/// @dev A contract that can execute arbitrary calls from its owner.
interface IFlashWallet {
/// @dev Execute an arbitrary call. Only an authority can call this.
/// @param target The call target.
/// @param callData The call data.
@ -35,20 +33,14 @@ interface IFlashWallet {
address payable target,
bytes calldata callData,
uint256 value
)
external
payable
returns (bytes memory resultData);
) external payable returns (bytes memory resultData);
/// @dev Execute an arbitrary delegatecall, in the context of this puppet.
/// Only an authority can call this.
/// @param target The call target.
/// @param callData The call data.
/// @return resultData The data returned by the call.
function executeDelegateCall(
address payable target,
bytes calldata callData
)
function executeDelegateCall(address payable target, bytes calldata callData)
external
payable
returns (bytes memory resultData);

11
contracts/zero-ex/contracts/src/external/ILiquidityProviderSandbox.sol vendored
View File

@ -23,9 +23,7 @@ pragma experimental ABIEncoderV2;
import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
import "../vendor/ILiquidityProvider.sol";
interface ILiquidityProviderSandbox {
/// @dev Calls `sellTokenForToken` on the given `provider` contract to
/// trigger a trade.
/// @param provider The address of the on-chain liquidity provider.
@ -41,8 +39,7 @@ interface ILiquidityProviderSandbox {
address recipient,
uint256 minBuyAmount,
bytes calldata auxiliaryData
)
external;
) external;
/// @dev Calls `sellEthForToken` on the given `provider` contract to
/// trigger a trade.
@ -57,8 +54,7 @@ interface ILiquidityProviderSandbox {
address recipient,
uint256 minBuyAmount,
bytes calldata auxiliaryData
)
external;
) external;
/// @dev Calls `sellTokenForEth` on the given `provider` contract to
/// trigger a trade.
@ -73,6 +69,5 @@ interface ILiquidityProviderSandbox {
address recipient,
uint256 minBuyAmount,
bytes calldata auxiliaryData
)
external;
) external;
}

31
contracts/zero-ex/contracts/src/external/LibFeeCollector.sol vendored
View File

@ -20,25 +20,30 @@
pragma solidity ^0.6.5;
pragma experimental ABIEncoderV2;
/// @dev Helpers for computing `FeeCollector` contract addresses.
library LibFeeCollector {
/// @dev Compute the CREATE2 address for a fee collector.
/// @param controller The address of the `FeeCollectorController` contract.
/// @param initCodeHash The init code hash of the `FeeCollector` contract.
/// @param poolId The fee collector's pool ID.
function getFeeCollectorAddress(address controller, bytes32 initCodeHash, bytes32 poolId)
internal
pure
returns (address payable feeCollectorAddress)
{
function getFeeCollectorAddress(
address controller,
bytes32 initCodeHash,
bytes32 poolId
) internal pure returns (address payable feeCollectorAddress) {
// Compute the CREATE2 address for the fee collector.
return address(uint256(keccak256(abi.encodePacked(
byte(0xff),
controller,
poolId, // pool ID is salt
initCodeHash
))));
return
address(
uint256(
keccak256(
abi.encodePacked(
bytes1(0xff),
controller,
poolId, // pool ID is salt
initCodeHash
)
)
)
);
}
}

54
contracts/zero-ex/contracts/src/external/LiquidityProviderSandbox.sol vendored
View File

@ -22,30 +22,22 @@ import "../vendor/ILiquidityProvider.sol";
import "../vendor/v3/IERC20Bridge.sol";
import "./ILiquidityProviderSandbox.sol";
/// @dev A permissionless contract through which the ZeroEx contract can
/// safely trigger a trade on an external `ILiquidityProvider` contract.
contract LiquidityProviderSandbox is
ILiquidityProviderSandbox
{
contract LiquidityProviderSandbox is ILiquidityProviderSandbox {
using LibRichErrorsV06 for bytes;
/// @dev Store the owner as an immutable.
address public immutable owner;
constructor(address owner_)
public
{
constructor(address owner_) public {
owner = owner_;
}
/// @dev Allows only the (immutable) owner to call a function.
modifier onlyOwner() virtual {
if (msg.sender != owner) {
LibOwnableRichErrorsV06.OnlyOwnerError(
msg.sender,
owner
).rrevert();
LibOwnableRichErrorsV06.OnlyOwnerError(msg.sender, owner).rrevert();
}
_;
}
@ -65,18 +57,8 @@ contract LiquidityProviderSandbox is
address recipient,
uint256 minBuyAmount,
bytes calldata auxiliaryData
)
external
onlyOwner
override
{
provider.sellTokenForToken(
inputToken,
outputToken,
recipient,
minBuyAmount,
auxiliaryData
);
) external override onlyOwner {
provider.sellTokenForToken(inputToken, outputToken, recipient, minBuyAmount, auxiliaryData);
}
/// @dev Calls `sellEthForToken` on the given `provider` contract to
@ -92,17 +74,8 @@ contract LiquidityProviderSandbox is
address recipient,
uint256 minBuyAmount,
bytes calldata auxiliaryData
)
external
onlyOwner
override
{
provider.sellEthForToken(
outputToken,
recipient,
minBuyAmount,
auxiliaryData
);
) external override onlyOwner {
provider.sellEthForToken(outputToken, recipient, minBuyAmount, auxiliaryData);
}
/// @dev Calls `sellTokenForEth` on the given `provider` contract to
@ -118,16 +91,7 @@ contract LiquidityProviderSandbox is
address recipient,
uint256 minBuyAmount,
bytes calldata auxiliaryData
)
external
onlyOwner
override
{
provider.sellTokenForEth(
inputToken,
payable(recipient),
minBuyAmount,
auxiliaryData
);
) external override onlyOwner {
provider.sellTokenForEth(inputToken, payable(recipient), minBuyAmount, auxiliaryData);
}
}

Some files were not shown because too many files have changed in this diff Show More