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

Upgrade prettier-plugin-solidity to stable v1 (#622)

Browse Source 
* Upgrade prettier-plugin-solidity to stable v1

* Prettier format contracts
This commit is contained in:
Elena 2022-11-23 11:53:40 +02:00 committed by GitHub
parent 0000143b4e
commit 010a926d79
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
101 changed files with 396 additions and 896 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -47,11 +47,7 @@ contract ERC20Token is IERC20Token {
/// @param _to The address of the recipient /// @param _to The address of the recipient
/// @param _value The amount of token to be transferred /// @param _value The amount of token to be transferred
/// @return True if transfer was successful /// @return True if transfer was successful
function transferFrom( function transferFrom(address _from, address _to, uint256 _value) external returns (bool) {
address _from,
address _to,
uint256 _value
) external returns (bool) {
require(balances[_from] >= _value, "ERC20_INSUFFICIENT_BALANCE"); require(balances[_from] >= _value, "ERC20_INSUFFICIENT_BALANCE");
require(allowed[_from][msg.sender] >= _value, "ERC20_INSUFFICIENT_ALLOWANCE"); require(allowed[_from][msg.sender] >= _value, "ERC20_INSUFFICIENT_ALLOWANCE");
require(balances[_to] + _value >= balances[_to], "UINT256_OVERFLOW"); require(balances[_to] + _value >= balances[_to], "UINT256_OVERFLOW");

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

@ -31,11 +31,7 @@ library LibERC20Token {
/// @param token The address of the token contract. /// @param token The address of the token contract.
/// @param spender The address that receives an allowance. /// @param spender The address that receives an allowance.
/// @param allowance The allowance to set. /// @param allowance The allowance to set.
function approve( function approve(address token, address spender, uint256 allowance) internal {
address token,
address spender,
uint256 allowance
) internal {
bytes memory callData = abi.encodeWithSelector(IERC20Token(0).approve.selector, spender, allowance); bytes memory callData = abi.encodeWithSelector(IERC20Token(0).approve.selector, spender, allowance);
_callWithOptionalBooleanResult(token, callData); _callWithOptionalBooleanResult(token, callData);
} }
@ -47,11 +43,7 @@ library LibERC20Token {
/// @param token The address of the token contract. /// @param token The address of the token contract.
/// @param spender The address that receives an allowance. /// @param spender The address that receives an allowance.
/// @param amount The minimum allowance needed. /// @param amount The minimum allowance needed.
function approveIfBelow( function approveIfBelow(address token, address spender, uint256 amount) internal {
address token,
address spender,
uint256 amount
) internal {
if (IERC20Token(token).allowance(address(this), spender) < amount) { if (IERC20Token(token).allowance(address(this), spender) < amount) {
approve(token, spender, uint256(-1)); approve(token, spender, uint256(-1));
} }
@ -63,11 +55,7 @@ library LibERC20Token {
/// @param token The address of the token contract. /// @param token The address of the token contract.
/// @param to The address that receives the tokens /// @param to The address that receives the tokens
/// @param amount Number of tokens to transfer. /// @param amount Number of tokens to transfer.
function transfer( function transfer(address token, address to, uint256 amount) internal {
address token,
address to,
uint256 amount
) internal {
bytes memory callData = abi.encodeWithSelector(IERC20Token(0).transfer.selector, to, amount); bytes memory callData = abi.encodeWithSelector(IERC20Token(0).transfer.selector, to, amount);
_callWithOptionalBooleanResult(token, callData); _callWithOptionalBooleanResult(token, callData);
} }
@ -79,12 +67,7 @@ library LibERC20Token {
/// @param from The owner of the tokens. /// @param from The owner of the tokens.
/// @param to The address that receives the tokens /// @param to The address that receives the tokens
/// @param amount Number of tokens to transfer. /// @param amount Number of tokens to transfer.
function transferFrom( function transferFrom(address token, address from, address to, uint256 amount) internal {
address token,
address from,
address to,
uint256 amount
) internal {
bytes memory callData = abi.encodeWithSelector(IERC20Token(0).transferFrom.selector, from, to, amount); bytes memory callData = abi.encodeWithSelector(IERC20Token(0).transferFrom.selector, from, to, amount);
_callWithOptionalBooleanResult(token, callData); _callWithOptionalBooleanResult(token, callData);
} }
@ -107,11 +90,7 @@ library LibERC20Token {
/// @param owner The owner of the tokens. /// @param owner The owner of the tokens.
/// @param spender The address the spender. /// @param spender The address the spender.
/// @return allowance The allowance for a token, owner, and spender. /// @return allowance The allowance for a token, owner, and spender.
function allowance( function allowance(address token, address owner, address spender) internal view returns (uint256 allowance_) {
address token,
address owner,
address spender
) internal view returns (uint256 allowance_) {
(bool didSucceed, bytes memory resultData) = token.staticcall( (bool didSucceed, bytes memory resultData) = token.staticcall(
abi.encodeWithSelector(IERC20Token(0).allowance.selector, owner, spender) abi.encodeWithSelector(IERC20Token(0).allowance.selector, owner, spender)
); );

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

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

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

@ -58,11 +58,7 @@ contract WETH9 {
return transferFrom(msg.sender, dst, wad); return transferFrom(msg.sender, dst, wad);
} }
function transferFrom( function transferFrom(address src, address dst, uint256 wad) public returns (bool) {
address src,
address dst,
uint256 wad
) public returns (bool) {
require(balanceOf[src] >= wad); require(balanceOf[src] >= wad);
if (src != msg.sender && allowance[src][msg.sender] != uint256(-1)) { if (src != msg.sender && allowance[src][msg.sender] != uint256(-1)) {

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

@ -37,11 +37,7 @@ contract Token {
/// @param _to The address of the recipient /// @param _to The address of the recipient
/// @param _value The amount of token to be transferred /// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not /// @return Whether the transfer was successful or not
function transferFrom( function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
address _from,
address _to,
uint256 _value
) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens /// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens /// @param _spender The address of the account able to transfer the tokens
@ -71,11 +67,7 @@ contract ERC20Token is Token {
} }
} }
function transferFrom( function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
address _from,
address _to,
uint256 _value
) returns (bool) {
if ( if (
balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value >= balances[_to] balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value >= balances[_to]
) { ) {
@ -109,18 +101,14 @@ contract ERC20Token is Token {
} }
contract UnlimitedAllowanceToken is ERC20Token { contract UnlimitedAllowanceToken is ERC20Token {
uint256 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. /// @dev ERC20 transferFrom, modified such that an allowance of MAX_UINT represents an unlimited allowance.
/// @param _from Address to transfer from. /// @param _from Address to transfer from.
/// @param _to Address to transfer to. /// @param _to Address to transfer to.
/// @param _value Amount to transfer. /// @param _value Amount to transfer.
/// @return Success of transfer. /// @return Success of transfer.
function transferFrom( function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
address _from,
address _to,
uint256 _value
) public returns (bool) {
uint256 allowance = allowed[_from][msg.sender]; uint256 allowance = allowed[_from][msg.sender];
if (balances[_from] >= _value && allowance >= _value && balances[_to] + _value >= balances[_to]) { if (balances[_from] >= _value && allowance >= _value && balances[_to] + _value >= balances[_to]) {
balances[_to] += _value; balances[_to] += _value;
@ -138,7 +126,7 @@ contract UnlimitedAllowanceToken is ERC20Token {
contract ZRXToken is UnlimitedAllowanceToken { contract ZRXToken is UnlimitedAllowanceToken {
uint8 public constant decimals = 18; uint8 public constant decimals = 18;
uint256 public totalSupply = 10**27; // 1 billion tokens, 18 decimal places uint256 public totalSupply = 10 ** 27; // 1 billion tokens, 18 decimal places
string public constant name = "0x Protocol Token"; string public constant name = "0x Protocol Token";
string public constant symbol = "ZRX"; string public constant symbol = "ZRX";

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

@ -34,11 +34,7 @@ contract IERC20Token {
/// @param _to The address of the recipient /// @param _to The address of the recipient
/// @param _value The amount of token to be transferred /// @param _value The amount of token to be transferred
/// @return True if transfer was successful /// @return True if transfer was successful
function transferFrom( function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
address _from,
address _to,
uint256 _value
) external returns (bool);
/// @dev `msg.sender` approves `_spender` to spend `_value` tokens /// @dev `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens /// @param _spender The address of the account able to transfer the tokens

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

@ -35,11 +35,7 @@ interface IERC20TokenV06 {
/// @param to The address of the recipient /// @param to The address of the recipient
/// @param value The amount of token to be transferred /// @param value The amount of token to be transferred
/// @return True if transfer was successful /// @return True if transfer was successful
function transferFrom( function transferFrom(address from, address to, uint256 value) external returns (bool);
address from,
address to,
uint256 value
) external returns (bool);
/// @dev `msg.sender` approves `spender` to spend `value` tokens /// @dev `msg.sender` approves `spender` to spend `value` tokens
/// @param spender The address of the account able to transfer the tokens /// @param spender The address of the account able to transfer the tokens

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

@ -31,11 +31,7 @@ library LibERC20TokenV06 {
/// @param token The address of the token contract. /// @param token The address of the token contract.
/// @param spender The address that receives an allowance. /// @param spender The address that receives an allowance.
/// @param allowance The allowance to set. /// @param allowance The allowance to set.
function compatApprove( function compatApprove(IERC20TokenV06 token, address spender, uint256 allowance) internal {
IERC20TokenV06 token,
address spender,
uint256 allowance
) internal {
bytes memory callData = abi.encodeWithSelector(token.approve.selector, spender, allowance); bytes memory callData = abi.encodeWithSelector(token.approve.selector, spender, allowance);
_callWithOptionalBooleanResult(address(token), callData); _callWithOptionalBooleanResult(address(token), callData);
} }
@ -46,11 +42,7 @@ library LibERC20TokenV06 {
/// @param token The address of the token contract. /// @param token The address of the token contract.
/// @param spender The address that receives an allowance. /// @param spender The address that receives an allowance.
/// @param amount The minimum allowance needed. /// @param amount The minimum allowance needed.
function approveIfBelow( function approveIfBelow(IERC20TokenV06 token, address spender, uint256 amount) internal {
IERC20TokenV06 token,
address spender,
uint256 amount
) internal {
if (token.allowance(address(this), spender) < amount) { if (token.allowance(address(this), spender) < amount) {
compatApprove(token, spender, uint256(-1)); compatApprove(token, spender, uint256(-1));
} }
@ -61,11 +53,7 @@ library LibERC20TokenV06 {
/// @param token The address of the token contract. /// @param token The address of the token contract.
/// @param to The address that receives the tokens /// @param to The address that receives the tokens
/// @param amount Number of tokens to transfer. /// @param amount Number of tokens to transfer.
function compatTransfer( function compatTransfer(IERC20TokenV06 token, address to, uint256 amount) internal {
IERC20TokenV06 token,
address to,
uint256 amount
) internal {
bytes memory callData = abi.encodeWithSelector(token.transfer.selector, to, amount); bytes memory callData = abi.encodeWithSelector(token.transfer.selector, to, amount);
_callWithOptionalBooleanResult(address(token), callData); _callWithOptionalBooleanResult(address(token), callData);
} }
@ -76,12 +64,7 @@ library LibERC20TokenV06 {
/// @param from The owner of the tokens. /// @param from The owner of the tokens.
/// @param to The address that receives the tokens /// @param to The address that receives the tokens
/// @param amount Number of tokens to transfer. /// @param amount Number of tokens to transfer.
function compatTransferFrom( function compatTransferFrom(IERC20TokenV06 token, address from, address to, uint256 amount) internal {
IERC20TokenV06 token,
address from,
address to,
uint256 amount
) internal {
bytes memory callData = abi.encodeWithSelector(token.transferFrom.selector, from, to, amount); bytes memory callData = abi.encodeWithSelector(token.transferFrom.selector, from, to, amount);
_callWithOptionalBooleanResult(address(token), callData); _callWithOptionalBooleanResult(address(token), callData);
} }

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

@ -30,12 +30,7 @@ contract DummyERC20Token is Ownable, MintableERC20Token {
uint256 public decimals; uint256 public decimals;
uint256 public constant MAX_MINT_AMOUNT = 10000000000000000000000; uint256 public constant MAX_MINT_AMOUNT = 10000000000000000000000;
constructor( constructor(string memory _name, string memory _symbol, uint256 _decimals, uint256 _totalSupply) public {
string memory _name,
string memory _symbol,
uint256 _decimals,
uint256 _totalSupply
) public {
name = _name; name = _name;
symbol = _symbol; symbol = _symbol;
decimals = _decimals; decimals = _decimals;

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

@ -32,11 +32,7 @@ contract DummyMultipleReturnERC20Token is DummyERC20Token {
/// @param _from The address of the sender /// @param _from The address of the sender
/// @param _to The address of the recipient /// @param _to The address of the recipient
/// @param _value The amount of token to be transferred /// @param _value The amount of token to be transferred
function transferFrom( function transferFrom(address _from, address _to, uint256 _value) external returns (bool) {
address _from,
address _to,
uint256 _value
) external returns (bool) {
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 64 bytes // HACK: This contract will not compile if we remove `returns (bool)`, so we manually return 64 bytes

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

@ -50,11 +50,7 @@ contract DummyNoReturnERC20Token is DummyERC20Token {
/// @param _from The address of the sender /// @param _from The address of the sender
/// @param _to The address of the recipient /// @param _to The address of the recipient
/// @param _value The amount of token to be transferred /// @param _value The amount of token to be transferred
function transferFrom( function transferFrom(address _from, address _to, uint256 _value) external returns (bool) {
address _from,
address _to,
uint256 _value
) external returns (bool) {
require(balances[_from] >= _value, "ERC20_INSUFFICIENT_BALANCE"); require(balances[_from] >= _value, "ERC20_INSUFFICIENT_BALANCE");
require(allowed[_from][msg.sender] >= _value, "ERC20_INSUFFICIENT_ALLOWANCE"); require(allowed[_from][msg.sender] >= _value, "ERC20_INSUFFICIENT_ALLOWANCE");
require(balances[_to] + _value >= balances[_to], "UINT256_OVERFLOW"); require(balances[_to] + _value >= balances[_to], "UINT256_OVERFLOW");

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

@ -29,11 +29,7 @@ contract TestLibERC20TokenTarget {
bytes private _revertData; bytes private _revertData;
bytes private _returnData; bytes private _returnData;
function setBehavior( function setBehavior(bool shouldRevert, bytes calldata revertData, bytes calldata returnData) external {
bool shouldRevert,
bytes calldata revertData,
bytes calldata returnData
) external {
_shouldRevert = shouldRevert; _shouldRevert = shouldRevert;
_revertData = revertData; _revertData = revertData;
_returnData = returnData; _returnData = returnData;
@ -49,11 +45,7 @@ contract TestLibERC20TokenTarget {
_execute(); _execute();
} }
function transferFrom( function transferFrom(address from, address to, uint256 amount) external returns (bool) {
address from,
address to,
uint256 amount
) external returns (bool) {
emit TransferFromCalled(from, to, amount); emit TransferFromCalled(from, to, amount);
_execute(); _execute();
} }

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

@ -32,11 +32,7 @@ contract UntransferrableDummyERC20Token is DummyERC20Token {
/// @param _from The address of the sender /// @param _from The address of the sender
/// @param _to The address of the recipient /// @param _to The address of the recipient
/// @param _value The amount of token to be transferred /// @param _value The amount of token to be transferred
function transferFrom( function transferFrom(address _from, address _to, uint256 _value) external returns (bool) {
address _from,
address _to,
uint256 _value
) external returns (bool) {
require(false, "TRANSFER_DISABLED"); require(false, "TRANSFER_DISABLED");
} }
} }

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

@ -36,7 +36,9 @@ interface ISablier {
function balanceOf(uint256 streamId, address who) external view returns (uint256 balance); function balanceOf(uint256 streamId, address who) external view returns (uint256 balance);
function getStream(uint256 streamId) function getStream(
uint256 streamId
)
external external
view view
returns ( returns (

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

@ -36,7 +36,7 @@ contract DefaultPoolOperator {
stakingProxy = stakingProxy_; stakingProxy = stakingProxy_;
weth = weth_; weth = weth_;
// operator share = 100% // 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 /// @dev Sends this contract's entire WETH balance to the

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

@ -81,10 +81,10 @@ interface IStaking {
/// @param staker Owner of stake. /// @param staker Owner of stake.
/// @param stakeStatus UNDELEGATED or DELEGATED /// @param stakeStatus UNDELEGATED or DELEGATED
/// @return balance Owner's stake balances for given status. /// @return balance Owner's stake balances for given status.
function getOwnerStakeByStatus(address staker, StakeStatus stakeStatus) function getOwnerStakeByStatus(
external address staker,
view StakeStatus stakeStatus
returns (StoredBalance memory balance); ) external view returns (StoredBalance memory balance);
/// @dev Returns the total stake delegated to a specific staking pool, /// @dev Returns the total stake delegated to a specific staking pool,
/// across all members. /// across all members.
@ -96,8 +96,8 @@ interface IStaking {
/// @param staker of stake. /// @param staker of stake.
/// @param poolId Unique Id of pool. /// @param poolId Unique Id of pool.
/// @return balance Stake delegated to pool by staker. /// @return balance Stake delegated to pool by staker.
function getStakeDelegatedToPoolByOwner(address staker, bytes32 poolId) function getStakeDelegatedToPoolByOwner(
external address staker,
view bytes32 poolId
returns (StoredBalance memory balance); ) external view returns (StoredBalance memory balance);
} }

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

@ -112,11 +112,7 @@ interface IZrxTreasury {
/// @param operatedPoolIds The pools operated by `msg.sender`. The /// @param operatedPoolIds The pools operated by `msg.sender`. The
/// ZRX currently delegated to those pools will be accounted /// ZRX currently delegated to those pools will be accounted
/// for in the voting power. /// for in the voting power.
function castVote( function castVote(uint256 proposalId, bool support, bytes32[] calldata operatedPoolIds) external;
uint256 proposalId,
bool support,
bytes32[] calldata operatedPoolIds
) external;
/// @dev Casts a vote for the given proposal, by signature. /// @dev Casts a vote for the given proposal, by signature.
/// Only callable during the voting period for that proposal. /// Only callable during the voting period for that proposal.
@ -159,8 +155,8 @@ interface IZrxTreasury {
/// ZRX currently delegated to those pools will be accounted /// ZRX currently delegated to those pools will be accounted
/// for in the voting power. /// for in the voting power.
/// @return votingPower The current voting power of the given account. /// @return votingPower The current voting power of the given account.
function getVotingPower(address account, bytes32[] calldata operatedPoolIds) function getVotingPower(
external address account,
view bytes32[] calldata operatedPoolIds
returns (uint256 votingPower); ) external view returns (uint256 votingPower);
} }

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

@ -144,11 +144,7 @@ contract ZrxTreasury is IZrxTreasury {
/// @param operatedPoolIds The pools operated by `msg.sender`. The /// @param operatedPoolIds The pools operated by `msg.sender`. The
/// ZRX currently delegated to those pools will be accounted /// ZRX currently delegated to those pools will be accounted
/// for in the voting power. /// for in the voting power.
function castVote( function castVote(uint256 proposalId, bool support, bytes32[] memory operatedPoolIds) public override {
uint256 proposalId,
bool support,
bytes32[] memory operatedPoolIds
) public override {
return _castVote(msg.sender, proposalId, support, operatedPoolIds); return _castVote(msg.sender, proposalId, support, operatedPoolIds);
} }
@ -219,12 +215,10 @@ contract ZrxTreasury is IZrxTreasury {
/// ZRX currently delegated to those pools will be accounted /// ZRX currently delegated to those pools will be accounted
/// for in the voting power. /// for in the voting power.
/// @return votingPower The current voting power of the given account. /// @return votingPower The current voting power of the given account.
function getVotingPower(address account, bytes32[] memory operatedPoolIds) function getVotingPower(
public address account,
view bytes32[] memory operatedPoolIds
override ) public view override returns (uint256 votingPower) {
returns (uint256 votingPower)
{
uint256 delegatedBalance = stakingProxy uint256 delegatedBalance = stakingProxy
.getOwnerStakeByStatus(account, IStaking.StakeStatus.DELEGATED) .getOwnerStakeByStatus(account, IStaking.StakeStatus.DELEGATED)
.currentEpochBalance; .currentEpochBalance;
@ -307,12 +301,7 @@ contract ZrxTreasury is IZrxTreasury {
/// @dev Casts a vote for the given proposal. Only callable /// @dev Casts a vote for the given proposal. Only callable
/// during the voting period for that proposal. See /// during the voting period for that proposal. See
/// `getVotingPower` for how voting power is computed. /// `getVotingPower` for how voting power is computed.
function _castVote( function _castVote(address voter, uint256 proposalId, bool support, bytes32[] memory operatedPoolIds) private {
address voter,
uint256 proposalId,
bool support,
bytes32[] memory operatedPoolIds
) private {
if (proposalId >= proposalCount()) { if (proposalId >= proposalCount()) {
revert("_castVote/INVALID_PROPOSAL_ID"); revert("_castVote/INVALID_PROPOSAL_ID");
} }

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

@ -23,7 +23,7 @@ library D18 {
/// @dev Decimal places for dydx value quantities. /// @dev Decimal places for dydx value quantities.
uint256 private constant PRECISION = 18; uint256 private constant PRECISION = 18;
/// @dev 1.0 in base-18 decimal. /// @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. /// @dev Minimum signed integer value.
int256 private constant MIN_INT256_VALUE = int256 private constant MIN_INT256_VALUE =
int256(0x8000000000000000000000000000000000000000000000000000000000000000); int256(0x8000000000000000000000000000000000000000000000000000000000000000);

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

@ -117,11 +117,10 @@ library LibAddressArray {
/// @param addressArray Array of addresses. /// @param addressArray Array of addresses.
/// @param target Address to search for in array. /// @param target Address to search for in array.
/// @return Existence and index of the target in the array. /// @return Existence and index of the target in the array.
function indexOf(address[] memory addressArray, address target) function indexOf(
internal address[] memory addressArray,
pure address target
returns (bool success, uint256 index) ) internal pure returns (bool success, uint256 index) {
{
assembly { assembly {
// Calculate byte length of array // Calculate byte length of array
let arrayByteLen := mul(mload(addressArray), 32) let arrayByteLen := mul(mload(addressArray), 32)

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

@ -22,11 +22,10 @@ library LibAddressArrayRichErrors {
// bytes4(keccak256("MismanagedMemoryError(uint256,uint256)")) // bytes4(keccak256("MismanagedMemoryError(uint256,uint256)"))
bytes4 internal constant MISMANAGED_MEMORY_ERROR_SELECTOR = 0x5fc83722; bytes4 internal constant MISMANAGED_MEMORY_ERROR_SELECTOR = 0x5fc83722;
function MismanagedMemoryError(uint256 freeMemPtr, uint256 addressArrayEndPtr) function MismanagedMemoryError(
internal uint256 freeMemPtr,
pure uint256 addressArrayEndPtr
returns (bytes memory) ) internal pure returns (bytes memory) {
{
return abi.encodeWithSelector(MISMANAGED_MEMORY_ERROR_SELECTOR, freeMemPtr, addressArrayEndPtr); return abi.encodeWithSelector(MISMANAGED_MEMORY_ERROR_SELECTOR, freeMemPtr, addressArrayEndPtr);
} }
} }

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

@ -50,11 +50,7 @@ library LibBytes {
/// @param dest memory address to copy bytes to. /// @param dest memory address to copy bytes to.
/// @param source memory address to copy bytes from. /// @param source memory address to copy bytes from.
/// @param length number of bytes to copy. /// @param length number of bytes to copy.
function memCopy( function memCopy(uint256 dest, uint256 source, uint256 length) internal pure {
uint256 dest,
uint256 source,
uint256 length
) internal pure {
if (length < 32) { if (length < 32) {
// Handle a partial word by reading destination and masking // Handle a partial word by reading destination and masking
// off the bits we are interested in. // off the bits we are interested in.
@ -161,11 +157,7 @@ library LibBytes {
/// @param from The starting index for the slice (inclusive). /// @param from The starting index for the slice (inclusive).
/// @param to The final index for the slice (exclusive). /// @param to The final index for the slice (exclusive).
/// @return result The slice containing bytes at indices [from, to) /// @return result The slice containing bytes at indices [from, to)
function slice( function slice(bytes memory b, uint256 from, uint256 to) internal pure returns (bytes memory result) {
bytes memory b,
uint256 from,
uint256 to
) internal pure returns (bytes memory result) {
// Ensure that the from and to positions are valid positions for a slice within // Ensure that the from and to positions are valid positions for a slice within
// the byte array that is being used. // the byte array that is being used.
if (from > to) { if (from > to) {
@ -199,11 +191,7 @@ library LibBytes {
/// @param to The final index for the slice (exclusive). /// @param to The final index for the slice (exclusive).
/// @return result The slice containing bytes at indices [from, to) /// @return result The slice containing bytes at indices [from, to)
/// @dev When `from == 0`, the original array will match the slice. In other cases its state will be corrupted. /// @dev When `from == 0`, the original array will match the slice. In other cases its state will be corrupted.
function sliceDestructive( function sliceDestructive(bytes memory b, uint256 from, uint256 to) internal pure returns (bytes memory result) {
bytes memory b,
uint256 from,
uint256 to
) internal pure returns (bytes memory result) {
// Ensure that the from and to positions are valid positions for a slice within // Ensure that the from and to positions are valid positions for a slice within
// the byte array that is being used. // the byte array that is being used.
if (from > to) { if (from > to) {
@ -303,11 +291,7 @@ library LibBytes {
/// @param b Byte array to insert address into. /// @param b Byte array to insert address into.
/// @param index Index in byte array of address. /// @param index Index in byte array of address.
/// @param input Address to put into byte array. /// @param input Address to put into byte array.
function writeAddress( function writeAddress(bytes memory b, uint256 index, address input) internal pure {
bytes memory b,
uint256 index,
address input
) internal pure {
if (b.length < index + 20) { if (b.length < index + 20) {
LibRichErrors.rrevert( LibRichErrors.rrevert(
LibBytesRichErrors.InvalidByteOperationError( LibBytesRichErrors.InvalidByteOperationError(
@ -376,11 +360,7 @@ library LibBytes {
/// @param b Byte array to insert <input> into. /// @param b Byte array to insert <input> into.
/// @param index Index in byte array of <input>. /// @param index Index in byte array of <input>.
/// @param input bytes32 to put into byte array. /// @param input bytes32 to put into byte array.
function writeBytes32( function writeBytes32(bytes memory b, uint256 index, bytes32 input) internal pure {
bytes memory b,
uint256 index,
bytes32 input
) internal pure {
if (b.length < index + 32) { if (b.length < index + 32) {
LibRichErrors.rrevert( LibRichErrors.rrevert(
LibBytesRichErrors.InvalidByteOperationError( LibBytesRichErrors.InvalidByteOperationError(
@ -413,11 +393,7 @@ library LibBytes {
/// @param b Byte array to insert <input> into. /// @param b Byte array to insert <input> into.
/// @param index Index in byte array of <input>. /// @param index Index in byte array of <input>.
/// @param input uint256 to put into byte array. /// @param input uint256 to put into byte array.
function writeUint256( function writeUint256(bytes memory b, uint256 index, uint256 input) internal pure {
bytes memory b,
uint256 index,
uint256 input
) internal pure {
writeBytes32(b, index, bytes32(input)); writeBytes32(b, index, bytes32(input));
} }

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

@ -62,12 +62,11 @@ library LibFractions {
/// @param denominator The denominator. /// @param denominator The denominator.
/// @return scaledNumerator The rescaled numerator. /// @return scaledNumerator The rescaled numerator.
/// @return scaledDenominator The rescaled denominator. /// @return scaledDenominator The rescaled denominator.
function normalize(uint256 numerator, uint256 denominator) function normalize(
internal uint256 numerator,
pure uint256 denominator
returns (uint256 scaledNumerator, uint256 scaledDenominator) ) internal pure 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. /// @dev Safely scales the difference between two fractions.

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

@ -20,11 +20,7 @@ library LibSafeMathRichErrors {
VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT96 VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT96
} }
function Uint256BinOpError( function Uint256BinOpError(BinOpErrorCodes errorCode, uint256 a, uint256 b) internal pure returns (bytes memory) {
BinOpErrorCodes errorCode,
uint256 a,
uint256 b
) internal pure returns (bytes memory) {
return abi.encodeWithSelector(UINT256_BINOP_ERROR_SELECTOR, errorCode, a, b); return abi.encodeWithSelector(UINT256_BINOP_ERROR_SELECTOR, errorCode, a, b);
} }

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

@ -51,11 +51,7 @@ library LibBytesV06 {
/// @param dest memory address to copy bytes to. /// @param dest memory address to copy bytes to.
/// @param source memory address to copy bytes from. /// @param source memory address to copy bytes from.
/// @param length number of bytes to copy. /// @param length number of bytes to copy.
function memCopy( function memCopy(uint256 dest, uint256 source, uint256 length) internal pure {
uint256 dest,
uint256 source,
uint256 length
) internal pure {
if (length < 32) { if (length < 32) {
// Handle a partial word by reading destination and masking // Handle a partial word by reading destination and masking
// off the bits we are interested in. // off the bits we are interested in.
@ -162,11 +158,7 @@ library LibBytesV06 {
/// @param from The starting index for the slice (inclusive). /// @param from The starting index for the slice (inclusive).
/// @param to The final index for the slice (exclusive). /// @param to The final index for the slice (exclusive).
/// @return result The slice containing bytes at indices [from, to) /// @return result The slice containing bytes at indices [from, to)
function slice( function slice(bytes memory b, uint256 from, uint256 to) internal pure returns (bytes memory result) {
bytes memory b,
uint256 from,
uint256 to
) internal pure returns (bytes memory result) {
// Ensure that the from and to positions are valid positions for a slice within // Ensure that the from and to positions are valid positions for a slice within
// the byte array that is being used. // the byte array that is being used.
if (from > to) { if (from > to) {
@ -201,11 +193,7 @@ library LibBytesV06 {
/// @param from The starting index for the slice (inclusive). /// @param from The starting index for the slice (inclusive).
/// @param to The final index for the slice (exclusive). /// @param to The final index for the slice (exclusive).
/// @return result The slice containing bytes at indices [from, to) /// @return result The slice containing bytes at indices [from, to)
function sliceDestructive( function sliceDestructive(bytes memory b, uint256 from, uint256 to) internal pure returns (bytes memory result) {
bytes memory b,
uint256 from,
uint256 to
) internal pure returns (bytes memory result) {
// Ensure that the from and to positions are valid positions for a slice within // Ensure that the from and to positions are valid positions for a slice within
// the byte array that is being used. // the byte array that is being used.
if (from > to) { if (from > to) {
@ -305,11 +293,7 @@ library LibBytesV06 {
/// @param b Byte array to insert address into. /// @param b Byte array to insert address into.
/// @param index Index in byte array of address. /// @param index Index in byte array of address.
/// @param input Address to put into byte array. /// @param input Address to put into byte array.
function writeAddress( function writeAddress(bytes memory b, uint256 index, address input) internal pure {
bytes memory b,
uint256 index,
address input
) internal pure {
if (b.length < index + 20) { if (b.length < index + 20) {
LibRichErrorsV06.rrevert( LibRichErrorsV06.rrevert(
LibBytesRichErrorsV06.InvalidByteOperationError( LibBytesRichErrorsV06.InvalidByteOperationError(
@ -378,11 +362,7 @@ library LibBytesV06 {
/// @param b Byte array to insert <input> into. /// @param b Byte array to insert <input> into.
/// @param index Index in byte array of <input>. /// @param index Index in byte array of <input>.
/// @param input bytes32 to put into byte array. /// @param input bytes32 to put into byte array.
function writeBytes32( function writeBytes32(bytes memory b, uint256 index, bytes32 input) internal pure {
bytes memory b,
uint256 index,
bytes32 input
) internal pure {
if (b.length < index + 32) { if (b.length < index + 32) {
LibRichErrorsV06.rrevert( LibRichErrorsV06.rrevert(
LibBytesRichErrorsV06.InvalidByteOperationError( LibBytesRichErrorsV06.InvalidByteOperationError(
@ -415,11 +395,7 @@ library LibBytesV06 {
/// @param b Byte array to insert <input> into. /// @param b Byte array to insert <input> into.
/// @param index Index in byte array of <input>. /// @param index Index in byte array of <input>.
/// @param input uint256 to put into byte array. /// @param input uint256 to put into byte array.
function writeUint256( function writeUint256(bytes memory b, uint256 index, uint256 input) internal pure {
bytes memory b,
uint256 index,
uint256 input
) internal pure {
writeBytes32(b, index, bytes32(input)); writeBytes32(b, index, bytes32(input));
} }

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

@ -40,11 +40,7 @@ library LibSafeMathRichErrorsV06 {
VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT128 VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT128
} }
function Uint256BinOpError( function Uint256BinOpError(BinOpErrorCodes errorCode, uint256 a, uint256 b) internal pure returns (bytes memory) {
BinOpErrorCodes errorCode,
uint256 a,
uint256 b
) internal pure returns (bytes memory) {
return abi.encodeWithSelector(UINT256_BINOP_ERROR_SELECTOR, errorCode, a, b); return abi.encodeWithSelector(UINT256_BINOP_ERROR_SELECTOR, errorCode, a, b);
} }

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

@ -30,11 +30,10 @@ contract TestLibAddressArray {
/// @param addressArray Array of addresses. /// @param addressArray Array of addresses.
/// @param addressToAppend Address to append. /// @param addressToAppend Address to append.
/// @return Array of addresses: [... addressArray, addressToAppend] /// @return Array of addresses: [... addressArray, addressToAppend]
function publicAppend(address[] memory addressArray, address addressToAppend) function publicAppend(
public address[] memory addressArray,
pure address addressToAppend
returns (address[] memory) ) public pure returns (address[] memory) {
{
return addressArray.append(addressToAppend); return addressArray.append(addressToAppend);
} }
@ -52,15 +51,7 @@ contract TestLibAddressArray {
address[] memory addressArray, address[] memory addressArray,
int256 freeMemOffset, int256 freeMemOffset,
address addressToAppend address addressToAppend
) ) public pure returns (address[] memory result, uint256 oldArrayMemStart, uint256 newArrayMemStart) {
public
pure
returns (
address[] memory result,
uint256 oldArrayMemStart,
uint256 newArrayMemStart
)
{
assembly { assembly {
// Remember the original memory address of the array. // Remember the original memory address of the array.
oldArrayMemStart := addressArray oldArrayMemStart := addressArray
@ -89,11 +80,10 @@ contract TestLibAddressArray {
/// @param addressArray Array of addresses. /// @param addressArray Array of addresses.
/// @param target Address to search for in array. /// @param target Address to search for in array.
/// @return Existence and index of the target in the array. /// @return Existence and index of the target in the array.
function publicIndexOf(address[] memory addressArray, address target) function publicIndexOf(
public address[] memory addressArray,
pure address target
returns (bool success, uint256 index) ) public pure returns (bool success, uint256 index) {
{
(success, index) = addressArray.indexOf(target); (success, index) = addressArray.indexOf(target);
} }
} }

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

@ -60,11 +60,7 @@ contract TestLibBytes {
/// @param b Byte array to insert address into. /// @param b Byte array to insert address into.
/// @param index Index in byte array of address. /// @param index Index in byte array of address.
/// @param input Address to put into byte array. /// @param input Address to put into byte array.
function publicWriteAddress( function publicWriteAddress(bytes memory b, uint256 index, address input) public pure returns (bytes memory) {
bytes memory b,
uint256 index,
address input
) public pure returns (bytes memory) {
b.writeAddress(index, input); b.writeAddress(index, input);
return b; return b;
} }
@ -82,11 +78,7 @@ contract TestLibBytes {
/// @param b Byte array to insert <input> into. /// @param b Byte array to insert <input> into.
/// @param index Index in byte array of <input>. /// @param index Index in byte array of <input>.
/// @param input bytes32 to put into byte array. /// @param input bytes32 to put into byte array.
function publicWriteBytes32( function publicWriteBytes32(bytes memory b, uint256 index, bytes32 input) public pure returns (bytes memory) {
bytes memory b,
uint256 index,
bytes32 input
) public pure returns (bytes memory) {
b.writeBytes32(index, input); b.writeBytes32(index, input);
return b; return b;
} }
@ -104,11 +96,7 @@ contract TestLibBytes {
/// @param b Byte array to insert <input> into. /// @param b Byte array to insert <input> into.
/// @param index Index in byte array of <input>. /// @param index Index in byte array of <input>.
/// @param input uint256 to put into byte array. /// @param input uint256 to put into byte array.
function publicWriteUint256( function publicWriteUint256(bytes memory b, uint256 index, uint256 input) public pure returns (bytes memory) {
bytes memory b,
uint256 index,
uint256 input
) public pure returns (bytes memory) {
b.writeUint256(index, input); b.writeUint256(index, input);
return b; return b;
} }

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

@ -20,11 +20,10 @@
pragma solidity ^0.6.5; pragma solidity ^0.6.5;
library LibMetaTransactionsRichErrors { library LibMetaTransactionsRichErrors {
function InvalidMetaTransactionsArrayLengthsError(uint256 mtxCount, uint256 signatureCount) function InvalidMetaTransactionsArrayLengthsError(
internal uint256 mtxCount,
pure uint256 signatureCount
returns (bytes memory) ) internal pure returns (bytes memory) {
{
return return
abi.encodeWithSelector( abi.encodeWithSelector(
bytes4(keccak256("InvalidMetaTransactionsArrayLengthsError(uint256,uint256)")), bytes4(keccak256("InvalidMetaTransactionsArrayLengthsError(uint256,uint256)")),
@ -33,11 +32,10 @@ library LibMetaTransactionsRichErrors {
); );
} }
function MetaTransactionUnsupportedFunctionError(bytes32 mtxHash, bytes4 selector) function MetaTransactionUnsupportedFunctionError(
internal bytes32 mtxHash,
pure bytes4 selector
returns (bytes memory) ) internal pure returns (bytes memory) {
{
return return
abi.encodeWithSelector( abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionUnsupportedFunctionError(bytes32,bytes4)")), bytes4(keccak256("MetaTransactionUnsupportedFunctionError(bytes32,bytes4)")),
@ -118,11 +116,10 @@ library LibMetaTransactionsRichErrors {
); );
} }
function MetaTransactionAlreadyExecutedError(bytes32 mtxHash, uint256 executedBlockNumber) function MetaTransactionAlreadyExecutedError(
internal bytes32 mtxHash,
pure uint256 executedBlockNumber
returns (bytes memory) ) internal pure returns (bytes memory) {
{
return return
abi.encodeWithSelector( abi.encodeWithSelector(
bytes4(keccak256("MetaTransactionAlreadyExecutedError(bytes32,uint256)")), bytes4(keccak256("MetaTransactionAlreadyExecutedError(bytes32,uint256)")),

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

@ -54,11 +54,10 @@ library LibNFTOrdersRichErrors {
); );
} }
function SellOrderFeesExceedSpreadError(uint256 sellOrderFees, uint256 spread) function SellOrderFeesExceedSpreadError(
internal uint256 sellOrderFees,
pure uint256 spread
returns (bytes memory) ) internal pure returns (bytes memory) {
{
return return
abi.encodeWithSelector( abi.encodeWithSelector(
bytes4(keccak256("SellOrderFeesExceedSpreadError(uint256,uint256)")), bytes4(keccak256("SellOrderFeesExceedSpreadError(uint256,uint256)")),
@ -112,11 +111,10 @@ library LibNFTOrdersRichErrors {
); );
} }
function ExceedsRemainingOrderAmount(uint128 remainingOrderAmount, uint128 fillAmount) function ExceedsRemainingOrderAmount(
internal uint128 remainingOrderAmount,
pure uint128 fillAmount
returns (bytes memory) ) internal pure returns (bytes memory) {
{
return return
abi.encodeWithSelector( abi.encodeWithSelector(
bytes4(keccak256("ExceedsRemainingOrderAmount(uint128,uint128)")), bytes4(keccak256("ExceedsRemainingOrderAmount(uint128,uint128)")),

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

@ -45,11 +45,10 @@ library LibSignatureRichErrors {
); );
} }
function SignatureValidationError(SignatureValidationErrorCodes code, bytes32 hash) function SignatureValidationError(
internal SignatureValidationErrorCodes code,
pure bytes32 hash
returns (bytes memory) ) 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);
} }
} }

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

@ -43,11 +43,10 @@ library LibTransformERC20RichErrors {
); );
} }
function NegativeTransformERC20OutputError(address outputToken, uint256 outputTokenLostAmount) function NegativeTransformERC20OutputError(
internal address outputToken,
pure uint256 outputTokenLostAmount
returns (bytes memory) ) internal pure returns (bytes memory) {
{
return return
abi.encodeWithSelector( abi.encodeWithSelector(
bytes4(keccak256("NegativeTransformERC20OutputError(address,uint256)")), bytes4(keccak256("NegativeTransformERC20OutputError(address,uint256)")),
@ -77,11 +76,10 @@ library LibTransformERC20RichErrors {
abi.encodeWithSelector(bytes4(keccak256("OnlyCallableByDeployerError(address,address)")), caller, deployer); abi.encodeWithSelector(bytes4(keccak256("OnlyCallableByDeployerError(address,address)")), caller, deployer);
} }
function InvalidExecutionContextError(address actualContext, address expectedContext) function InvalidExecutionContextError(
internal address actualContext,
pure address expectedContext
returns (bytes memory) ) internal pure returns (bytes memory) {
{
return return
abi.encodeWithSelector( abi.encodeWithSelector(
bytes4(keccak256("InvalidExecutionContextError(address,address)")), bytes4(keccak256("InvalidExecutionContextError(address,address)")),
@ -95,11 +93,10 @@ library LibTransformERC20RichErrors {
INVALID_ARRAY_LENGTH INVALID_ARRAY_LENGTH
} }
function InvalidTransformDataError(InvalidTransformDataErrorCode errorCode, bytes memory transformData) function InvalidTransformDataError(
internal InvalidTransformDataErrorCode errorCode,
pure bytes memory transformData
returns (bytes memory) ) internal pure returns (bytes memory) {
{
return return
abi.encodeWithSelector( abi.encodeWithSelector(
bytes4(keccak256("InvalidTransformDataError(uint8,bytes)")), bytes4(keccak256("InvalidTransformDataError(uint8,bytes)")),
@ -138,11 +135,10 @@ library LibTransformERC20RichErrors {
); );
} }
function InsufficientTakerTokenError(uint256 tokenBalance, uint256 tokensNeeded) function InsufficientTakerTokenError(
internal uint256 tokenBalance,
pure uint256 tokensNeeded
returns (bytes memory) ) internal pure returns (bytes memory) {
{
return return
abi.encodeWithSelector( abi.encodeWithSelector(
bytes4(keccak256("InsufficientTakerTokenError(uint256,uint256)")), bytes4(keccak256("InsufficientTakerTokenError(uint256,uint256)")),

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

@ -38,11 +38,7 @@ contract FeeCollector is AuthorizableV06 {
/// @param weth The WETH contract. /// @param weth The WETH contract.
/// @param staking The staking contract. /// @param staking The staking contract.
/// @param poolId The pool ID this contract is collecting fees for. /// @param poolId The pool ID this contract is collecting fees for.
function initialize( function initialize(IEtherTokenV06 weth, IStaking staking, bytes32 poolId) external onlyAuthorized {
IEtherTokenV06 weth,
IStaking staking,
bytes32 poolId
) external onlyAuthorized {
weth.approve(address(staking), type(uint256).max); weth.approve(address(staking), type(uint256).max);
staking.joinStakingPoolAsMaker(poolId); staking.joinStakingPoolAsMaker(poolId);
} }

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

@ -69,13 +69,10 @@ contract FlashWallet is IFlashWallet {
/// @param target The call target. /// @param target The call target.
/// @param callData The call data. /// @param callData The call data.
/// @return resultData The data returned by the call. /// @return resultData The data returned by the call.
function executeDelegateCall(address payable target, bytes calldata callData) function executeDelegateCall(
external address payable target,
payable bytes calldata callData
override ) external payable override onlyOwner returns (bytes memory resultData) {
onlyOwner
returns (bytes memory resultData)
{
bool success; bool success;
(success, resultData) = target.delegatecall(callData); (success, resultData) = target.delegatecall(callData);
if (!success) { if (!success) {

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

@ -40,10 +40,10 @@ interface IFlashWallet {
/// @param target The call target. /// @param target The call target.
/// @param callData The call data. /// @param callData The call data.
/// @return resultData The data returned by the call. /// @return resultData The data returned by the call.
function executeDelegateCall(address payable target, bytes calldata callData) function executeDelegateCall(
external address payable target,
payable bytes calldata callData
returns (bytes memory resultData); ) external payable returns (bytes memory resultData);
/// @dev Allows the puppet to receive ETH. /// @dev Allows the puppet to receive ETH.
receive() external payable; receive() external payable;

25
contracts/zero-ex/contracts/src/features/MetaTransactionsFeature.sol
View File

@ -131,7 +131,10 @@ contract MetaTransactionsFeature is
/// @param mtx The meta-transaction. /// @param mtx The meta-transaction.
/// @param signature The signature by `mtx.signer`. /// @param signature The signature by `mtx.signer`.
/// @return returnResult The ABI-encoded result of the underlying call. /// @return returnResult The ABI-encoded result of the underlying call.
function executeMetaTransaction(MetaTransactionData memory mtx, LibSignature.Signature memory signature) function executeMetaTransaction(
MetaTransactionData memory mtx,
LibSignature.Signature memory signature
)
public public
payable payable
override override
@ -153,7 +156,10 @@ contract MetaTransactionsFeature is
/// @param mtxs The meta-transactions. /// @param mtxs The meta-transactions.
/// @param signatures The signature by each respective `mtx.signer`. /// @param signatures The signature by each respective `mtx.signer`.
/// @return returnResults The ABI-encoded results of the underlying calls. /// @return returnResults The ABI-encoded results of the underlying calls.
function batchExecuteMetaTransactions(MetaTransactionData[] memory mtxs, LibSignature.Signature[] memory signatures) function batchExecuteMetaTransactions(
MetaTransactionData[] memory mtxs,
LibSignature.Signature[] memory signatures
)
public public
payable payable
override override
@ -182,12 +188,9 @@ contract MetaTransactionsFeature is
/// @dev Get the block at which a meta-transaction has been executed. /// @dev Get the block at which a meta-transaction has been executed.
/// @param mtx The meta-transaction. /// @param mtx The meta-transaction.
/// @return blockNumber The block height when the meta-transactioin was executed. /// @return blockNumber The block height when the meta-transactioin was executed.
function getMetaTransactionExecutedBlock(MetaTransactionData memory mtx) function getMetaTransactionExecutedBlock(
public MetaTransactionData memory mtx
view ) public view override returns (uint256 blockNumber) {
override
returns (uint256 blockNumber)
{
return getMetaTransactionHashExecutedBlock(getMetaTransactionHash(mtx)); return getMetaTransactionHashExecutedBlock(getMetaTransactionHash(mtx));
} }
@ -459,11 +462,7 @@ contract MetaTransactionsFeature is
/// @dev Make an arbitrary internal, meta-transaction call. /// @dev Make an arbitrary internal, meta-transaction call.
/// Warning: Do not let unadulterated `callData` into this function. /// Warning: Do not let unadulterated `callData` into this function.
function _callSelf( function _callSelf(bytes32 hash, bytes memory callData, uint256 value) private returns (bytes memory returnResult) {
bytes32 hash,
bytes memory callData,
uint256 value
) private returns (bytes memory returnResult) {
bool success; bool success;
(success, returnResult) = address(this).call{value: value}(callData); (success, returnResult) = address(this).call{value: value}(callData);
if (!success) { if (!success) {

29
contracts/zero-ex/contracts/src/features/OtcOrdersFeature.sol
View File

@ -147,12 +147,10 @@ contract OtcOrdersFeature is IFeature, IOtcOrdersFeature, FixinCommon, FixinEIP7
/// @param makerSignature The order signature from the maker. /// @param makerSignature The order signature from the maker.
/// @return takerTokenFilledAmount How much taker token was filled. /// @return takerTokenFilledAmount How much taker token was filled.
/// @return makerTokenFilledAmount How much maker token was filled. /// @return makerTokenFilledAmount How much maker token was filled.
function fillOtcOrderWithEth(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature) function fillOtcOrderWithEth(
public LibNativeOrder.OtcOrder memory order,
payable LibSignature.Signature memory makerSignature
override ) public payable override returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount) {
returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount)
{
if (order.takerToken == WETH) { if (order.takerToken == WETH) {
// Wrap ETH // Wrap ETH
WETH.deposit{value: msg.value}(); WETH.deposit{value: msg.value}();
@ -425,12 +423,9 @@ contract OtcOrdersFeature is IFeature, IOtcOrdersFeature, FixinCommon, FixinEIP7
/// @dev Get the order info for an OTC order. /// @dev Get the order info for an OTC order.
/// @param order The OTC order. /// @param order The OTC order.
/// @return orderInfo Info about the order. /// @return orderInfo Info about the order.
function getOtcOrderInfo(LibNativeOrder.OtcOrder memory order) function getOtcOrderInfo(
public LibNativeOrder.OtcOrder memory order
view ) public view override returns (LibNativeOrder.OtcOrderInfo memory orderInfo) {
override
returns (LibNativeOrder.OtcOrderInfo memory orderInfo)
{
// compute order hash. // compute order hash.
orderInfo.orderHash = getOtcOrderHash(order); orderInfo.orderHash = getOtcOrderHash(order);
@ -470,12 +465,10 @@ contract OtcOrdersFeature is IFeature, IOtcOrdersFeature, FixinCommon, FixinEIP7
/// @param txOrigin The address. /// @param txOrigin The address.
/// @param nonceBucket The nonce bucket index. /// @param nonceBucket The nonce bucket index.
/// @return lastNonce The last nonce value used. /// @return lastNonce The last nonce value used.
function lastOtcTxOriginNonce(address txOrigin, uint64 nonceBucket) function lastOtcTxOriginNonce(
public address txOrigin,
view uint64 nonceBucket
override ) public view override returns (uint128 lastNonce) {
returns (uint128 lastNonce)
{
LibOtcOrdersStorage.Storage storage stor = LibOtcOrdersStorage.getStorage(); LibOtcOrdersStorage.Storage storage stor = LibOtcOrdersStorage.getStorage();
return stor.txOriginNonces[txOrigin][nonceBucket]; return stor.txOriginNonces[txOrigin][nonceBucket];
} }

6
contracts/zero-ex/contracts/src/features/OwnableFeature.sol
View File

@ -77,11 +77,7 @@ contract OwnableFeature is IFeature, IOwnableFeature, FixinCommon {
/// @param target The migrator contract address. /// @param target The migrator contract address.
/// @param data The call data. /// @param data The call data.
/// @param newOwner The address of the new owner. /// @param newOwner The address of the new owner.
function migrate( function migrate(address target, bytes calldata data, address newOwner) external override onlyOwner {
address target,
bytes calldata data,
address newOwner
) external override onlyOwner {
if (newOwner == address(0)) { if (newOwner == address(0)) {
LibOwnableRichErrors.TransferOwnerToZeroError().rrevert(); LibOwnableRichErrors.TransferOwnerToZeroError().rrevert();
} }

2
contracts/zero-ex/contracts/src/features/PancakeSwapFeature.sol
View File

@ -85,7 +85,7 @@ contract PancakeSwapFeature is IFeature, IPancakeSwapFeature, FixinCommon {
// BNB pseudo-token address. // BNB pseudo-token address.
uint256 private constant ETH_TOKEN_ADDRESS_32 = 0x000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee; uint256 private constant ETH_TOKEN_ADDRESS_32 = 0x000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee;
// Maximum token quantity that can be swapped against the PancakeSwapPair contract. // Maximum token quantity that can be swapped against the PancakeSwapPair contract.
uint256 private constant MAX_SWAP_AMOUNT = 2**112; uint256 private constant MAX_SWAP_AMOUNT = 2 ** 112;
// bytes4(keccak256("executeCall(address,bytes)")) // bytes4(keccak256("executeCall(address,bytes)"))
uint256 private constant ALLOWANCE_TARGET_EXECUTE_CALL_SELECTOR_32 = uint256 private constant ALLOWANCE_TARGET_EXECUTE_CALL_SELECTOR_32 =

11
contracts/zero-ex/contracts/src/features/TransformERC20Feature.sol
View File

@ -153,14 +153,9 @@ contract TransformERC20Feature is IFeature, ITransformERC20Feature, FixinCommon,
/// @dev Internal version of `transformERC20()`. Only callable from within. /// @dev Internal version of `transformERC20()`. Only callable from within.
/// @param args A `TransformERC20Args` struct. /// @param args A `TransformERC20Args` struct.
/// @return outputTokenAmount The amount of `outputToken` received by the taker. /// @return outputTokenAmount The amount of `outputToken` received by the taker.
function _transformERC20(TransformERC20Args memory args) function _transformERC20(
public TransformERC20Args memory args
payable ) public payable virtual override onlySelf returns (uint256 outputTokenAmount) {
virtual
override
onlySelf
returns (uint256 outputTokenAmount)
{
return _transformERC20Private(args); return _transformERC20Private(args);
} }

2
contracts/zero-ex/contracts/src/features/UniswapFeature.sol
View File

@ -51,7 +51,7 @@ contract UniswapFeature is IFeature, IUniswapFeature, FixinCommon {
// ETH pseudo-token address. // ETH pseudo-token address.
uint256 private constant ETH_TOKEN_ADDRESS_32 = 0x000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee; uint256 private constant ETH_TOKEN_ADDRESS_32 = 0x000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee;
// Maximum token quantity that can be swapped against the UniswapV2Pair contract. // Maximum token quantity that can be swapped against the UniswapV2Pair contract.
uint256 private constant MAX_SWAP_AMOUNT = 2**112; uint256 private constant MAX_SWAP_AMOUNT = 2 ** 112;
// bytes4(keccak256("executeCall(address,bytes)")) // bytes4(keccak256("executeCall(address,bytes)"))
uint256 private constant ALLOWANCE_TARGET_EXECUTE_CALL_SELECTOR_32 = uint256 private constant ALLOWANCE_TARGET_EXECUTE_CALL_SELECTOR_32 =

31
contracts/zero-ex/contracts/src/features/UniswapV3Feature.sol
View File

@ -62,11 +62,7 @@ contract UniswapV3Feature is IFeature, IUniswapV3Feature, FixinCommon, FixinToke
/// @param weth The WETH contract. /// @param weth The WETH contract.
/// @param uniFactory The UniswapV3 factory contract. /// @param uniFactory The UniswapV3 factory contract.
/// @param poolInitCodeHash The UniswapV3 pool init code hash. /// @param poolInitCodeHash The UniswapV3 pool init code hash.
constructor( constructor(IEtherTokenV06 weth, address uniFactory, bytes32 poolInitCodeHash) public {
IEtherTokenV06 weth,
address uniFactory,
bytes32 poolInitCodeHash
) public {
WETH = weth; WETH = weth;
UNI_FF_FACTORY_ADDRESS = bytes32((uint256(0xff) << 248) | (uint256(uniFactory) << 88)); UNI_FF_FACTORY_ADDRESS = bytes32((uint256(0xff) << 248) | (uint256(uniFactory) << 88));
UNI_POOL_INIT_CODE_HASH = poolInitCodeHash; UNI_POOL_INIT_CODE_HASH = poolInitCodeHash;
@ -171,11 +167,7 @@ contract UniswapV3Feature is IFeature, IUniswapV3Feature, FixinCommon, FixinToke
/// @param amount1Delta Token1 amount owed. /// @param amount1Delta Token1 amount owed.
/// @param data Arbitrary data forwarded from swap() caller. An ABI-encoded /// @param data Arbitrary data forwarded from swap() caller. An ABI-encoded
/// struct of: inputToken, outputToken, fee, payer /// struct of: inputToken, outputToken, fee, payer
function uniswapV3SwapCallback( function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external override {
int256 amount0Delta,
int256 amount1Delta,
bytes calldata data
) external override {
IERC20TokenV06 token0; IERC20TokenV06 token0;
IERC20TokenV06 token1; IERC20TokenV06 token1;
address payer; address payer;
@ -261,12 +253,7 @@ contract UniswapV3Feature is IFeature, IUniswapV3Feature, FixinCommon, FixinToke
// Pay tokens from `payer` to `to`, using `transferFrom()` if // Pay tokens from `payer` to `to`, using `transferFrom()` if
// `payer` != this contract. // `payer` != this contract.
function _pay( function _pay(IERC20TokenV06 token, address payer, address to, uint256 amount) private {
IERC20TokenV06 token,
address payer,
address to,
uint256 amount
) private {
if (payer != address(this)) { if (payer != address(this)) {
_transferERC20TokensFrom(token, payer, to, amount); _transferERC20TokensFrom(token, payer, to, amount);
} else { } else {
@ -330,15 +317,9 @@ contract UniswapV3Feature is IFeature, IUniswapV3Feature, FixinCommon, FixinToke
} }
// Return the first input token, output token, and fee of an encoded uniswap path. // Return the first input token, output token, and fee of an encoded uniswap path.
function _decodeFirstPoolInfoFromPath(bytes memory encodedPath) function _decodeFirstPoolInfoFromPath(
private bytes memory encodedPath
pure ) private pure returns (IERC20TokenV06 inputToken, uint24 fee, IERC20TokenV06 outputToken) {
returns (
IERC20TokenV06 inputToken,
uint24 fee,
IERC20TokenV06 outputToken
)
{
require(encodedPath.length >= SINGLE_HOP_PATH_SIZE, "UniswapV3Feature/BAD_PATH_ENCODING"); require(encodedPath.length >= SINGLE_HOP_PATH_SIZE, "UniswapV3Feature/BAD_PATH_ENCODING");
assembly { assembly {
let p := add(encodedPath, 32) let p := add(encodedPath, 32)

14
contracts/zero-ex/contracts/src/features/interfaces/IERC1155OrdersFeature.sol
View File

@ -199,17 +199,17 @@ interface IERC1155OrdersFeature {
/// an ERC1155 asset. /// an ERC1155 asset.
/// @param order The ERC1155 order. /// @param order The ERC1155 order.
/// @param erc1155TokenId The ID of the ERC1155 asset. /// @param erc1155TokenId The ID of the ERC1155 asset.
function validateERC1155OrderProperties(LibNFTOrder.ERC1155Order calldata order, uint256 erc1155TokenId) function validateERC1155OrderProperties(
external LibNFTOrder.ERC1155Order calldata order,
view; uint256 erc1155TokenId
) external view;
/// @dev Get the order info for an ERC1155 order. /// @dev Get the order info for an ERC1155 order.
/// @param order The ERC1155 order. /// @param order The ERC1155 order.
/// @return orderInfo Infor about the order. /// @return orderInfo Infor about the order.
function getERC1155OrderInfo(LibNFTOrder.ERC1155Order calldata order) function getERC1155OrderInfo(
external LibNFTOrder.ERC1155Order calldata order
view ) external view returns (LibNFTOrder.OrderInfo memory orderInfo);
returns (LibNFTOrder.OrderInfo memory orderInfo);
/// @dev Get the EIP-712 hash of an ERC1155 order. /// @dev Get the EIP-712 hash of an ERC1155 order.
/// @param order The ERC1155 order. /// @param order The ERC1155 order.

7
contracts/zero-ex/contracts/src/features/interfaces/IERC721OrdersFeature.sol
View File

@ -230,10 +230,9 @@ interface IERC721OrdersFeature {
/// @dev Get the current status of an ERC721 order. /// @dev Get the current status of an ERC721 order.
/// @param order The ERC721 order. /// @param order The ERC721 order.
/// @return status The status of the order. /// @return status The status of the order.
function getERC721OrderStatus(LibNFTOrder.ERC721Order calldata order) function getERC721OrderStatus(
external LibNFTOrder.ERC721Order calldata order
view ) external view returns (LibNFTOrder.OrderStatus status);
returns (LibNFTOrder.OrderStatus status);
/// @dev Get the EIP-712 hash of an ERC721 order. /// @dev Get the EIP-712 hash of an ERC721 order.
/// @param order The ERC721 order. /// @param order The ERC721 order.

6
contracts/zero-ex/contracts/src/features/interfaces/IFundRecoveryFeature.sol
View File

@ -24,9 +24,5 @@ interface IFundRecoveryFeature {
/// @param erc20 ERC20 Token Address. /// @param erc20 ERC20 Token Address.
/// @param amountOut Amount of tokens to withdraw. /// @param amountOut Amount of tokens to withdraw.
/// @param recipientWallet Recipient wallet address. /// @param recipientWallet Recipient wallet address.
function transferTrappedTokensTo( function transferTrappedTokensTo(IERC20TokenV06 erc20, uint256 amountOut, address payable recipientWallet) external;
IERC20TokenV06 erc20,
uint256 amountOut,
address payable recipientWallet
) external;
} }

15
contracts/zero-ex/contracts/src/features/interfaces/IMetaTransactionsFeature.sol
View File

@ -61,10 +61,10 @@ interface IMetaTransactionsFeature {
/// @param mtx The meta-transaction. /// @param mtx The meta-transaction.
/// @param signature The signature by `mtx.signer`. /// @param signature The signature by `mtx.signer`.
/// @return returnResult The ABI-encoded result of the underlying call. /// @return returnResult The ABI-encoded result of the underlying call.
function executeMetaTransaction(MetaTransactionData calldata mtx, LibSignature.Signature calldata signature) function executeMetaTransaction(
external MetaTransactionData calldata mtx,
payable LibSignature.Signature calldata signature
returns (bytes memory returnResult); ) external payable returns (bytes memory returnResult);
/// @dev Execute multiple meta-transactions. /// @dev Execute multiple meta-transactions.
/// @param mtxs The meta-transactions. /// @param mtxs The meta-transactions.
@ -78,10 +78,9 @@ interface IMetaTransactionsFeature {
/// @dev Get the block at which a meta-transaction has been executed. /// @dev Get the block at which a meta-transaction has been executed.
/// @param mtx The meta-transaction. /// @param mtx The meta-transaction.
/// @return blockNumber The block height when the meta-transactioin was executed. /// @return blockNumber The block height when the meta-transactioin was executed.
function getMetaTransactionExecutedBlock(MetaTransactionData calldata mtx) function getMetaTransactionExecutedBlock(
external MetaTransactionData calldata mtx
view ) external view returns (uint256 blockNumber);
returns (uint256 blockNumber);
/// @dev Get the block at which a meta-transaction hash has been executed. /// @dev Get the block at which a meta-transaction hash has been executed.
/// @param mtxHash The meta-transaction hash. /// @param mtxHash The meta-transaction hash.

31
contracts/zero-ex/contracts/src/features/interfaces/INativeOrdersFeature.sol
View File

@ -155,11 +155,7 @@ interface INativeOrdersFeature is INativeOrdersEvents {
/// @param makerToken The maker token. /// @param makerToken The maker token.
/// @param takerToken The taker token. /// @param takerToken The taker token.
/// @param minValidSalt The new minimum valid salt. /// @param minValidSalt The new minimum valid salt.
function cancelPairLimitOrders( function cancelPairLimitOrders(IERC20TokenV06 makerToken, IERC20TokenV06 takerToken, uint256 minValidSalt) external;
IERC20TokenV06 makerToken,
IERC20TokenV06 takerToken,
uint256 minValidSalt
) external;
/// @dev Cancel all limit orders for a given maker and pair with a salt less /// @dev Cancel all limit orders for a given maker and pair with a salt less
/// than the value provided. The caller must be a signer registered to the maker. /// than the value provided. The caller must be a signer registered to the maker.
@ -211,11 +207,7 @@ interface INativeOrdersFeature is INativeOrdersEvents {
/// @param makerToken The maker token. /// @param makerToken The maker token.
/// @param takerToken The taker token. /// @param takerToken The taker token.
/// @param minValidSalt The new minimum valid salt. /// @param minValidSalt The new minimum valid salt.
function cancelPairRfqOrders( function cancelPairRfqOrders(IERC20TokenV06 makerToken, IERC20TokenV06 takerToken, uint256 minValidSalt) external;
IERC20TokenV06 makerToken,
IERC20TokenV06 takerToken,
uint256 minValidSalt
) external;
/// @dev Cancel all RFQ orders for a given maker and pair with a salt less /// @dev Cancel all RFQ orders for a given maker and pair with a salt less
/// than the value provided. The caller must be a signer registered to the maker. /// than the value provided. The caller must be a signer registered to the maker.
@ -263,18 +255,16 @@ interface INativeOrdersFeature is INativeOrdersEvents {
/// @dev Get the order info for a limit order. /// @dev Get the order info for a limit order.
/// @param order The limit order. /// @param order The limit order.
/// @return orderInfo Info about the order. /// @return orderInfo Info about the order.
function getLimitOrderInfo(LibNativeOrder.LimitOrder calldata order) function getLimitOrderInfo(
external LibNativeOrder.LimitOrder calldata order
view ) external view returns (LibNativeOrder.OrderInfo memory orderInfo);
returns (LibNativeOrder.OrderInfo memory orderInfo);
/// @dev Get the order info for an RFQ order. /// @dev Get the order info for an RFQ order.
/// @param order The RFQ order. /// @param order The RFQ order.
/// @return orderInfo Info about the order. /// @return orderInfo Info about the order.
function getRfqOrderInfo(LibNativeOrder.RfqOrder calldata order) function getRfqOrderInfo(
external LibNativeOrder.RfqOrder calldata order
view ) external view returns (LibNativeOrder.OrderInfo memory orderInfo);
returns (LibNativeOrder.OrderInfo memory orderInfo);
/// @dev Get the canonical hash of a limit order. /// @dev Get the canonical hash of a limit order.
/// @param order The limit order. /// @param order The limit order.
@ -319,7 +309,10 @@ interface INativeOrdersFeature is INativeOrdersEvents {
/// @return actualFillableTakerTokenAmount How much of the order is fillable /// @return actualFillableTakerTokenAmount How much of the order is fillable
/// based on maker funds, in taker tokens. /// based on maker funds, in taker tokens.
/// @return isSignatureValid Whether the signature is valid. /// @return isSignatureValid Whether the signature is valid.
function getRfqOrderRelevantState(LibNativeOrder.RfqOrder calldata order, LibSignature.Signature calldata signature) function getRfqOrderRelevantState(
LibNativeOrder.RfqOrder calldata order,
LibSignature.Signature calldata signature
)
external external
view view
returns ( returns (

15
contracts/zero-ex/contracts/src/features/interfaces/IOtcOrdersFeature.sol
View File

@ -75,10 +75,10 @@ interface IOtcOrdersFeature {
/// @param makerSignature The order signature from the maker. /// @param makerSignature The order signature from the maker.
/// @return takerTokenFilledAmount How much taker token was filled. /// @return takerTokenFilledAmount How much taker token was filled.
/// @return makerTokenFilledAmount How much maker token was filled. /// @return makerTokenFilledAmount How much maker token was filled.
function fillOtcOrderWithEth(LibNativeOrder.OtcOrder calldata order, LibSignature.Signature calldata makerSignature) function fillOtcOrderWithEth(
external LibNativeOrder.OtcOrder calldata order,
payable LibSignature.Signature calldata makerSignature
returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount); ) external payable returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
/// @dev Fully fill an OTC order. "Meta-transaction" variant, /// @dev Fully fill an OTC order. "Meta-transaction" variant,
/// requires order to be signed by both maker and taker. /// requires order to be signed by both maker and taker.
@ -144,10 +144,9 @@ interface IOtcOrdersFeature {
/// @dev Get the order info for an OTC order. /// @dev Get the order info for an OTC order.
/// @param order The OTC order. /// @param order The OTC order.
/// @return orderInfo Info about the order. /// @return orderInfo Info about the order.
function getOtcOrderInfo(LibNativeOrder.OtcOrder calldata order) function getOtcOrderInfo(
external LibNativeOrder.OtcOrder calldata order
view ) external view returns (LibNativeOrder.OtcOrderInfo memory orderInfo);
returns (LibNativeOrder.OtcOrderInfo memory orderInfo);
/// @dev Get the canonical hash of an OTC order. /// @dev Get the canonical hash of an OTC order.
/// @param order The OTC order. /// @param order The OTC order.

6
contracts/zero-ex/contracts/src/features/interfaces/IOwnableFeature.sol
View File

@ -38,9 +38,5 @@ interface IOwnableFeature is IOwnableV06 {
/// @param target The migrator contract address. /// @param target The migrator contract address.
/// @param newOwner The address of the new owner. /// @param newOwner The address of the new owner.
/// @param data The call data. /// @param data The call data.
function migrate( function migrate(address target, bytes calldata data, address newOwner) external;
address target,
bytes calldata data,
address newOwner
) external;
} }

7
contracts/zero-ex/contracts/src/features/interfaces/ITokenSpenderFeature.sol
View File

@ -30,12 +30,7 @@ interface ITokenSpenderFeature {
/// @param owner The owner of the tokens. /// @param owner The owner of the tokens.
/// @param to The recipient of the tokens. /// @param to The recipient of the tokens.
/// @param amount The amount of `token` to transfer. /// @param amount The amount of `token` to transfer.
function _spendERC20Tokens( function _spendERC20Tokens(IERC20TokenV06 token, address owner, address to, uint256 amount) external;
IERC20TokenV06 token,
address owner,
address to,
uint256 amount
) external;
/// @dev Gets the maximum amount of an ERC20 token `token` that can be /// @dev Gets the maximum amount of an ERC20 token `token` that can be
/// pulled from `owner`. /// pulled from `owner`.

6
contracts/zero-ex/contracts/src/features/interfaces/IUniswapV3Feature.sol
View File

@ -82,9 +82,5 @@ interface IUniswapV3Feature {
/// @param amount1Delta Token1 amount owed. /// @param amount1Delta Token1 amount owed.
/// @param data Arbitrary data forwarded from swap() caller. An ABI-encoded /// @param data Arbitrary data forwarded from swap() caller. An ABI-encoded
/// struct of: inputToken, outputToken, fee, payer /// struct of: inputToken, outputToken, fee, payer
function uniswapV3SwapCallback( function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external;
int256 amount0Delta,
int256 amount1Delta,
bytes calldata data
) external;
} }

10
contracts/zero-ex/contracts/src/features/libs/LibNFTOrder.sol
View File

@ -271,10 +271,7 @@ library LibNFTOrder {
mstore(typeHashPos, _ERC_721_ORDER_TYPEHASH) mstore(typeHashPos, _ERC_721_ORDER_TYPEHASH)
mstore(feesHashPos, feesHash) mstore(feesHashPos, feesHash)
mstore(propertiesHashPos, propertiesHash) mstore(propertiesHashPos, propertiesHash)
structHash := keccak256( structHash := keccak256(typeHashPos, 384 /* 32 * 12 */)
typeHashPos,
384 /* 32 * 12 */
)
mstore(typeHashPos, typeHashMemBefore) mstore(typeHashPos, typeHashMemBefore)
mstore(feesHashPos, feeHashMemBefore) mstore(feesHashPos, feeHashMemBefore)
@ -322,10 +319,7 @@ library LibNFTOrder {
mstore(typeHashPos, _ERC_1155_ORDER_TYPEHASH) mstore(typeHashPos, _ERC_1155_ORDER_TYPEHASH)
mstore(feesHashPos, feesHash) mstore(feesHashPos, feesHash)
mstore(propertiesHashPos, propertiesHash) mstore(propertiesHashPos, propertiesHash)
structHash := keccak256( structHash := keccak256(typeHashPos, 416 /* 32 * 12 */)
typeHashPos,
416 /* 32 * 12 */
)
mstore(typeHashPos, typeHashMemBefore) mstore(typeHashPos, typeHashMemBefore)
mstore(feesHashPos, feesHashMemBefore) mstore(feesHashPos, feesHashMemBefore)

18
contracts/zero-ex/contracts/src/features/multiplex/MultiplexFeature.sol
View File

@ -54,7 +54,7 @@ contract MultiplexFeature is
/// @dev Version of this feature. /// @dev Version of this feature.
uint256 public immutable override FEATURE_VERSION = _encodeVersion(2, 0, 0); uint256 public immutable override FEATURE_VERSION = _encodeVersion(2, 0, 0);
/// @dev The highest bit of a uint256 value. /// @dev The highest bit of a uint256 value.
uint256 private constant HIGH_BIT = 2**255; uint256 private constant HIGH_BIT = 2 ** 255;
/// @dev Mask of the lower 255 bits of a uint256 value. /// @dev Mask of the lower 255 bits of a uint256 value.
uint256 private constant LOWER_255_BITS = HIGH_BIT - 1; uint256 private constant LOWER_255_BITS = HIGH_BIT - 1;
@ -191,10 +191,10 @@ contract MultiplexFeature is
/// @param minBuyAmount The minimum amount of `outputToken` that /// @param minBuyAmount The minimum amount of `outputToken` that
/// must be bought for this function to not revert. /// must be bought for this function to not revert.
/// @return boughtAmount The amount of `outputToken` bought. /// @return boughtAmount The amount of `outputToken` bought.
function _multiplexBatchSell(BatchSellParams memory params, uint256 minBuyAmount) function _multiplexBatchSell(
private BatchSellParams memory params,
returns (uint256 boughtAmount) uint256 minBuyAmount
{ ) private returns (uint256 boughtAmount) {
// Cache the recipient's initial balance of the output token. // Cache the recipient's initial balance of the output token.
uint256 balanceBefore = params.outputToken.balanceOf(params.recipient); uint256 balanceBefore = params.outputToken.balanceOf(params.recipient);
// Execute the batch sell. // Execute the batch sell.
@ -320,10 +320,10 @@ contract MultiplexFeature is
/// @param minBuyAmount The minimum amount of output tokens that /// @param minBuyAmount The minimum amount of output tokens that
/// must be bought for this function to not revert. /// must be bought for this function to not revert.
/// @return boughtAmount The amount of output tokens bought. /// @return boughtAmount The amount of output tokens bought.
function _multiplexMultiHopSell(MultiHopSellParams memory params, uint256 minBuyAmount) function _multiplexMultiHopSell(
private MultiHopSellParams memory params,
returns (uint256 boughtAmount) uint256 minBuyAmount
{ ) private returns (uint256 boughtAmount) {
// There should be one call/hop between every two tokens // There should be one call/hop between every two tokens
// in the path. // in the path.
// tokens[0]––calls[0]––>tokens[1]––...––calls[n-1]––>tokens[n] // tokens[0]––calls[0]––>tokens[1]––...––calls[n-1]––>tokens[n]

7
contracts/zero-ex/contracts/src/features/multiplex/MultiplexUniswapV3.sol
View File

@ -73,9 +73,10 @@ abstract contract MultiplexUniswapV3 is FixinTokenSpender {
} }
} }
function _multiHopSellUniswapV3(IMultiplexFeature.MultiHopSellState memory state, bytes memory wrappedCallData) function _multiHopSellUniswapV3(
internal IMultiplexFeature.MultiHopSellState memory state,
{ bytes memory wrappedCallData
) internal {
bool success; bool success;
bytes memory resultData; bytes memory resultData;
if (state.from == address(this)) { if (state.from == address(this)) {

12
contracts/zero-ex/contracts/src/features/native_orders/NativeOrdersCancellation.sol
View File

@ -85,11 +85,7 @@ abstract contract NativeOrdersCancellation is INativeOrdersEvents, NativeOrdersI
/// @param makerToken The maker token. /// @param makerToken The maker token.
/// @param takerToken The taker token. /// @param takerToken The taker token.
/// @param minValidSalt The new minimum valid salt. /// @param minValidSalt The new minimum valid salt.
function cancelPairLimitOrders( function cancelPairLimitOrders(IERC20TokenV06 makerToken, IERC20TokenV06 takerToken, uint256 minValidSalt) public {
IERC20TokenV06 makerToken,
IERC20TokenV06 takerToken,
uint256 minValidSalt
) public {
_cancelPairLimitOrders(msg.sender, makerToken, takerToken, minValidSalt); _cancelPairLimitOrders(msg.sender, makerToken, takerToken, minValidSalt);
} }
@ -172,11 +168,7 @@ abstract contract NativeOrdersCancellation is INativeOrdersEvents, NativeOrdersI
/// @param makerToken The maker token. /// @param makerToken The maker token.
/// @param takerToken The taker token. /// @param takerToken The taker token.
/// @param minValidSalt The new minimum valid salt. /// @param minValidSalt The new minimum valid salt.
function cancelPairRfqOrders( function cancelPairRfqOrders(IERC20TokenV06 makerToken, IERC20TokenV06 takerToken, uint256 minValidSalt) public {
IERC20TokenV06 makerToken,
IERC20TokenV06 takerToken,
uint256 minValidSalt
) public {
_cancelPairRfqOrders(msg.sender, makerToken, takerToken, minValidSalt); _cancelPairRfqOrders(msg.sender, makerToken, takerToken, minValidSalt);
} }

29
contracts/zero-ex/contracts/src/features/native_orders/NativeOrdersInfo.sol
View File

@ -51,11 +51,9 @@ abstract contract NativeOrdersInfo is FixinEIP712, FixinTokenSpender {
/// @dev Get the order info for a limit order. /// @dev Get the order info for a limit order.
/// @param order The limit order. /// @param order The limit order.
/// @return orderInfo Info about the order. /// @return orderInfo Info about the order.
function getLimitOrderInfo(LibNativeOrder.LimitOrder memory order) function getLimitOrderInfo(
public LibNativeOrder.LimitOrder memory order
view ) public view returns (LibNativeOrder.OrderInfo memory orderInfo) {
returns (LibNativeOrder.OrderInfo memory orderInfo)
{
// Recover maker and compute order hash. // Recover maker and compute order hash.
orderInfo.orderHash = getLimitOrderHash(order); orderInfo.orderHash = getLimitOrderHash(order);
uint256 minValidSalt = LibNativeOrdersStorage uint256 minValidSalt = LibNativeOrdersStorage
@ -69,11 +67,9 @@ abstract contract NativeOrdersInfo is FixinEIP712, FixinTokenSpender {
/// @dev Get the order info for an RFQ order. /// @dev Get the order info for an RFQ order.
/// @param order The RFQ order. /// @param order The RFQ order.
/// @return orderInfo Info about the order. /// @return orderInfo Info about the order.
function getRfqOrderInfo(LibNativeOrder.RfqOrder memory order) function getRfqOrderInfo(
public LibNativeOrder.RfqOrder memory order
view ) public view returns (LibNativeOrder.OrderInfo memory orderInfo) {
returns (LibNativeOrder.OrderInfo memory orderInfo)
{
// Recover maker and compute order hash. // Recover maker and compute order hash.
orderInfo.orderHash = getRfqOrderHash(order); orderInfo.orderHash = getRfqOrderHash(order);
uint256 minValidSalt = LibNativeOrdersStorage uint256 minValidSalt = LibNativeOrdersStorage
@ -145,7 +141,10 @@ abstract contract NativeOrdersInfo is FixinEIP712, FixinTokenSpender {
/// @return actualFillableTakerTokenAmount How much of the order is fillable /// @return actualFillableTakerTokenAmount How much of the order is fillable
/// based on maker funds, in taker tokens. /// based on maker funds, in taker tokens.
/// @return isSignatureValid Whether the signature is valid. /// @return isSignatureValid Whether the signature is valid.
function getRfqOrderRelevantState(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature) function getRfqOrderRelevantState(
LibNativeOrder.RfqOrder memory order,
LibSignature.Signature memory signature
)
public public
view view
returns ( returns (
@ -293,11 +292,9 @@ abstract contract NativeOrdersInfo is FixinEIP712, FixinTokenSpender {
/// @dev Calculate the actual fillable taker token amount of an order /// @dev Calculate the actual fillable taker token amount of an order
/// based on maker allowance and balances. /// based on maker allowance and balances.
function _getActualFillableTakerTokenAmount(GetActualFillableTakerTokenAmountParams memory params) function _getActualFillableTakerTokenAmount(
private GetActualFillableTakerTokenAmountParams memory params
view ) private view returns (uint128 actualFillableTakerTokenAmount) {
returns (uint128 actualFillableTakerTokenAmount)
{
if (params.orderMakerAmount == 0 || params.orderTakerAmount == 0) { if (params.orderMakerAmount == 0 || params.orderTakerAmount == 0) {
// Empty order. // Empty order.
return 0; return 0;

21
contracts/zero-ex/contracts/src/features/native_orders/NativeOrdersSettlement.sol
View File

@ -313,10 +313,9 @@ abstract contract NativeOrdersSettlement is
/// @dev Fill a limit order. Private variant. Does not refund protocol fees. /// @dev Fill a limit order. Private variant. Does not refund protocol fees.
/// @param params Function params. /// @param params Function params.
/// @return results Results of the fill. /// @return results Results of the fill.
function _fillLimitOrderPrivate(FillLimitOrderPrivateParams memory params) function _fillLimitOrderPrivate(
private FillLimitOrderPrivateParams memory params
returns (FillNativeOrderResults memory results) ) private returns (FillNativeOrderResults memory results) {
{
LibNativeOrder.OrderInfo memory orderInfo = getLimitOrderInfo(params.order); LibNativeOrder.OrderInfo memory orderInfo = getLimitOrderInfo(params.order);
// Must be fillable. // Must be fillable.
@ -402,10 +401,9 @@ abstract contract NativeOrdersSettlement is
/// @dev Fill an RFQ order. Private variant. /// @dev Fill an RFQ order. Private variant.
/// @param params Function params. /// @param params Function params.
/// @return results Results of the fill. /// @return results Results of the fill.
function _fillRfqOrderPrivate(FillRfqOrderPrivateParams memory params) function _fillRfqOrderPrivate(
private FillRfqOrderPrivateParams memory params
returns (FillNativeOrderResults memory results) ) private returns (FillNativeOrderResults memory results) {
{
LibNativeOrder.OrderInfo memory orderInfo = getRfqOrderInfo(params.order); LibNativeOrder.OrderInfo memory orderInfo = getRfqOrderInfo(params.order);
// Must be fillable. // Must be fillable.
@ -473,10 +471,9 @@ abstract contract NativeOrdersSettlement is
/// @param settleInfo Information needed to execute the settlement. /// @param settleInfo Information needed to execute the settlement.
/// @return takerTokenFilledAmount How much taker token was filled. /// @return takerTokenFilledAmount How much taker token was filled.
/// @return makerTokenFilledAmount How much maker token was filled. /// @return makerTokenFilledAmount How much maker token was filled.
function _settleOrder(SettleOrderInfo memory settleInfo) function _settleOrder(
private SettleOrderInfo memory settleInfo
returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount) ) private returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount) {
{
// Clamp the taker token fill amount to the fillable amount. // Clamp the taker token fill amount to the fillable amount.
takerTokenFilledAmount = LibSafeMathV06.min128( takerTokenFilledAmount = LibSafeMathV06.min128(
settleInfo.takerTokenFillAmount, settleInfo.takerTokenFillAmount,

40
contracts/zero-ex/contracts/src/features/nft_orders/ERC1155OrdersFeature.sol
View File

@ -251,7 +251,7 @@ contract ERC1155OrdersFeature is IFeature, IERC1155OrdersFeature, FixinERC1155Sp
/// indicating that the callback succeeded. /// indicating that the callback succeeded.
function onERC1155Received( function onERC1155Received(
address operator, address operator,
address, /* from */ address /* from */,
uint256 tokenId, uint256 tokenId,
uint256 value, uint256 value,
bytes calldata data bytes calldata data
@ -422,7 +422,7 @@ contract ERC1155OrdersFeature is IFeature, IERC1155OrdersFeature, FixinERC1155Sp
/// @param fillAmount The amount (denominated in the NFT asset) /// @param fillAmount The amount (denominated in the NFT asset)
/// that the order has been filled by. /// that the order has been filled by.
function _updateOrderState( function _updateOrderState(
LibNFTOrder.NFTOrder memory, /* order */ LibNFTOrder.NFTOrder memory /* order */,
bytes32 orderHash, bytes32 orderHash,
uint128 fillAmount uint128 fillAmount
) internal override { ) internal override {
@ -442,23 +442,19 @@ contract ERC1155OrdersFeature is IFeature, IERC1155OrdersFeature, FixinERC1155Sp
/// an ERC1155 asset. /// an ERC1155 asset.
/// @param order The ERC1155 order. /// @param order The ERC1155 order.
/// @param erc1155TokenId The ID of the ERC1155 asset. /// @param erc1155TokenId The ID of the ERC1155 asset.
function validateERC1155OrderProperties(LibNFTOrder.ERC1155Order memory order, uint256 erc1155TokenId) function validateERC1155OrderProperties(
public LibNFTOrder.ERC1155Order memory order,
view uint256 erc1155TokenId
override ) public view override {
{
_validateOrderProperties(order.asNFTOrder(), erc1155TokenId); _validateOrderProperties(order.asNFTOrder(), erc1155TokenId);
} }
/// @dev Get the order info for an ERC1155 order. /// @dev Get the order info for an ERC1155 order.
/// @param order The ERC1155 order. /// @param order The ERC1155 order.
/// @return orderInfo Info about the order. /// @return orderInfo Info about the order.
function getERC1155OrderInfo(LibNFTOrder.ERC1155Order memory order) function getERC1155OrderInfo(
public LibNFTOrder.ERC1155Order memory order
view ) public view override returns (LibNFTOrder.OrderInfo memory orderInfo) {
override
returns (LibNFTOrder.OrderInfo memory orderInfo)
{
orderInfo.orderAmount = order.erc1155TokenAmount; orderInfo.orderAmount = order.erc1155TokenAmount;
orderInfo.orderHash = getERC1155OrderHash(order); orderInfo.orderHash = getERC1155OrderHash(order);
@ -511,24 +507,18 @@ contract ERC1155OrdersFeature is IFeature, IERC1155OrdersFeature, FixinERC1155Sp
/// @dev Get the order info for an NFT order. /// @dev Get the order info for an NFT order.
/// @param order The NFT order. /// @param order The NFT order.
/// @return orderInfo Info about the order. /// @return orderInfo Info about the order.
function _getOrderInfo(LibNFTOrder.NFTOrder memory order) function _getOrderInfo(
internal LibNFTOrder.NFTOrder memory order
view ) internal view override returns (LibNFTOrder.OrderInfo memory orderInfo) {
override
returns (LibNFTOrder.OrderInfo memory orderInfo)
{
return getERC1155OrderInfo(order.asERC1155Order()); return getERC1155OrderInfo(order.asERC1155Order());
} }
/// @dev Get the EIP-712 hash of an ERC1155 order. /// @dev Get the EIP-712 hash of an ERC1155 order.
/// @param order The ERC1155 order. /// @param order The ERC1155 order.
/// @return orderHash The order hash. /// @return orderHash The order hash.
function getERC1155OrderHash(LibNFTOrder.ERC1155Order memory order) function getERC1155OrderHash(
public LibNFTOrder.ERC1155Order memory order
view ) public view override returns (bytes32 orderHash) {
override
returns (bytes32 orderHash)
{
return _getEIP712Hash(LibNFTOrder.getERC1155OrderStructHash(order)); return _getEIP712Hash(LibNFTOrder.getERC1155OrderStructHash(order));
} }
} }

50
contracts/zero-ex/contracts/src/features/nft_orders/ERC721OrdersFeature.sol
View File

@ -474,7 +474,7 @@ contract ERC721OrdersFeature is IFeature, IERC721OrdersFeature, FixinERC721Spend
/// indicating that the callback succeeded. /// indicating that the callback succeeded.
function onERC721Received( function onERC721Received(
address operator, address operator,
address, /* from */ address /* from */,
uint256 tokenId, uint256 tokenId,
bytes calldata data bytes calldata data
) external override returns (bytes4 success) { ) external override returns (bytes4 success) {
@ -599,11 +599,10 @@ contract ERC721OrdersFeature is IFeature, IERC721OrdersFeature, FixinERC721Spend
/// the given ERC721 order. Reverts if not. /// the given ERC721 order. Reverts if not.
/// @param order The ERC721 order. /// @param order The ERC721 order.
/// @param signature The signature to validate. /// @param signature The signature to validate.
function validateERC721OrderSignature(LibNFTOrder.ERC721Order memory order, LibSignature.Signature memory signature) function validateERC721OrderSignature(
public LibNFTOrder.ERC721Order memory order,
view LibSignature.Signature memory signature
override ) public view override {
{
bytes32 orderHash = getERC721OrderHash(order); bytes32 orderHash = getERC721OrderHash(order);
_validateOrderSignature(orderHash, signature, order.maker); _validateOrderSignature(orderHash, signature, order.maker);
} }
@ -658,7 +657,7 @@ contract ERC721OrdersFeature is IFeature, IERC721OrdersFeature, FixinERC721Spend
/// that the order has been filled by. /// that the order has been filled by.
function _updateOrderState( function _updateOrderState(
LibNFTOrder.NFTOrder memory order, LibNFTOrder.NFTOrder memory order,
bytes32, /* orderHash */ bytes32 /* orderHash */,
uint128 fillAmount uint128 fillAmount
) internal override { ) internal override {
assert(fillAmount == 1); assert(fillAmount == 1);
@ -682,23 +681,19 @@ contract ERC721OrdersFeature is IFeature, IERC721OrdersFeature, FixinERC721Spend
/// an ERC721 asset. /// an ERC721 asset.
/// @param order The ERC721 order. /// @param order The ERC721 order.
/// @param erc721TokenId The ID of the ERC721 asset. /// @param erc721TokenId The ID of the ERC721 asset.
function validateERC721OrderProperties(LibNFTOrder.ERC721Order memory order, uint256 erc721TokenId) function validateERC721OrderProperties(
public LibNFTOrder.ERC721Order memory order,
view uint256 erc721TokenId
override ) public view override {
{
_validateOrderProperties(order.asNFTOrder(), erc721TokenId); _validateOrderProperties(order.asNFTOrder(), erc721TokenId);
} }
/// @dev Get the current status of an ERC721 order. /// @dev Get the current status of an ERC721 order.
/// @param order The ERC721 order. /// @param order The ERC721 order.
/// @return status The status of the order. /// @return status The status of the order.
function getERC721OrderStatus(LibNFTOrder.ERC721Order memory order) function getERC721OrderStatus(
public LibNFTOrder.ERC721Order memory order
view ) public view override returns (LibNFTOrder.OrderStatus status) {
override
returns (LibNFTOrder.OrderStatus status)
{
// Only buy orders with `erc721TokenId` == 0 can be property // Only buy orders with `erc721TokenId` == 0 can be property
// orders. // orders.
if ( if (
@ -741,12 +736,9 @@ contract ERC721OrdersFeature is IFeature, IERC721OrdersFeature, FixinERC721Spend
/// @dev Get the order info for an NFT order. /// @dev Get the order info for an NFT order.
/// @param order The NFT order. /// @param order The NFT order.
/// @return orderInfo Info about the order. /// @return orderInfo Info about the order.
function _getOrderInfo(LibNFTOrder.NFTOrder memory order) function _getOrderInfo(
internal LibNFTOrder.NFTOrder memory order
view ) internal view override returns (LibNFTOrder.OrderInfo memory orderInfo) {
override
returns (LibNFTOrder.OrderInfo memory orderInfo)
{
LibNFTOrder.ERC721Order memory erc721Order = order.asERC721Order(); LibNFTOrder.ERC721Order memory erc721Order = order.asERC721Order();
orderInfo.orderHash = getERC721OrderHash(erc721Order); orderInfo.orderHash = getERC721OrderHash(erc721Order);
orderInfo.status = getERC721OrderStatus(erc721Order); orderInfo.status = getERC721OrderStatus(erc721Order);
@ -770,12 +762,10 @@ contract ERC721OrdersFeature is IFeature, IERC721OrdersFeature, FixinERC721Spend
/// 248 bits. /// 248 bits.
/// @return bitVector The order status bit vector for the /// @return bitVector The order status bit vector for the
/// given maker and nonce range. /// given maker and nonce range.
function getERC721OrderStatusBitVector(address maker, uint248 nonceRange) function getERC721OrderStatusBitVector(
external address maker,
view uint248 nonceRange
override ) external view override returns (uint256 bitVector) {
returns (uint256 bitVector)
{
LibERC721OrdersStorage.Storage storage stor = LibERC721OrdersStorage.getStorage(); LibERC721OrdersStorage.Storage storage stor = LibERC721OrdersStorage.getStorage();
return stor.orderStatusByMaker[maker][nonceRange]; return stor.orderStatusByMaker[maker][nonceRange];
} }

8
contracts/zero-ex/contracts/src/features/nft_orders/NFTOrders.sol
View File

@ -439,9 +439,7 @@ abstract contract NFTOrders is FixinCommon, FixinEIP712, FixinTokenSpender {
/// @dev Get the order info for an NFT order. /// @dev Get the order info for an NFT order.
/// @param order The NFT order. /// @param order The NFT order.
/// @return orderInfo Info about the order. /// @return orderInfo Info about the order.
function _getOrderInfo(LibNFTOrder.NFTOrder memory order) function _getOrderInfo(
internal LibNFTOrder.NFTOrder memory order
view ) internal view virtual returns (LibNFTOrder.OrderInfo memory orderInfo);
virtual
returns (LibNFTOrder.OrderInfo memory orderInfo);
} }

7
contracts/zero-ex/contracts/src/fixins/FixinERC721Spender.sol
View File

@ -33,12 +33,7 @@ abstract contract FixinERC721Spender {
/// @param owner The owner of the asset. /// @param owner The owner of the asset.
/// @param to The recipient of the asset. /// @param to The recipient of the asset.
/// @param tokenId The token ID of the asset to transfer. /// @param tokenId The token ID of the asset to transfer.
function _transferERC721AssetFrom( function _transferERC721AssetFrom(IERC721Token token, address owner, address to, uint256 tokenId) internal {
IERC721Token token,
address owner,
address to,
uint256 tokenId
) internal {
require(address(token) != address(this), "FixinERC721Spender/CANNOT_INVOKE_SELF"); require(address(token) != address(this), "FixinERC721Spender/CANNOT_INVOKE_SELF");
assembly { assembly {

13
contracts/zero-ex/contracts/src/fixins/FixinTokenSpender.sol
View File

@ -33,12 +33,7 @@ abstract contract FixinTokenSpender {
/// @param owner The owner of the tokens. /// @param owner The owner of the tokens.
/// @param to The recipient of the tokens. /// @param to The recipient of the tokens.
/// @param amount The amount of `token` to transfer. /// @param amount The amount of `token` to transfer.
function _transferERC20TokensFrom( function _transferERC20TokensFrom(IERC20TokenV06 token, address owner, address to, uint256 amount) internal {
IERC20TokenV06 token,
address owner,
address to,
uint256 amount
) internal {
require(address(token) != address(this), "FixinTokenSpender/CANNOT_INVOKE_SELF"); require(address(token) != address(this), "FixinTokenSpender/CANNOT_INVOKE_SELF");
assembly { assembly {
@ -79,11 +74,7 @@ abstract contract FixinTokenSpender {
/// @param token The token to spend. /// @param token The token to spend.
/// @param to The recipient of the tokens. /// @param to The recipient of the tokens.
/// @param amount The amount of `token` to transfer. /// @param amount The amount of `token` to transfer.
function _transferERC20Tokens( function _transferERC20Tokens(IERC20TokenV06 token, address to, uint256 amount) internal {
IERC20TokenV06 token,
address to,
uint256 amount
) internal {
require(address(token) != address(this), "FixinTokenSpender/CANNOT_INVOKE_SELF"); require(address(token) != address(this), "FixinTokenSpender/CANNOT_INVOKE_SELF");
assembly { assembly {

4
contracts/zero-ex/contracts/src/liquidity-providers/CurveLiquidityProvider.sol
View File

@ -131,8 +131,8 @@ contract CurveLiquidityProvider is ILiquidityProvider {
/// @dev Quotes the amount of `outputToken` that would be obtained by /// @dev Quotes the amount of `outputToken` that would be obtained by
/// selling `sellAmount` of `inputToken`. /// selling `sellAmount` of `inputToken`.
function getSellQuote( function getSellQuote(
IERC20TokenV06, /* inputToken */ IERC20TokenV06 /* inputToken */,
IERC20TokenV06, /* outputToken */ IERC20TokenV06 /* outputToken */,
uint256 /* sellAmount */ uint256 /* sellAmount */
) external view override returns (uint256) { ) external view override returns (uint256) {
revert("CurveLiquidityProvider/NOT_IMPLEMENTED"); revert("CurveLiquidityProvider/NOT_IMPLEMENTED");

4
contracts/zero-ex/contracts/src/liquidity-providers/MooniswapLiquidityProvider.sol
View File

@ -128,8 +128,8 @@ contract MooniswapLiquidityProvider is ILiquidityProvider {
/// @dev Quotes the amount of `outputToken` that would be obtained by /// @dev Quotes the amount of `outputToken` that would be obtained by
/// selling `sellAmount` of `inputToken`. /// selling `sellAmount` of `inputToken`.
function getSellQuote( function getSellQuote(
IERC20TokenV06, /* inputToken */ IERC20TokenV06 /* inputToken */,
IERC20TokenV06, /* outputToken */ IERC20TokenV06 /* outputToken */,
uint256 /* sellAmount */ uint256 /* sellAmount */
) external view override returns (uint256) { ) external view override returns (uint256) {
revert("MooniswapLiquidityProvider/NOT_IMPLEMENTED"); revert("MooniswapLiquidityProvider/NOT_IMPLEMENTED");

6
contracts/zero-ex/contracts/src/migrations/FullMigration.sol
View File

@ -114,11 +114,7 @@ contract FullMigration {
/// @param zeroEx The bootstrapped ZeroEx contract. /// @param zeroEx The bootstrapped ZeroEx contract.
/// @param features Features to add to the proxy. /// @param features Features to add to the proxy.
/// @param migrateOpts Parameters needed to initialize features. /// @param migrateOpts Parameters needed to initialize features.
function _addFeatures( function _addFeatures(ZeroEx zeroEx, Features memory features, MigrateOpts memory migrateOpts) private {
ZeroEx zeroEx,
Features memory features,
MigrateOpts memory migrateOpts
) private {
IOwnableFeature ownable = IOwnableFeature(address(zeroEx)); IOwnableFeature ownable = IOwnableFeature(address(zeroEx));
// TransformERC20Feature // TransformERC20Feature
{ {

2
contracts/zero-ex/contracts/src/transformers/FillQuoteTransformer.sol
View File

@ -138,7 +138,7 @@ contract FillQuoteTransformer is Transformer {
event ProtocolFeeUnfunded(bytes32 orderHash); event ProtocolFeeUnfunded(bytes32 orderHash);
/// @dev The highest bit of a uint256 value. /// @dev The highest bit of a uint256 value.
uint256 private constant HIGH_BIT = 2**255; uint256 private constant HIGH_BIT = 2 ** 255;
/// @dev Mask of the lower 255 bits of a uint256 value. /// @dev Mask of the lower 255 bits of a uint256 value.
uint256 private constant LOWER_255_BITS = HIGH_BIT - 1; uint256 private constant LOWER_255_BITS = HIGH_BIT - 1;
/// @dev If `refundReceiver` is set to this address, unpsent /// @dev If `refundReceiver` is set to this address, unpsent

21
contracts/zero-ex/contracts/src/transformers/LibERC20Transformer.sol
View File

@ -40,11 +40,7 @@ library LibERC20Transformer {
/// @param token An ERC20 or the ETH pseudo-token address (`ETH_TOKEN_ADDRESS`). /// @param token An ERC20 or the ETH pseudo-token address (`ETH_TOKEN_ADDRESS`).
/// @param to The recipient. /// @param to The recipient.
/// @param amount The transfer amount. /// @param amount The transfer amount.
function transformerTransfer( function transformerTransfer(IERC20TokenV06 token, address payable to, uint256 amount) internal {
IERC20TokenV06 token,
address payable to,
uint256 amount
) internal {
if (isTokenETH(token)) { if (isTokenETH(token)) {
to.transfer(amount); to.transfer(amount);
} else { } else {
@ -57,11 +53,7 @@ library LibERC20Transformer {
/// @param token An ERC20 or the ETH pseudo-token address (`ETH_TOKEN_ADDRESS`). /// @param token An ERC20 or the ETH pseudo-token address (`ETH_TOKEN_ADDRESS`).
/// @param to The recipient. /// @param to The recipient.
/// @param amount The transfer amount. /// @param amount The transfer amount.
function unsafeTransformerTransfer( function unsafeTransformerTransfer(IERC20TokenV06 token, address payable to, uint256 amount) internal {
IERC20TokenV06 token,
address payable to,
uint256 amount
) internal {
if (isTokenETH(token)) { if (isTokenETH(token)) {
(bool sent, ) = to.call{value: amount}(""); (bool sent, ) = to.call{value: amount}("");
require(sent, "LibERC20Transformer/FAILED_TO_SEND_ETHER"); require(sent, "LibERC20Transformer/FAILED_TO_SEND_ETHER");
@ -130,11 +122,10 @@ library LibERC20Transformer {
/// @param deploymentNonce The nonce that the deployer had when deploying /// @param deploymentNonce The nonce that the deployer had when deploying
/// a contract. /// a contract.
/// @return deploymentAddress The deployment address. /// @return deploymentAddress The deployment address.
function getDeployedAddress(address deployer, uint32 deploymentNonce) function getDeployedAddress(
internal address deployer,
pure uint32 deploymentNonce
returns (address payable deploymentAddress) ) internal pure returns (address payable deploymentAddress) {
{
// The address of if a deployed contract is the lower 20 bytes of the // The address of if a deployed contract is the lower 20 bytes of the
// hash of the RLP-encoded deployer's account address + account nonce. // hash of the RLP-encoded deployer's account address + account nonce.
// See: https://ethereum.stackexchange.com/questions/760/how-is-the-address-of-an-ethereum-contract-computed // See: https://ethereum.stackexchange.com/questions/760/how-is-the-address-of-an-ethereum-contract-computed

4
contracts/zero-ex/contracts/src/transformers/bridges/EthereumBridgeAdapter.sol
View File

@ -72,7 +72,9 @@ contract EthereumBridgeAdapter is
MixinUniswapV3, MixinUniswapV3,
MixinZeroExBridge MixinZeroExBridge
{ {
constructor(IEtherTokenV06 weth) constructor(
IEtherTokenV06 weth
)
public public
MixinBancor(weth) MixinBancor(weth)
MixinBancorV3(weth) MixinBancorV3(weth)

13
contracts/zero-ex/contracts/src/transformers/bridges/mixins/MixinAaveV2.sol
View File

@ -36,12 +36,7 @@ interface ILendingPool {
* @param referralCode Code used to register the integrator originating the operation, for potential rewards. * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man * 0 if the action is executed directly by the user, without any middle-man
**/ **/
function deposit( function deposit(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
) external;
/** /**
* @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
@ -54,11 +49,7 @@ interface ILendingPool {
* different wallet * different wallet
* @return The final amount withdrawn * @return The final amount withdrawn
**/ **/
function withdraw( function withdraw(address asset, uint256 amount, address to) external returns (uint256);
address asset,
uint256 amount,
address to
) external returns (uint256);
} }
contract MixinAaveV2 { contract MixinAaveV2 {

8
contracts/zero-ex/contracts/src/transformers/bridges/mixins/MixinBalancerV2Batch.sol
View File

@ -63,10 +63,10 @@ contract MixinBalancerV2Batch {
IERC20TokenV06[] assets; IERC20TokenV06[] assets;
} }
function _tradeBalancerV2Batch(uint256 sellAmount, bytes memory bridgeData) function _tradeBalancerV2Batch(
internal uint256 sellAmount,
returns (uint256 boughtAmount) bytes memory bridgeData
{ ) internal returns (uint256 boughtAmount) {
// Decode the bridge data. // Decode the bridge data.
( (
IBalancerV2BatchSwapVault vault, IBalancerV2BatchSwapVault vault,

12
contracts/zero-ex/contracts/src/transformers/bridges/mixins/MixinDodo.sol
View File

@ -26,17 +26,9 @@ import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
import "../IBridgeAdapter.sol"; import "../IBridgeAdapter.sol";
interface IDODO { interface IDODO {
function sellBaseToken( function sellBaseToken(uint256 amount, uint256 minReceiveQuote, bytes calldata data) external returns (uint256);
uint256 amount,
uint256 minReceiveQuote,
bytes calldata data
) external returns (uint256);
function buyBaseToken( function buyBaseToken(uint256 amount, uint256 maxPayQuote, bytes calldata data) external returns (uint256);
uint256 amount,
uint256 maxPayQuote,
bytes calldata data
) external returns (uint256);
} }
interface IDODOHelper { interface IDODOHelper {

7
contracts/zero-ex/contracts/src/transformers/bridges/mixins/MixinGMX.sol
View File

@ -33,12 +33,7 @@ interface IGmxRouter {
/// @param _amountIn The amount of input tokens to send. /// @param _amountIn The amount of input tokens to send.
/// @param _minOut The minimum amount of output tokens that must be received for the transaction not to revert. /// @param _minOut The minimum amount of output tokens that must be received for the transaction not to revert.
/// @param _receiver Recipient of the output tokens. /// @param _receiver Recipient of the output tokens.
function swap( function swap(address[] calldata _path, uint256 _amountIn, uint256 _minOut, address _receiver) external;
address[] calldata _path,
uint256 _amountIn,
uint256 _minOut,
address _receiver
) external;
} }
contract MixinGMX { contract MixinGMX {

8
contracts/zero-ex/contracts/src/transformers/bridges/mixins/MixinMakerPSM.sol
View File

@ -63,11 +63,11 @@ contract MixinMakerPSM {
// Maker units // Maker units
// wad: fixed point decimal with 18 decimals (for basic quantities, e.g. balances) // wad: fixed point decimal with 18 decimals (for basic quantities, e.g. balances)
uint256 private constant WAD = 10**18; uint256 private constant WAD = 10 ** 18;
// ray: fixed point decimal with 27 decimals (for precise quantites, e.g. ratios) // ray: fixed point decimal with 27 decimals (for precise quantites, e.g. ratios)
uint256 private constant RAY = 10**27; uint256 private constant RAY = 10 ** 27;
// rad: fixed point decimal with 45 decimals (result of integer multiplication with a wad and a ray) // rad: fixed point decimal with 45 decimals (result of integer multiplication with a wad and a ray)
uint256 private constant RAD = 10**45; uint256 private constant RAD = 10 ** 45;
// See https://github.com/makerdao/dss/blob/master/DEVELOPING.md // See https://github.com/makerdao/dss/blob/master/DEVELOPING.md
@ -89,7 +89,7 @@ contract MixinMakerPSM {
psm.sellGem(address(this), sellAmount); psm.sellGem(address(this), sellAmount);
} else if (address(buyToken) == data.gemTokenAddres) { } else if (address(buyToken) == data.gemTokenAddres) {
uint256 feeDivisor = WAD.safeAdd(psm.tout()); // eg. 1.001 * 10 ** 18 with 0.1% fee [tout is in wad]; uint256 feeDivisor = WAD.safeAdd(psm.tout()); // eg. 1.001 * 10 ** 18 with 0.1% fee [tout is in wad];
uint256 buyTokenBaseUnit = uint256(10)**uint256(buyToken.decimals()); uint256 buyTokenBaseUnit = uint256(10) ** uint256(buyToken.decimals());
uint256 gemAmount = sellAmount.safeMul(buyTokenBaseUnit).safeDiv(feeDivisor); uint256 gemAmount = sellAmount.safeMul(buyTokenBaseUnit).safeDiv(feeDivisor);
sellToken.approveIfBelow(data.psmAddress, sellAmount); sellToken.approveIfBelow(data.psmAddress, sellAmount);

7
contracts/zero-ex/contracts/src/transformers/bridges/mixins/MixinWOOFi.sol
View File

@ -80,12 +80,7 @@ contract MixinWOOFi {
boughtAmount = buyToken.balanceOf(address(this)).safeSub(beforeBalance); boughtAmount = buyToken.balanceOf(address(this)).safeSub(beforeBalance);
} }
function _swap( function _swap(uint256 _amountIn, address _tokenIn, address _tokenOut, IWooPP pool) internal {
uint256 _amountIn,
address _tokenIn,
address _tokenOut,
IWooPP pool
) internal {
address quoteToken = pool.quoteToken(); address quoteToken = pool.quoteToken();
if (_tokenIn == quoteToken) { if (_tokenIn == quoteToken) {
pool.sellQuote(_tokenOut, _amountIn, 1, address(this), rebateAddress); pool.sellQuote(_tokenOut, _amountIn, 1, address(this), rebateAddress);

16
contracts/zero-ex/contracts/src/vendor/IERC1155Token.sol vendored
View File

@ -71,13 +71,7 @@ interface IERC1155Token {
/// @param id ID of the token type /// @param id ID of the token type
/// @param value Transfer amount /// @param value Transfer amount
/// @param data Additional data with no specified format, sent in call to `_to` /// @param data Additional data with no specified format, sent in call to `_to`
function safeTransferFrom( function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external;
address from,
address to,
uint256 id,
uint256 value,
bytes calldata data
) external;
/// @notice Send multiple types of Tokens from a 3rd party in one transfer (with safety call). /// @notice Send multiple types of Tokens from a 3rd party in one transfer (with safety call).
/// @dev MUST emit TransferBatch event on success. /// @dev MUST emit TransferBatch event on success.
@ -124,8 +118,8 @@ interface IERC1155Token {
/// @param owners The addresses of the token holders /// @param owners The addresses of the token holders
/// @param ids ID of the Tokens /// @param ids ID of the Tokens
/// @return balances_ The _owner's balance of the Token types requested /// @return balances_ The _owner's balance of the Token types requested
function balanceOfBatch(address[] calldata owners, uint256[] calldata ids) function balanceOfBatch(
external address[] calldata owners,
view uint256[] calldata ids
returns (uint256[] memory balances_); ) external view returns (uint256[] memory balances_);
} }

19
contracts/zero-ex/contracts/src/vendor/IERC721Token.sol vendored
View File

@ -49,12 +49,7 @@ interface IERC721Token {
/// @param _to The new owner /// @param _to The new owner
/// @param _tokenId The NFT to transfer /// @param _tokenId The NFT to transfer
/// @param _data Additional data with no specified format, sent in call to `_to` /// @param _data Additional data with no specified format, sent in call to `_to`
function safeTransferFrom( function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata _data) external;
address _from,
address _to,
uint256 _tokenId,
bytes calldata _data
) external;
/// @notice Transfers the ownership of an NFT from one address to another address /// @notice Transfers the ownership of an NFT from one address to another address
/// @dev This works identically to the other function with an extra data parameter, /// @dev This works identically to the other function with an extra data parameter,
@ -62,11 +57,7 @@ interface IERC721Token {
/// @param _from The current owner of the NFT /// @param _from The current owner of the NFT
/// @param _to The new owner /// @param _to The new owner
/// @param _tokenId The NFT to transfer /// @param _tokenId The NFT to transfer
function safeTransferFrom( function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
address _from,
address _to,
uint256 _tokenId
) external;
/// @notice Change or reaffirm the approved address for an NFT /// @notice Change or reaffirm the approved address for an NFT
/// @dev The zero address indicates there is no approved address. /// @dev The zero address indicates there is no approved address.
@ -101,11 +92,7 @@ interface IERC721Token {
/// @param _from The current owner of the NFT /// @param _from The current owner of the NFT
/// @param _to The new owner /// @param _to The new owner
/// @param _tokenId The NFT to transfer /// @param _tokenId The NFT to transfer
function transferFrom( function transferFrom(address _from, address _to, uint256 _tokenId) external;
address _from,
address _to,
uint256 _tokenId
) external;
/// @notice Find the owner of an NFT /// @notice Find the owner of an NFT
/// @dev NFTs assigned to zero address are considered invalid, and queries /// @dev NFTs assigned to zero address are considered invalid, and queries

6
contracts/zero-ex/contracts/src/vendor/IPropertyValidator.sol vendored
View File

@ -26,9 +26,5 @@ interface IPropertyValidator {
/// @param tokenAddress The ERC721/ERC1155 token contract address. /// @param tokenAddress The ERC721/ERC1155 token contract address.
/// @param tokenId The ERC721/ERC1155 tokenId of the asset to check. /// @param tokenId The ERC721/ERC1155 tokenId of the asset to check.
/// @param propertyData Encoded properties or auxiliary data needed to perform the check. /// @param propertyData Encoded properties or auxiliary data needed to perform the check.
function validateProperty( function validateProperty(address tokenAddress, uint256 tokenId, bytes calldata propertyData) external view;
address tokenAddress,
uint256 tokenId,
bytes calldata propertyData
) external view;
} }

16
contracts/zero-ex/contracts/src/vendor/IUniswapV2Pair.sol vendored
View File

@ -29,19 +29,7 @@ interface IUniswapV2Pair {
address indexed to address indexed to
); );
function swap( function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external;
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function getReserves() function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
} }

6
contracts/zero-ex/contracts/src/vendor/v3/IStaking.sol vendored
View File

@ -22,9 +22,5 @@ pragma solidity ^0.6.5;
interface IStaking { interface IStaking {
function joinStakingPoolAsMaker(bytes32) external; function joinStakingPoolAsMaker(bytes32) external;
function payProtocolFee( function payProtocolFee(address, address, uint256) external payable;
address,
address,
uint256
) external payable;
} }

4
contracts/zero-ex/contracts/test/TestFillQuoteTransformerBridge.sol
View File

@ -28,10 +28,10 @@ contract TestFillQuoteTransformerBridge {
uint256 private constant REVERT_AMOUNT = 0xdeadbeef; uint256 private constant REVERT_AMOUNT = 0xdeadbeef;
function sellTokenForToken( function sellTokenForToken(
address, /* takerToken */ address /* takerToken */,
address makerToken, address makerToken,
address recipient, address recipient,
uint256, /* minBuyAmount */ uint256 /* minBuyAmount */,
bytes calldata auxiliaryData bytes calldata auxiliaryData
) external returns (uint256 boughtAmount) { ) external returns (uint256 boughtAmount) {
boughtAmount = abi.decode(auxiliaryData, (uint256)); boughtAmount = abi.decode(auxiliaryData, (uint256));

7
contracts/zero-ex/contracts/test/TestFixinTokenSpender.sol
View File

@ -26,12 +26,7 @@ import "../src/fixins/FixinTokenSpender.sol";
contract TestFixinTokenSpender is FixinTokenSpender { contract TestFixinTokenSpender is FixinTokenSpender {
constructor() public {} constructor() public {}
function transferERC20TokensFrom( function transferERC20TokensFrom(IERC20TokenV06 token, address owner, address to, uint256 amount) external {
IERC20TokenV06 token,
address owner,
address to,
uint256 amount
) external {
_transferERC20TokensFrom(token, owner, to, amount); _transferERC20TokensFrom(token, owner, to, amount);
} }

8
contracts/zero-ex/contracts/test/TestLibNativeOrder.sol
View File

@ -5,11 +5,9 @@ pragma experimental ABIEncoderV2;
import "../src/features/libs/LibNativeOrder.sol"; import "../src/features/libs/LibNativeOrder.sol";
contract TestLibNativeOrder { contract TestLibNativeOrder {
function getLimitOrderStructHash(LibNativeOrder.LimitOrder calldata order) function getLimitOrderStructHash(
external LibNativeOrder.LimitOrder calldata order
pure ) external pure returns (bytes32 structHash) {
returns (bytes32 structHash)
{
return LibNativeOrder.getLimitOrderStructHash(order); return LibNativeOrder.getLimitOrderStructHash(order);
} }

9
contracts/zero-ex/contracts/test/TestLibSignature.sol
View File

@ -23,11 +23,10 @@ pragma experimental ABIEncoderV2;
import "../src/features/libs/LibSignature.sol"; import "../src/features/libs/LibSignature.sol";
contract TestLibSignature { contract TestLibSignature {
function getSignerOfHash(bytes32 hash, LibSignature.Signature calldata signature) function getSignerOfHash(
external bytes32 hash,
pure LibSignature.Signature calldata signature
returns (address signer) ) external pure returns (address signer) {
{
return LibSignature.getSignerOfHash(hash, signature); return LibSignature.getSignerOfHash(hash, signature);
} }
} }

2
contracts/zero-ex/contracts/test/TestMetaTransactionsNativeOrdersFeature.sol
View File

@ -82,7 +82,7 @@ contract TestMetaTransactionsNativeOrdersFeature is NativeOrdersFeature {
LibSignature.Signature memory signature, LibSignature.Signature memory signature,
uint128 takerTokenFillAmount, uint128 takerTokenFillAmount,
address taker, address taker,
bool, /* useSelfBalance */ bool /* useSelfBalance */,
address /* recipient */ address /* recipient */
) public override returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount) { ) public override returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount) {
emit FillRfqOrderCalled( emit FillRfqOrderCalled(

9
contracts/zero-ex/contracts/test/TestMetaTransactionsTransformERC20Feature.sol
View File

@ -37,12 +37,9 @@ contract TestMetaTransactionsTransformERC20Feature is TransformERC20Feature {
constructor() public TransformERC20Feature() {} constructor() public TransformERC20Feature() {}
function _transformERC20(TransformERC20Args memory args) function _transformERC20(
public TransformERC20Args memory args
payable ) public payable override returns (uint256 outputTokenAmount) {
override
returns (uint256 outputTokenAmount)
{
if (msg.value == 555) { if (msg.value == 555) {
tx.origin.transfer(1); tx.origin.transfer(1);
} }

6
contracts/zero-ex/contracts/test/TestOrderSignerRegistryWithContractWallet.sol
View File

@ -35,11 +35,7 @@ contract TestOrderSignerRegistryWithContractWallet is OwnableV06 {
zeroex.registerAllowedOrderSigner(signer, allowed); zeroex.registerAllowedOrderSigner(signer, allowed);
} }
function approveERC20( function approveERC20(IERC20TokenV06 token, address spender, uint256 value) external onlyOwner {
IERC20TokenV06 token,
address spender,
uint256 value
) external onlyOwner {
token.approve(spender, value); token.approve(spender, value);
} }
} }

6
contracts/zero-ex/contracts/test/TestPropertyValidator.sol
View File

@ -21,11 +21,7 @@ pragma solidity ^0.6.5;
pragma experimental ABIEncoderV2; pragma experimental ABIEncoderV2;
contract TestPropertyValidator { contract TestPropertyValidator {
function validateProperty( function validateProperty(address tokenAddress, uint256 tokenId, bytes calldata propertyData) external view {
address tokenAddress,
uint256 tokenId,
bytes calldata propertyData
) external view {
require(propertyData.length > 0, "TestPropertyValidator::validateProperty/REVERT"); require(propertyData.length > 0, "TestPropertyValidator::validateProperty/REVERT");
} }
} }

6
contracts/zero-ex/contracts/test/TestRfqOriginRegistration.sol
View File

@ -23,11 +23,7 @@ pragma experimental ABIEncoderV2;
import "../src/features/interfaces/INativeOrdersFeature.sol"; import "../src/features/interfaces/INativeOrdersFeature.sol";
contract TestRfqOriginRegistration { contract TestRfqOriginRegistration {
function registerAllowedRfqOrigins( function registerAllowedRfqOrigins(INativeOrdersFeature feature, address[] memory origins, bool allowed) external {
INativeOrdersFeature feature,
address[] memory origins,
bool allowed
) external {
feature.registerAllowedRfqOrigins(origins, allowed); feature.registerAllowedRfqOrigins(origins, allowed);
} }
} }

6
contracts/zero-ex/contracts/test/TestStaking.sol
View File

@ -36,11 +36,7 @@ contract TestStaking {
poolForMaker[msg.sender] = poolId; poolForMaker[msg.sender] = poolId;
} }
function payProtocolFee( function payProtocolFee(address makerAddress, address payerAddress, uint256 amount) external payable {
address makerAddress,
address payerAddress,
uint256 amount
) external payable {
require(weth.transferFrom(payerAddress, address(this), amount)); require(weth.transferFrom(payerAddress, address(this), amount));
balanceForPool[poolForMaker[makerAddress]] += amount; balanceForPool[poolForMaker[makerAddress]] += amount;
} }

4
contracts/zero-ex/contracts/test/TestTransformerBase.sol
View File

@ -25,9 +25,7 @@ import "../src/transformers/IERC20Transformer.sol";
import "../src/transformers/LibERC20Transformer.sol"; import "../src/transformers/LibERC20Transformer.sol";
contract TestTransformerBase is IERC20Transformer, Transformer { contract TestTransformerBase is IERC20Transformer, Transformer {
function transform( function transform(TransformContext calldata /* context */) external override returns (bytes4 success) {
TransformContext calldata /* context */
) external override returns (bytes4 success) {
return LibERC20Transformer.TRANSFORMER_SUCCESS; return LibERC20Transformer.TRANSFORMER_SUCCESS;
} }
} }

7
contracts/zero-ex/contracts/test/TestTransformerHost.sol
View File

@ -29,9 +29,10 @@ contract TestTransformerHost {
using LibERC20Transformer for IERC20TokenV06; using LibERC20Transformer for IERC20TokenV06;
using LibRichErrorsV06 for bytes; using LibRichErrorsV06 for bytes;
function rawExecuteTransform(IERC20Transformer transformer, IERC20Transformer.TransformContext calldata context) function rawExecuteTransform(
external IERC20Transformer transformer,
{ IERC20Transformer.TransformContext calldata context
) external {
(bool _success, bytes memory resultData) = address(transformer).delegatecall( (bool _success, bytes memory resultData) = address(transformer).delegatecall(
abi.encodeWithSelector(transformer.transform.selector, context) abi.encodeWithSelector(transformer.transform.selector, context)
); );

6
contracts/zero-ex/contracts/test/TestWethTransformerHost.sol
View File

@ -32,11 +32,7 @@ contract TestWethTransformerHost is TestTransformerHost {
_weth = weth; _weth = weth;
} }
function executeTransform( function executeTransform(uint256 wethAmount, IERC20Transformer transformer, bytes calldata data) external payable {
uint256 wethAmount,
IERC20Transformer transformer,
bytes calldata data
) external payable {
if (wethAmount != 0) { if (wethAmount != 0) {
_weth.deposit{value: wethAmount}(); _weth.deposit{value: wethAmount}();
} }

6
contracts/zero-ex/contracts/test/integration/TestCurve.sol
View File

@ -45,11 +45,7 @@ contract TestCurve {
IERC20TokenV06 public sellToken; IERC20TokenV06 public sellToken;
TestMintableERC20Token public buyToken; TestMintableERC20Token public buyToken;
constructor( constructor(IERC20TokenV06 sellToken_, TestMintableERC20Token buyToken_, uint256 buyAmount_) public payable {
IERC20TokenV06 sellToken_,
TestMintableERC20Token buyToken_,
uint256 buyAmount_
) public payable {
sellToken = sellToken_; sellToken = sellToken_;
buyToken = buyToken_; buyToken = buyToken_;
buyAmount = buyAmount_; buyAmount = buyAmount_;

24
contracts/zero-ex/contracts/test/integration/TestUniswapV2Pool.sol
View File

@ -27,12 +27,7 @@ contract TestUniswapV2Pool is IUniswapV2Pair {
(token0, token1) = (params.token0, params.token1); (token0, token1) = (params.token0, params.token1);
} }
function swap( function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata /* data */) external override {
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata /* data */
) external override {
if (amount0Out > 0) { if (amount0Out > 0) {
token0.transfer(to, amount0Out); token0.transfer(to, amount0Out);
} }
@ -41,26 +36,13 @@ contract TestUniswapV2Pool is IUniswapV2Pair {
} }
} }
function setReserves( function setReserves(uint112 reserve0_, uint112 reserve1_, uint32 blockTimestampLast_) external {
uint112 reserve0_,
uint112 reserve1_,
uint32 blockTimestampLast_
) external {
reserve0 = reserve0_; reserve0 = reserve0_;
reserve1 = reserve1_; reserve1 = reserve1_;
blockTimestampLast = blockTimestampLast_; blockTimestampLast = blockTimestampLast_;
} }
function getReserves() function getReserves() external view override returns (uint112, uint112, uint32) {
external
view
override
returns (
uint112,
uint112,
uint32
)
{
return (reserve0, reserve1, blockTimestampLast); return (reserve0, reserve1, blockTimestampLast);
} }
} }

6
contracts/zero-ex/contracts/test/integration/TestUniswapV3Pool.sol
View File

@ -15,11 +15,7 @@ interface IUniswapV3PoolDeployer {
} }
interface IUniswapV3SwapCallback { interface IUniswapV3SwapCallback {
function uniswapV3SwapCallback( function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external;
int256 amount0Delta,
int256 amount1Delta,
bytes calldata data
) external;
} }
contract TestUniswapV3Pool is IUniswapV3Pool { contract TestUniswapV3Pool is IUniswapV3Pool {

23
contracts/zero-ex/contracts/test/tokens/TestMintableERC1155Token.sol
View File

@ -108,11 +108,7 @@ contract TestMintableERC1155Token {
// owner => (operator => approved) // owner => (operator => approved)
mapping(address => mapping(address => bool)) internal operatorApproval; mapping(address => mapping(address => bool)) internal operatorApproval;
function mint( function mint(address to, uint256 id, uint256 quantity) external {
address to,
uint256 id,
uint256 quantity
) external {
// Grant the items to the caller // Grant the items to the caller
balances[id][to] = quantity.safeAdd(balances[id][to]); balances[id][to] = quantity.safeAdd(balances[id][to]);
@ -152,13 +148,7 @@ contract TestMintableERC1155Token {
/// @param id ID of the token type /// @param id ID of the token type
/// @param value Transfer amount /// @param value Transfer amount
/// @param data Additional data with no specified format, sent in call to `_to` /// @param data Additional data with no specified format, sent in call to `_to`
function safeTransferFrom( function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external {
address from,
address to,
uint256 id,
uint256 value,
bytes calldata data
) external {
// sanity checks // sanity checks
require(to != address(0x0), "CANNOT_TRANSFER_TO_ADDRESS_ZERO"); require(to != address(0x0), "CANNOT_TRANSFER_TO_ADDRESS_ZERO");
require(from == msg.sender || operatorApproval[from][msg.sender] == true, "INSUFFICIENT_ALLOWANCE"); require(from == msg.sender || operatorApproval[from][msg.sender] == true, "INSUFFICIENT_ALLOWANCE");
@ -267,11 +257,10 @@ contract TestMintableERC1155Token {
/// @param owners The addresses of the token holders /// @param owners The addresses of the token holders
/// @param ids ID of the Tokens /// @param ids ID of the Tokens
/// @return balances_ The _owner's balance of the Token types requested /// @return balances_ The _owner's balance of the Token types requested
function balanceOfBatch(address[] calldata owners, uint256[] calldata ids) function balanceOfBatch(
external address[] calldata owners,
view uint256[] calldata ids
returns (uint256[] memory balances_) ) external view returns (uint256[] memory balances_) {
{
// sanity check // sanity check
require(owners.length == ids.length, "OWNERS_AND_IDS_MUST_HAVE_SAME_LENGTH"); require(owners.length == ids.length, "OWNERS_AND_IDS_MUST_HAVE_SAME_LENGTH");

12
contracts/zero-ex/contracts/test/tokens/TestMintableERC20Token.sol
View File

@ -35,11 +35,7 @@ contract TestMintableERC20Token {
return true; return true;
} }
function approveAs( function approveAs(address owner, address spender, uint256 amount) external returns (bool) {
address owner,
address spender,
uint256 amount
) external returns (bool) {
allowance[owner][spender] = amount; allowance[owner][spender] = amount;
return true; return true;
} }
@ -53,11 +49,7 @@ contract TestMintableERC20Token {
balanceOf[owner] -= amount; balanceOf[owner] -= amount;
} }
function transferFrom( function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
address from,
address to,
uint256 amount
) public virtual returns (bool) {
if (from != msg.sender) { if (from != msg.sender) {
require(allowance[from][msg.sender] >= amount, "TestMintableERC20Token/INSUFFICIENT_ALLOWANCE"); require(allowance[from][msg.sender] >= amount, "TestMintableERC20Token/INSUFFICIENT_ALLOWANCE");
allowance[from][msg.sender] -= amount; allowance[from][msg.sender] -= amount;

19
contracts/zero-ex/contracts/test/tokens/TestMintableERC721Token.sol
View File

@ -123,12 +123,7 @@ contract TestMintableERC721Token {
/// @param _to The new owner /// @param _to The new owner
/// @param _tokenId The NFT to transfer /// @param _tokenId The NFT to transfer
/// @param _data Additional data with no specified format, sent in call to `_to` /// @param _data Additional data with no specified format, sent in call to `_to`
function safeTransferFrom( function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata _data) external {
address _from,
address _to,
uint256 _tokenId,
bytes calldata _data
) external {
transferFrom(_from, _to, _tokenId); transferFrom(_from, _to, _tokenId);
uint256 receiverCodeSize; uint256 receiverCodeSize;
@ -147,11 +142,7 @@ contract TestMintableERC721Token {
/// @param _from The current owner of the NFT /// @param _from The current owner of the NFT
/// @param _to The new owner /// @param _to The new owner
/// @param _tokenId The NFT to transfer /// @param _tokenId The NFT to transfer
function safeTransferFrom( function safeTransferFrom(address _from, address _to, uint256 _tokenId) external {
address _from,
address _to,
uint256 _tokenId
) external {
transferFrom(_from, _to, _tokenId); transferFrom(_from, _to, _tokenId);
uint256 receiverCodeSize; uint256 receiverCodeSize;
@ -209,11 +200,7 @@ contract TestMintableERC721Token {
/// @param _from The current owner of the NFT /// @param _from The current owner of the NFT
/// @param _to The new owner /// @param _to The new owner
/// @param _tokenId The NFT to transfer /// @param _tokenId The NFT to transfer
function transferFrom( function transferFrom(address _from, address _to, uint256 _tokenId) public {
address _from,
address _to,
uint256 _tokenId
) public {
require(_to != address(0), "ERC721_ZERO_TO_ADDRESS"); require(_to != address(0), "ERC721_ZERO_TO_ADDRESS");
address owner = ownerOf(_tokenId); address owner = ownerOf(_tokenId);

13
contracts/zero-ex/contracts/test/tokens/TestTokenSpenderERC20Token.sol
View File

@ -39,11 +39,7 @@ contract TestTokenSpenderERC20Token is TestMintableERC20Token {
_isGreedyRevert = isGreedy; _isGreedyRevert = isGreedy;
} }
function transferFrom( function transferFrom(address from, address to, uint256 amount) public override returns (bool) {
address from,
address to,
uint256 amount
) public override returns (bool) {
emit TransferFromCalled(msg.sender, from, to, amount); emit TransferFromCalled(msg.sender, from, to, amount);
if (amount == EMPTY_RETURN_AMOUNT) { if (amount == EMPTY_RETURN_AMOUNT) {
assembly { assembly {
@ -73,12 +69,7 @@ contract TestTokenSpenderERC20Token is TestMintableERC20Token {
return true; return true;
} }
function setBalanceAndAllowanceOf( function setBalanceAndAllowanceOf(address owner, uint256 balance, address spender, uint256 allowance_) external {
address owner,
uint256 balance,
address spender,
uint256 allowance_
) external {
balanceOf[owner] = balance; balanceOf[owner] = balance;
allowance[owner][spender] = allowance_; allowance[owner][spender] = allowance_;
} }

2
package.json
View File

@ -74,7 +74,7 @@
"lerna": "^3.0.0-beta.25", "lerna": "^3.0.0-beta.25",
"npm-run-all": "^4.1.2", "npm-run-all": "^4.1.2",
"prettier": "2.7.1", "prettier": "2.7.1",
"prettier-plugin-solidity": "^1.0.0-beta.24", "prettier-plugin-solidity": "^1.0.0",
"solhint": "^3.3.7", "solhint": "^3.3.7",
"solhint-plugin-prettier": "^0.0.5", "solhint-plugin-prettier": "^0.0.5",
"source-map-support": "^0.5.6", "source-map-support": "^0.5.6",

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