diff --git a/contracts/AMMQuoter.sol b/contracts/AMMQuoter.sol index e02681e4..693a0696 100644 --- a/contracts/AMMQuoter.sol +++ b/contracts/AMMQuoter.sol @@ -130,12 +130,7 @@ contract AMMQuoter { return _getCurveMakerOutAmount(vars, curveVersion, fromTokenCurveIndex, toTokenCurveIndex, swapMethod); } - function getMakerOutAmount( - address _makerAddr, - address _takerAssetAddr, - address _makerAssetAddr, - uint256 _takerAssetAmount - ) public view returns (uint256) { + function getMakerOutAmount(address _makerAddr, address _takerAssetAddr, address _makerAssetAddr, uint256 _takerAssetAmount) public view returns (uint256) { uint256 makerAssetAmount; if (_makerAddr == UNISWAP_V2_ROUTER_02_ADDRESS || _makerAddr == SUSHISWAP_ROUTER_ADDRESS) { IUniswapRouterV2 router = IUniswapRouterV2(_makerAddr); @@ -284,12 +279,7 @@ contract AMMQuoter { return _getCurveTakerInAmount(vars, curveVersion, fromTokenCurveIndex, toTokenCurveIndex, swapMethod, supportGetDx); } - function getTakerInAmount( - address _makerAddr, - address _takerAssetAddr, - address _makerAssetAddr, - uint256 _makerAssetAmount - ) public view returns (uint256) { + function getTakerInAmount(address _makerAddr, address _takerAssetAddr, address _makerAssetAddr, uint256 _makerAssetAmount) public view returns (uint256) { uint256 takerAssetAmount; if (_makerAddr == UNISWAP_V2_ROUTER_02_ADDRESS || _makerAddr == SUSHISWAP_ROUTER_ADDRESS) { IUniswapRouterV2 router = IUniswapRouterV2(_makerAddr); @@ -348,7 +338,7 @@ contract AMMQuoter { address _makerAssetAddr, uint256 _makerAssetAmount ) external view returns (address bestMaker, uint256 bestAmount) { - bestAmount = 2**256 - 1; + bestAmount = 2 ** 256 - 1; uint256 poolLength = _makerAddresses.length; for (uint256 i = 0; i < poolLength; ++i) { address makerAddress = _makerAddresses[i]; diff --git a/contracts/AMMWrapper.sol b/contracts/AMMWrapper.sol index 134c01ec..50454af1 100644 --- a/contracts/AMMWrapper.sol +++ b/contracts/AMMWrapper.sol @@ -314,12 +314,7 @@ contract AMMWrapper is IAMMWrapper, StrategyBase, ReentrancyGuard, BaseLibEIP712 * @dev internal function of `trade`. * It transfer assets to receiver specified in order. */ - function _settle( - AMMLibEIP712.Order memory _order, - InternalTxData memory _internalTxData, - uint256 _settleAmount, - uint256 _feeAmount - ) internal { + function _settle(AMMLibEIP712.Order memory _order, InternalTxData memory _internalTxData, uint256 _settleAmount, uint256 _feeAmount) internal { // Transfer token/ETH to receiver if (_internalTxData.toEth) { // Withdraw from WETH if internal maker asset is WETH diff --git a/contracts/AMMWrapperWithPath.sol b/contracts/AMMWrapperWithPath.sol index 9c92fb16..9f62fb70 100644 --- a/contracts/AMMWrapperWithPath.sol +++ b/contracts/AMMWrapperWithPath.sol @@ -224,11 +224,7 @@ contract AMMWrapperWithPath is IAMMWrapperWithPath, AMMWrapper { return amounts[amounts.length - 1]; } - function _validateAMMPath( - address[] memory _path, - address _takerAssetAddr, - address _makerAssetAddr - ) internal pure { + function _validateAMMPath(address[] memory _path, address _takerAssetAddr, address _makerAssetAddr) internal pure { require(_path.length >= 2, "AMMWrapper: path length must be at least two"); require(_path[0] == _takerAssetAddr, "AMMWrapper: first element of path must match taker asset"); require(_path[_path.length - 1] == _makerAssetAddr, "AMMWrapper: last element of path must match maker asset"); @@ -341,11 +337,7 @@ contract AMMWrapperWithPath is IAMMWrapperWithPath, AMMWrapper { return swapSteps; } - function _buildBalancerV2Limits( - address[] memory _path, - uint256 _takerAssetAmount, - uint256 _makerAssetAmount - ) internal pure returns (int256[] memory) { + function _buildBalancerV2Limits(address[] memory _path, uint256 _takerAssetAmount, uint256 _makerAssetAmount) internal pure returns (int256[] memory) { int256[] memory limits = new int256[](_path.length); // amount swapped in to balancer will denoted with positive sign limits[0] = int256(_takerAssetAmount); diff --git a/contracts/LONStaking.sol b/contracts/LONStaking.sol index 0c89eef7..4b926133 100644 --- a/contracts/LONStaking.sol +++ b/contracts/LONStaking.sol @@ -44,12 +44,7 @@ contract LONStaking is ERC20ForUpgradeable, OwnableForUpgradeable, ReentrancyGua /* ========== CONSTRUCTOR ========== */ - function initialize( - ILon _lonToken, - address _owner, - uint256 _COOLDOWN_IN_DAYS, - uint256 _BPS_RAGE_EXIT_PENALTY - ) external { + function initialize(ILon _lonToken, address _owner, uint256 _COOLDOWN_IN_DAYS, uint256 _BPS_RAGE_EXIT_PENALTY) external { lonToken = _lonToken; _initializeOwnable(_owner); @@ -173,11 +168,7 @@ contract LONStaking is ERC20ForUpgradeable, OwnableForUpgradeable, ReentrancyGua } } - function _transfer( - address _from, - address _to, - uint256 _amount - ) internal override whenNotPaused { + function _transfer(address _from, address _to, uint256 _amount) internal override whenNotPaused { uint256 balanceOfFrom = balanceOf(_from); uint256 balanceOfTo = balanceOf(_to); uint256 previousSenderCooldown = stakersCooldowns[_from]; @@ -193,15 +184,7 @@ contract LONStaking is ERC20ForUpgradeable, OwnableForUpgradeable, ReentrancyGua } // EIP-2612 permit standard - function permit( - address _owner, - address _spender, - uint256 _value, - uint256 _deadline, - uint8 _v, - bytes32 _r, - bytes32 _s - ) external { + function permit(address _owner, address _spender, uint256 _value, uint256 _deadline, uint8 _v, bytes32 _r, bytes32 _s) external { require(_owner != address(0), "owner is zero address"); require(block.timestamp <= _deadline || _deadline == 0, "permit expired"); @@ -237,13 +220,7 @@ contract LONStaking is ERC20ForUpgradeable, OwnableForUpgradeable, ReentrancyGua lonToken.transferFrom(msg.sender, address(this), _amount); } - function stakeWithPermit( - uint256 _amount, - uint256 _deadline, - uint8 _v, - bytes32 _r, - bytes32 _s - ) public nonReentrant whenNotPaused { + function stakeWithPermit(uint256 _amount, uint256 _deadline, uint8 _v, bytes32 _r, bytes32 _s) public nonReentrant whenNotPaused { _stake(msg.sender, _amount); // Use permit to allow LONStaking contract to transferFrom user lonToken.permit(msg.sender, address(this), _amount, _deadline, _v, _r, _s); diff --git a/contracts/LPStakingRewards.sol b/contracts/LPStakingRewards.sol index 032cfa79..196d8d7e 100644 --- a/contracts/LPStakingRewards.sol +++ b/contracts/LPStakingRewards.sol @@ -39,13 +39,7 @@ contract LPStakingRewards is ILPStakingRewards, ReentrancyGuard, IEmergency { _; } - constructor( - address _emergencyRecipient, - address _rewardsDistribution, - address _rewardsToken, - address _lpToken, - uint256 _rewardsDuration - ) { + constructor(address _emergencyRecipient, address _rewardsDistribution, address _rewardsToken, address _lpToken, uint256 _rewardsDuration) { require(_rewardsDuration > 0, "rewards duration is 0"); emergencyRecipient = _emergencyRecipient; @@ -82,13 +76,7 @@ contract LPStakingRewards is ILPStakingRewards, ReentrancyGuard, IEmergency { return rewardRate.mul(rewardsDuration); } - function stakeWithPermit( - uint256 amount, - uint256 deadline, - uint8 v, - bytes32 r, - bytes32 s - ) external nonReentrant updateReward(msg.sender) { + function stakeWithPermit(uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) { require(amount > 0, "cannot stake 0"); _totalSupply = _totalSupply.add(amount); _balances[msg.sender] = _balances[msg.sender].add(amount); diff --git a/contracts/LimitOrder.sol b/contracts/LimitOrder.sol index a1d5d0e6..6eb01d6b 100644 --- a/contracts/LimitOrder.sol +++ b/contracts/LimitOrder.sol @@ -80,11 +80,7 @@ contract LimitOrder is ILimitOrder, StrategyBase, BaseLibEIP712, SignatureValida /// @param _makerFeeFactor The new fee factor for maker /// @param _takerFeeFactor The new fee factor for taker /// @param _profitFeeFactor The new fee factor for relayer profit - function setFactors( - uint16 _makerFeeFactor, - uint16 _takerFeeFactor, - uint16 _profitFeeFactor - ) external onlyOwner { + function setFactors(uint16 _makerFeeFactor, uint16 _takerFeeFactor, uint16 _profitFeeFactor) external onlyOwner { require(_makerFeeFactor <= LibConstant.BPS_MAX, "LimitOrder: Invalid maker fee factor"); require(_takerFeeFactor <= LibConstant.BPS_MAX, "LimitOrder: Invalid taker fee factor"); require(_profitFeeFactor <= LibConstant.BPS_MAX, "LimitOrder: Invalid profit fee factor"); @@ -455,11 +451,7 @@ contract LimitOrder is ILimitOrder, StrategyBase, BaseLibEIP712, SignatureValida /* order utils */ - function _validateOrder( - LimitOrderLibEIP712.Order memory _order, - bytes32 _orderHash, - bytes memory _orderMakerSig - ) internal view { + function _validateOrder(LimitOrderLibEIP712.Order memory _order, bytes32 _orderHash, bytes memory _orderMakerSig) internal view { require(_order.expiry > uint64(block.timestamp), "LimitOrder: Order is expired"); bool isCancelled = LibOrderStorage.getStorage().orderHashToCancelled[_orderHash]; require(!isCancelled, "LimitOrder: Order is cancelled"); @@ -477,15 +469,7 @@ contract LimitOrder is ILimitOrder, StrategyBase, BaseLibEIP712, SignatureValida LimitOrderLibEIP712.Order memory _order, bytes32 _orderHash, uint256 _takerTokenAmount - ) - internal - view - returns ( - uint256, - uint256, - uint256 - ) - { + ) internal view returns (uint256, uint256, uint256) { uint256 takerTokenFilledAmount = LibOrderStorage.getStorage().orderHashToTakerTokenFilledAmount[_orderHash]; require(takerTokenFilledAmount < _order.takerTokenAmount, "LimitOrder: Order is filled"); diff --git a/contracts/Lon.sol b/contracts/Lon.sol index afb19ecc..4ad9c1a1 100644 --- a/contracts/Lon.sol +++ b/contracts/Lon.sol @@ -48,15 +48,7 @@ contract Lon is ERC20, ILon, Ownable { } // implement the eip-2612 - function permit( - address owner, - address spender, - uint256 value, - uint256 deadline, - uint8 v, - bytes32 r, - bytes32 s - ) external override { + function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override { require(owner != address(0), "zero address"); require(block.timestamp <= deadline || deadline == 0, "permit is expired"); diff --git a/contracts/MarketMakerProxy.sol b/contracts/MarketMakerProxy.sol index daf5df99..72b31d81 100644 --- a/contracts/MarketMakerProxy.sol +++ b/contracts/MarketMakerProxy.sol @@ -26,11 +26,7 @@ contract MarketMakerProxy is Ownable { address public signer; mapping(address => bool) public isWithdrawWhitelist; - constructor( - address _owner, - address _signer, - IWETH _weth - ) Ownable(_owner) { + constructor(address _owner, address _signer, IWETH _weth) Ownable(_owner) { require(_signer != address(0), "MarketMakerProxy: zero address"); signer = _signer; WETH = _weth; @@ -70,11 +66,7 @@ contract MarketMakerProxy is Ownable { } } - function withdrawToken( - address token, - address to, - uint256 amount - ) external onlyOwner { + function withdrawToken(address token, address to, uint256 amount) external onlyOwner { require(isWithdrawWhitelist[to], "MarketMakerProxy: not in withdraw whitelist"); IERC20(token).safeTransfer(to, amount); } diff --git a/contracts/MerkleRedeem.sol b/contracts/MerkleRedeem.sol index fde120d2..04a8052a 100644 --- a/contracts/MerkleRedeem.sol +++ b/contracts/MerkleRedeem.sol @@ -27,21 +27,12 @@ contract MerkleRedeem is Ownable, ReentrancyGuard, IEmergency { mapping(uint256 => mapping(address => bool)) public claimed; /*==== PUBLIC FUNCTIONS =====*/ - constructor( - address _owner, - IERC20 _rewardsToken, - address _emergencyRecipient - ) Ownable(_owner) { + constructor(address _owner, IERC20 _rewardsToken, address _emergencyRecipient) Ownable(_owner) { emergencyRecipient = _emergencyRecipient; rewardsToken = _rewardsToken; } - function claimPeriod( - address recipient, - uint256 period, - uint256 balance, - bytes32[] memory proof - ) external nonReentrant { + function claimPeriod(address recipient, uint256 period, uint256 balance, bytes32[] memory proof) external nonReentrant { require(!claimed[period][recipient]); require(verifyClaim(recipient, period, balance, proof), "incorrect merkle proof"); @@ -49,12 +40,7 @@ contract MerkleRedeem is Ownable, ReentrancyGuard, IEmergency { _disburse(recipient, balance); } - function verifyClaim( - address recipient, - uint256 period, - uint256 balance, - bytes32[] memory proof - ) public view returns (bool) { + function verifyClaim(address recipient, uint256 period, uint256 balance, bytes32[] memory proof) public view returns (bool) { bytes32 leaf = keccak256(abi.encodePacked(recipient, balance)); return MerkleProof.verify(proof, periodMerkleRoots[period], leaf); } @@ -76,11 +62,7 @@ contract MerkleRedeem is Ownable, ReentrancyGuard, IEmergency { _disburse(recipient, totalBalance); } - function claimStatus( - address recipient, - uint256 begin, - uint256 end - ) external view returns (bool[] memory) { + function claimStatus(address recipient, uint256 begin, uint256 end) external view returns (bool[] memory) { uint256 size = 1 + end - begin; bool[] memory arr = new bool[](size); for (uint256 i = 0; i < size; ++i) { @@ -104,11 +86,7 @@ contract MerkleRedeem is Ownable, ReentrancyGuard, IEmergency { token.transfer(emergencyRecipient, token.balanceOf(address(this))); } - function seedAllocations( - uint256 period, - bytes32 merkleRoot, - uint256 totalAllocation - ) external onlyOwner { + function seedAllocations(uint256 period, bytes32 merkleRoot, uint256 totalAllocation) external onlyOwner { require(periodMerkleRoots[period] == bytes32(0), "already seed"); periodMerkleRoots[period] = merkleRoot; diff --git a/contracts/PermanentStorage.sol b/contracts/PermanentStorage.sol index d3d9d9c8..add14477 100644 --- a/contracts/PermanentStorage.sol +++ b/contracts/PermanentStorage.sol @@ -60,11 +60,7 @@ contract PermanentStorage is IPermanentStorage { } /// @dev Set permission for entity to write certain storage. - function setPermission( - bytes32 _storageId, - address _role, - bool _enabled - ) external onlyOperator { + function setPermission(bytes32 _storageId, address _role, bool _enabled) external onlyOperator { if (_enabled) { require( (_role == operator) || (_role == ammWrapperAddr()) || (_role == rfqAddr()) || (_role == rfqv2Addr()) || (_role == limitOrderAddr()), @@ -124,17 +120,7 @@ contract PermanentStorage is IPermanentStorage { address _makerAddr, address _takerAssetAddr, address _makerAssetAddr - ) - external - view - override - returns ( - int128 takerAssetIndex, - int128 makerAssetIndex, - uint16 swapMethod, - bool supportGetDx - ) - { + ) external view override returns (int128 takerAssetIndex, int128 makerAssetIndex, uint16 swapMethod, bool supportGetDx) { // underlying_coins int128 i = AMMWrapperStorage.getStorage().curveTokenIndexes[_makerAddr][_takerAssetAddr]; int128 j = AMMWrapperStorage.getStorage().curveTokenIndexes[_makerAddr][_makerAssetAddr]; diff --git a/contracts/ProxyPermanentStorage.sol b/contracts/ProxyPermanentStorage.sol index bf7811a7..e26be6a7 100644 --- a/contracts/ProxyPermanentStorage.sol +++ b/contracts/ProxyPermanentStorage.sol @@ -4,9 +4,5 @@ pragma solidity 0.7.6; import "@openzeppelin/contracts/proxy/TransparentUpgradeableProxy.sol"; contract ProxyPermanentStorage is TransparentUpgradeableProxy { - constructor( - address _logic, - address _admin, - bytes memory _data - ) payable TransparentUpgradeableProxy(_logic, _admin, _data) {} + constructor(address _logic, address _admin, bytes memory _data) payable TransparentUpgradeableProxy(_logic, _admin, _data) {} } diff --git a/contracts/RFQ.sol b/contracts/RFQ.sol index f6556ef6..3df52987 100644 --- a/contracts/RFQ.sol +++ b/contracts/RFQ.sol @@ -93,11 +93,7 @@ contract RFQ is IRFQ, StrategyBase, ReentrancyGuard, SignatureValidator, BaseLib return _settle(_order, vars); } - function _emitFillOrder( - RFQLibEIP712.Order memory _order, - GroupedVars memory _vars, - uint256 settleAmount - ) internal { + function _emitFillOrder(RFQLibEIP712.Order memory _order, GroupedVars memory _vars, uint256 settleAmount) internal { emit FillOrder( SOURCE, _vars.transactionHash, diff --git a/contracts/RFQv2.sol b/contracts/RFQv2.sol index 92c29079..d3a950d1 100644 --- a/contracts/RFQv2.sol +++ b/contracts/RFQv2.sol @@ -114,11 +114,7 @@ contract RFQv2 is IRFQv2, StrategyBase, TokenCollector, SignatureValidator, Base _emitFilledRFQEvent(offerHash, order, makerTokenToTaker); } - function _emitFilledRFQEvent( - bytes32 _offerHash, - RFQOrder calldata _rfqOrder, - uint256 _makerTokenToTaker - ) internal { + function _emitFilledRFQEvent(bytes32 _offerHash, RFQOrder calldata _rfqOrder, uint256 _makerTokenToTaker) internal { emit FilledRFQ( _offerHash, _rfqOrder.offer.taker, diff --git a/contracts/RewardDistributor.sol b/contracts/RewardDistributor.sol index dd821a89..1d0befb8 100644 --- a/contracts/RewardDistributor.sol +++ b/contracts/RewardDistributor.sol @@ -329,11 +329,7 @@ contract RewardDistributor is Ownable, Pausable { } } - function _transferFeeToken( - address _feeTokenAddr, - address _transferTo, - uint256 _totalFeeTokenAmount - ) internal { + function _transferFeeToken(address _feeTokenAddr, address _transferTo, uint256 _totalFeeTokenAmount) internal { address strategyAddr; uint256 balanceInStrategy; uint256 amountToTransferFrom; @@ -406,13 +402,7 @@ contract RewardDistributor is Ownable, Pausable { } } - function _buyback( - address _feeTokenAddr, - FeeToken storage _feeToken, - address _exchangeAddr, - uint256 _amountFeeTokenToSwap, - uint256 _minLonAmount - ) internal { + function _buyback(address _feeTokenAddr, FeeToken storage _feeToken, address _exchangeAddr, uint256 _amountFeeTokenToSwap, uint256 _minLonAmount) internal { if (_amountFeeTokenToSwap > 0) { uint256 swappedLonAmount = _swap(_feeTokenAddr, _exchangeAddr, _feeToken.path, _amountFeeTokenToSwap, _minLonAmount); @@ -429,11 +419,7 @@ contract RewardDistributor is Ownable, Pausable { /************************************************************ * External functions * *************************************************************/ - function buyback( - address _feeTokenAddr, - uint256 _amount, - uint256 _minLonAmount - ) external whenNotPaused only_EOA_or_Self { + function buyback(address _feeTokenAddr, uint256 _amount, uint256 _minLonAmount) external whenNotPaused only_EOA_or_Self { FeeToken storage feeToken = feeTokens[_feeTokenAddr]; // Distribute LON directly without swap @@ -472,11 +458,7 @@ contract RewardDistributor is Ownable, Pausable { } } - function batchBuyback( - address[] calldata _feeTokenAddr, - uint256[] calldata _amount, - uint256[] calldata _minLonAmount - ) external whenNotPaused only_EOA { + function batchBuyback(address[] calldata _feeTokenAddr, uint256[] calldata _amount, uint256[] calldata _minLonAmount) external whenNotPaused only_EOA { uint256 inputLength = _feeTokenAddr.length; require((_amount.length == inputLength) && (_minLonAmount.length == inputLength), "input not the same length"); diff --git a/contracts/Spender.sol b/contracts/Spender.sol index b8444032..f1d545ce 100644 --- a/contracts/Spender.sol +++ b/contracts/Spender.sol @@ -159,11 +159,7 @@ contract Spender is ISpender, Ownable { /// @param _user The user to spend token from. /// @param _tokenAddr The address of the token. /// @param _amount Amount to spend. - function spendFromUser( - address _user, - address _tokenAddr, - uint256 _amount - ) external override onlyAuthorized { + function spendFromUser(address _user, address _tokenAddr, uint256 _amount) external override onlyAuthorized { require(!tokenBlacklist[_tokenAddr], "Spender: token is blacklisted"); if (_tokenAddr != LibConstant.ETH_ADDRESS && _tokenAddr != LibConstant.ZERO_ADDRESS) { diff --git a/contracts/SpenderSimulation.sol b/contracts/SpenderSimulation.sol index 582ea7e2..feb26b37 100644 --- a/contracts/SpenderSimulation.sol +++ b/contracts/SpenderSimulation.sol @@ -36,11 +36,7 @@ contract SpenderSimulation { /// @param _user The user to spend token from. /// @param _tokenAddr The address of the token. /// @param _amount Amount to spend. - function simulate( - address _user, - address _tokenAddr, - uint256 _amount - ) external checkBlackList(_tokenAddr, _user) { + function simulate(address _user, address _tokenAddr, uint256 _amount) external checkBlackList(_tokenAddr, _user) { spender.spendFromUser(_user, _tokenAddr, _amount); // All checks passed: revert with success reason string diff --git a/contracts/Tokenlon.sol b/contracts/Tokenlon.sol index 670f330b..492c0f81 100644 --- a/contracts/Tokenlon.sol +++ b/contracts/Tokenlon.sol @@ -4,9 +4,5 @@ pragma solidity 0.7.6; import "@openzeppelin/contracts/proxy/TransparentUpgradeableProxy.sol"; contract Tokenlon is TransparentUpgradeableProxy { - constructor( - address _logic, - address _admin, - bytes memory _data - ) payable TransparentUpgradeableProxy(_logic, _admin, _data) {} + constructor(address _logic, address _admin, bytes memory _data) payable TransparentUpgradeableProxy(_logic, _admin, _data) {} } diff --git a/contracts/TreasuryVester.sol b/contracts/TreasuryVester.sol index bb93c7b5..24d8b3ad 100644 --- a/contracts/TreasuryVester.sol +++ b/contracts/TreasuryVester.sol @@ -17,14 +17,7 @@ contract TreasuryVester { uint256 public lastUpdate; - constructor( - address _lon, - address _recipient, - uint256 _vestingAmount, - uint256 _vestingBegin, - uint256 _vestingCliff, - uint256 _vestingEnd - ) { + constructor(address _lon, address _recipient, uint256 _vestingAmount, uint256 _vestingBegin, uint256 _vestingCliff, uint256 _vestingEnd) { require(_vestingAmount > 0, "vesting amount is zero"); require(_vestingBegin >= block.timestamp, "vesting begin too early"); require(_vestingCliff >= _vestingBegin, "cliff is too early"); diff --git a/contracts/TreasuryVesterFactory.sol b/contracts/TreasuryVesterFactory.sol index dd25e51c..d14a79db 100644 --- a/contracts/TreasuryVesterFactory.sol +++ b/contracts/TreasuryVesterFactory.sol @@ -12,13 +12,7 @@ contract TreasuryVesterFactory { lon = _lon; } - function createVester( - address recipient, - uint256 vestingAmount, - uint256 vestingBegin, - uint256 vestingCliff, - uint256 vestingEnd - ) external returns (address) { + function createVester(address recipient, uint256 vestingAmount, uint256 vestingBegin, uint256 vestingCliff, uint256 vestingEnd) external returns (address) { require(vestingAmount > 0, "vesting amount is zero"); address vester = address(new TreasuryVester(address(lon), recipient, vestingAmount, vestingBegin, vestingCliff, vestingEnd)); diff --git a/contracts/interfaces/ICurveFi.sol b/contracts/interfaces/ICurveFi.sol index 9be67ed9..9dc6d91d 100644 --- a/contracts/interfaces/ICurveFi.sol +++ b/contracts/interfaces/ICurveFi.sol @@ -18,65 +18,23 @@ interface ICurveFi { uint256 min_mint_amount ) external; - function get_dx( - int128 i, - int128 j, - uint256 dy - ) external view returns (uint256 out); - - function get_dx_underlying( - int128 i, - int128 j, - uint256 dy - ) external view returns (uint256 out); - - function get_dy( - int128 i, - int128 j, - uint256 dx - ) external view returns (uint256 out); - - function get_dy_underlying( - int128 i, - int128 j, - uint256 dx - ) external view returns (uint256 out); - - function exchange( - int128 i, - int128 j, - uint256 dx, - uint256 min_dy - ) external payable; - - function exchange( - int128 i, - int128 j, - uint256 dx, - uint256 min_dy, - uint256 deadline - ) external payable; - - function exchange_underlying( - int128 i, - int128 j, - uint256 dx, - uint256 min_dy - ) external payable; - - function exchange_underlying( - int128 i, - int128 j, - uint256 dx, - uint256 min_dy, - uint256 deadline - ) external payable; - - function remove_liquidity( - uint256 _amount, - uint256 deadline, - uint256[2] calldata min_amounts - ) external; + function get_dx(int128 i, int128 j, uint256 dy) external view returns (uint256 out); + + function get_dx_underlying(int128 i, int128 j, uint256 dy) external view returns (uint256 out); + + function get_dy(int128 i, int128 j, uint256 dx) external view returns (uint256 out); + + function get_dy_underlying(int128 i, int128 j, uint256 dx) external view returns (uint256 out); + + function exchange(int128 i, int128 j, uint256 dx, uint256 min_dy) external payable; + + function exchange(int128 i, int128 j, uint256 dx, uint256 min_dy, uint256 deadline) external payable; + + function exchange_underlying(int128 i, int128 j, uint256 dx, uint256 min_dy) external payable; + + function exchange_underlying(int128 i, int128 j, uint256 dx, uint256 min_dy, uint256 deadline) external payable; + + function remove_liquidity(uint256 _amount, uint256 deadline, uint256[2] calldata min_amounts) external; function remove_liquidity_imbalance(uint256[2] calldata amounts, uint256 deadline) external; @@ -88,11 +46,7 @@ interface ICurveFi { function remove_liquidity(uint256 _amount, uint256[4] calldata amounts) external; - function commit_new_parameters( - int128 amplification, - int128 new_fee, - int128 new_admin_fee - ) external; + function commit_new_parameters(int128 amplification, int128 new_fee, int128 new_admin_fee) external; function apply_new_parameters() external; diff --git a/contracts/interfaces/ICurveFiV2.sol b/contracts/interfaces/ICurveFiV2.sol index a45c595b..0097ad46 100644 --- a/contracts/interfaces/ICurveFiV2.sol +++ b/contracts/interfaces/ICurveFiV2.sol @@ -2,17 +2,7 @@ pragma solidity >=0.7.0; interface ICurveFiV2 { - function get_dy( - uint256 i, - uint256 j, - uint256 dx - ) external view returns (uint256 out); + function get_dy(uint256 i, uint256 j, uint256 dx) external view returns (uint256 out); - function exchange( - uint256 i, - uint256 j, - uint256 dx, - uint256 min_dy, - bool use_eth - ) external payable; + function exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy, bool use_eth) external payable; } diff --git a/contracts/interfaces/IEIP2612.sol b/contracts/interfaces/IEIP2612.sol index 47f879f7..411adb50 100644 --- a/contracts/interfaces/IEIP2612.sol +++ b/contracts/interfaces/IEIP2612.sol @@ -8,13 +8,5 @@ interface IEIP2612 is IERC20 { function nonces(address owner) external view returns (uint256); - function permit( - address owner, - address spender, - uint256 value, - uint256 deadline, - uint8 v, - bytes32 r, - bytes32 s - ) external; + function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external; } diff --git a/contracts/interfaces/IERC20Permit.sol b/contracts/interfaces/IERC20Permit.sol index 0a7e4089..9c270c6d 100644 --- a/contracts/interfaces/IERC20Permit.sol +++ b/contracts/interfaces/IERC20Permit.sol @@ -2,13 +2,5 @@ pragma solidity >=0.7.0; interface IERC20Permit { - function permit( - address owner, - address spender, - uint256 value, - uint256 deadline, - uint8 v, - bytes32 r, - bytes32 s - ) external; + function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external; } diff --git a/contracts/interfaces/IOptimismL1StandardBridge.sol b/contracts/interfaces/IOptimismL1StandardBridge.sol index b9ff10c4..741a94ea 100644 --- a/contracts/interfaces/IOptimismL1StandardBridge.sol +++ b/contracts/interfaces/IOptimismL1StandardBridge.sol @@ -15,12 +15,5 @@ interface IOptimismL1StandardBridge { * solely as a convenience for external contracts. Aside from enforcing a maximum * length, these contracts provide no guarantees about its content. */ - function depositERC20To( - address _l1Token, - address _l2Token, - address _to, - uint256 _amount, - uint32 _l2Gas, - bytes calldata _data - ) external; + function depositERC20To(address _l1Token, address _l2Token, address _to, uint256 _amount, uint32 _l2Gas, bytes calldata _data) external; } diff --git a/contracts/interfaces/IPermanentStorage.sol b/contracts/interfaces/IPermanentStorage.sol index 87c08cf8..b5799bad 100644 --- a/contracts/interfaces/IPermanentStorage.sol +++ b/contracts/interfaces/IPermanentStorage.sol @@ -33,22 +33,9 @@ interface IPermanentStorage { address _makerAddr, address _takerAssetAddr, address _makerAssetAddr - ) - external - view - returns ( - int128 takerAssetIndex, - int128 makerAssetIndex, - uint16 swapMethod, - bool supportGetDx - ); - - function setCurvePoolInfo( - address _makerAddr, - address[] calldata _underlyingCoins, - address[] calldata _coins, - bool _supportGetDx - ) external; + ) external view returns (int128 takerAssetIndex, int128 makerAssetIndex, uint16 swapMethod, bool supportGetDx); + + function setCurvePoolInfo(address _makerAddr, address[] calldata _underlyingCoins, address[] calldata _coins, bool _supportGetDx) external; function isAMMTransactionSeen(bytes32 _transactionHash) external view returns (bool); diff --git a/contracts/interfaces/IRFQ.sol b/contracts/interfaces/IRFQ.sol index d1107a9b..7c12eb9f 100644 --- a/contracts/interfaces/IRFQ.sol +++ b/contracts/interfaces/IRFQ.sol @@ -42,9 +42,5 @@ interface IRFQ is IStrategyBase { /// @param _mmSignature The signature of the order from maker /// @param _userSignature The signature of the order from taker /// @return The settled amount of the order - function fill( - RFQLibEIP712.Order memory _order, - bytes memory _mmSignature, - bytes memory _userSignature - ) external payable returns (uint256); + function fill(RFQLibEIP712.Order memory _order, bytes memory _mmSignature, bytes memory _userSignature) external payable returns (uint256); } diff --git a/contracts/interfaces/ISpender.sol b/contracts/interfaces/ISpender.sol index c1d2d5e3..c9e13fac 100644 --- a/contracts/interfaces/ISpender.sol +++ b/contracts/interfaces/ISpender.sol @@ -12,9 +12,5 @@ interface ISpender { event BlackListToken(address token, bool isBlacklisted); event AuthorizeSpender(address spender, bool isAuthorized); - function spendFromUser( - address _user, - address _tokenAddr, - uint256 _amount - ) external; + function spendFromUser(address _user, address _tokenAddr, uint256 _amount) external; } diff --git a/contracts/interfaces/IUniswapPermit2.sol b/contracts/interfaces/IUniswapPermit2.sol index de91f6ad..96cc0947 100644 --- a/contracts/interfaces/IUniswapPermit2.sol +++ b/contracts/interfaces/IUniswapPermit2.sol @@ -36,29 +36,14 @@ interface IUniswapPermit2 { /// @notice A mapping from owner address to token address to spender address to PackedAllowance struct, which contains details and conditions of the approval. /// @notice The mapping is indexed in the above order see: allowance[ownerAddress][tokenAddress][spenderAddress] /// @dev The packed slot holds the allowed amount, expiration at which the allowed amount is no longer valid, and current nonce thats updated on any signature based approvals. - function allowance( - address user, - address token, - address spender - ) - external - view - returns ( - uint160 amount, - uint48 expiration, - uint48 nonce - ); + function allowance(address user, address token, address spender) external view returns (uint160 amount, uint48 expiration, uint48 nonce); /// @notice Permit a spender to a given amount of the owners token via the owner's EIP-712 signature /// @dev May fail if the owner's nonce was invalidated in-flight by invalidateNonce /// @param owner The owner of the tokens being approved /// @param permitSingle Data signed over by the owner specifying the terms of approval /// @param signature The owner's signature over the permit data - function permit( - address owner, - PermitSingle memory permitSingle, - bytes calldata signature - ) external; + function permit(address owner, PermitSingle memory permitSingle, bytes calldata signature) external; /// @notice Transfer approved tokens from one address to another /// @param from The address to transfer from @@ -67,12 +52,7 @@ interface IUniswapPermit2 { /// @param token The token address to transfer /// @dev Requires the from address to have approved at least the desired amount /// of tokens to msg.sender. - function transferFrom( - address from, - address to, - uint160 amount, - address token - ) external; + function transferFrom(address from, address to, uint160 amount, address token) external; /// @notice Approves the spender to use up to amount of the specified token up until the expiration /// @param token The token to approve @@ -81,12 +61,7 @@ interface IUniswapPermit2 { /// @param expiration The timestamp at which the approval is no longer valid /// @dev The packed allowance also holds a nonce, which will stay unchanged in approve /// @dev Setting amount to type(uint160).max sets an unlimited approval - function approve( - address token, - address spender, - uint160 amount, - uint48 expiration - ) external; + function approve(address token, address spender, uint160 amount, uint48 expiration) external; /* * Signature Transfer diff --git a/contracts/interfaces/IUniswapRouterV2.sol b/contracts/interfaces/IUniswapRouterV2.sol index cf71156a..fe21591e 100644 --- a/contracts/interfaces/IUniswapRouterV2.sol +++ b/contracts/interfaces/IUniswapRouterV2.sol @@ -19,13 +19,7 @@ interface IUniswapRouterV2 { uint256 amountBMin, address to, uint256 deadline - ) - external - returns ( - uint256 amountA, - uint256 amountB, - uint256 liquidity - ); + ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity); function addLiquidityETH( address token, @@ -34,14 +28,7 @@ interface IUniswapRouterV2 { uint256 amountETHMin, address to, uint256 deadline - ) - external - payable - returns ( - uint256 amountToken, - uint256 amountETH, - uint256 liquidity - ); + ) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity); function removeLiquidity( address tokenA, diff --git a/contracts/interfaces/IUniswapV3SwapCallback.sol b/contracts/interfaces/IUniswapV3SwapCallback.sol index 55fe333b..e82c5127 100644 --- a/contracts/interfaces/IUniswapV3SwapCallback.sol +++ b/contracts/interfaces/IUniswapV3SwapCallback.sol @@ -13,9 +13,5 @@ interface IUniswapV3SwapCallback { /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by /// the end of the swap. If positive, the callback must send that amount of token1 to the pool. /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call - function uniswapV3SwapCallback( - int256 amount0Delta, - int256 amount1Delta, - bytes calldata data - ) external; + function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external; } diff --git a/contracts/interfaces/IWETH.sol b/contracts/interfaces/IWETH.sol index 37d91942..bea724bd 100644 --- a/contracts/interfaces/IWETH.sol +++ b/contracts/interfaces/IWETH.sol @@ -10,9 +10,5 @@ interface IWETH { function transfer(address dst, uint256 wad) external returns (bool); - function transferFrom( - address src, - address dst, - uint256 wad - ) external returns (bool); + function transferFrom(address src, address dst, uint256 wad) external returns (bool); } diff --git a/contracts/upgradeable/ERC20ForUpgradeable.sol b/contracts/upgradeable/ERC20ForUpgradeable.sol index 6e11f312..7bbdbd36 100644 --- a/contracts/upgradeable/ERC20ForUpgradeable.sol +++ b/contracts/upgradeable/ERC20ForUpgradeable.sol @@ -157,11 +157,7 @@ contract ERC20ForUpgradeable is Context, IERC20 { * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ - function transferFrom( - address sender, - address recipient, - uint256 amount - ) public virtual override returns (bool) { + function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; @@ -217,11 +213,7 @@ contract ERC20ForUpgradeable is Context, IERC20 { * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ - function _transfer( - address sender, - address recipient, - uint256 amount - ) internal virtual { + function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); @@ -285,11 +277,7 @@ contract ERC20ForUpgradeable is Context, IERC20 { * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ - function _approve( - address owner, - address spender, - uint256 amount - ) internal virtual { + function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); @@ -322,9 +310,5 @@ contract ERC20ForUpgradeable is Context, IERC20 { * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ - function _beforeTokenTransfer( - address from, - address to, - uint256 amount - ) internal virtual {} + function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {} } diff --git a/contracts/utils/Asset.sol b/contracts/utils/Asset.sol index dc7b3bf3..c651bbfc 100644 --- a/contracts/utils/Asset.sol +++ b/contracts/utils/Asset.sol @@ -13,11 +13,7 @@ library Asset { return (addr == LibConstant.ETH_ADDRESS || addr == LibConstant.ZERO_ADDRESS); } - function transferTo( - address asset, - address payable to, - uint256 amount - ) internal { + function transferTo(address asset, address payable to, uint256 amount) internal { if (to == address(this)) { return; } diff --git a/contracts/utils/LibConstant.sol b/contracts/utils/LibConstant.sol index cf628010..bb34e6e1 100644 --- a/contracts/utils/LibConstant.sol +++ b/contracts/utils/LibConstant.sol @@ -2,8 +2,8 @@ pragma solidity ^0.7.6; library LibConstant { - int256 internal constant MAX_INT = 2**255 - 1; - uint256 internal constant MAX_UINT = 2**256 - 1; + int256 internal constant MAX_INT = 2 ** 255 - 1; + uint256 internal constant MAX_UINT = 2 ** 256 - 1; uint16 internal constant BPS_MAX = 10000; address internal constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; address internal constant ZERO_ADDRESS = address(0); diff --git a/contracts/utils/LibUniswapV2.sol b/contracts/utils/LibUniswapV2.sol index c45c47f1..1007ef90 100644 --- a/contracts/utils/LibUniswapV2.sol +++ b/contracts/utils/LibUniswapV2.sol @@ -29,11 +29,7 @@ library LibUniswapV2 { return amounts[amounts.length - 1]; } - function _validatePath( - address[] memory _path, - address _tokenIn, - address _tokenOut - ) internal pure { + function _validatePath(address[] memory _path, address _tokenIn, address _tokenOut) internal pure { require(_path.length >= 2, "UniswapV2: Path length must be at least two"); require(_path[0] == _tokenIn, "UniswapV2: First element of path must match token in"); require(_path[_path.length - 1] == _tokenOut, "UniswapV2: Last element of path must match token out"); diff --git a/contracts/utils/LibUniswapV3.sol b/contracts/utils/LibUniswapV3.sol index 2cc2cd69..35b555c6 100644 --- a/contracts/utils/LibUniswapV3.sol +++ b/contracts/utils/LibUniswapV3.sol @@ -64,11 +64,7 @@ library LibUniswapV3 { ); } - function _validatePath( - bytes memory _path, - address _tokenIn, - address _tokenOut - ) internal pure { + function _validatePath(bytes memory _path, address _tokenIn, address _tokenOut) internal pure { (address tokenA, address tokenB, ) = _path.decodeFirstPool(); if (_path.hasMultiplePools()) { diff --git a/contracts/utils/MerkleProof.sol b/contracts/utils/MerkleProof.sol index 45b5fcba..4589169f 100644 --- a/contracts/utils/MerkleProof.sol +++ b/contracts/utils/MerkleProof.sol @@ -11,11 +11,7 @@ library MerkleProof { * sibling hashes on the branch from the leaf to the root of the tree. Each * pair of leaves and each pair of pre-images are assumed to be sorted. */ - function verify( - bytes32[] memory proof, - bytes32 root, - bytes32 leaf - ) internal pure returns (bool) { + function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) { bytes32 computedHash = leaf; for (uint256 i = 0; i < proof.length; ++i) { diff --git a/contracts/utils/SignatureValidator.sol b/contracts/utils/SignatureValidator.sol index 096f83fa..8d203455 100644 --- a/contracts/utils/SignatureValidator.sol +++ b/contracts/utils/SignatureValidator.sol @@ -56,12 +56,7 @@ contract SignatureValidator { * (bytes32 r, bytes32 s, uint8 v, uint256 nonce, SignatureType sigType) * @return isValid True if the address recovered from the provided signature matches the input signer address. */ - function isValidSignature( - address _signerAddress, - bytes32 _hash, - bytes memory _data, - bytes memory _sig - ) public view returns (bool isValid) { + function isValidSignature(address _signerAddress, bytes32 _hash, bytes memory _data, bytes memory _sig) public view returns (bool isValid) { require(_sig.length > 0, "SignatureValidator#isValidSignature: length greater than 0 required"); require(_signerAddress != address(0x0), "SignatureValidator#isValidSignature: invalid signer"); @@ -137,11 +132,7 @@ contract SignatureValidator { /// and defines its own signature verification method. /// @param signature Proof that the hash has been signed by signer. /// @return isValid True if signature is valid for given wallet.. - function isValidWalletSignature( - bytes32 hash, - address walletAddress, - bytes memory signature - ) internal view returns (bool isValid) { + function isValidWalletSignature(bytes32 hash, address walletAddress, bytes memory signature) internal view returns (bool isValid) { bytes memory _calldata = abi.encodeWithSelector(IWallet(walletAddress).isValidSignature.selector, hash, signature); bytes32 magic_salt = bytes32(bytes4(keccak256("isValidWalletSignature(bytes32,address,bytes)"))); assembly { diff --git a/contracts/utils/StrategyBase.sol b/contracts/utils/StrategyBase.sol index 74cd1f81..f9a30ec1 100644 --- a/contracts/utils/StrategyBase.sol +++ b/contracts/utils/StrategyBase.sol @@ -23,13 +23,7 @@ abstract contract StrategyBase is IStrategyBase, Ownable { IPermanentStorage public immutable permStorage; ISpender public spender; - constructor( - address _owner, - address _userProxy, - address _weth, - address _permStorage, - address _spender - ) Ownable(_owner) { + constructor(address _owner, address _userProxy, address _weth, address _permStorage, address _spender) Ownable(_owner) { userProxy = _userProxy; weth = IWETH(_weth); permStorage = IPermanentStorage(_permStorage); diff --git a/contracts/utils/TokenCollector.sol b/contracts/utils/TokenCollector.sol index 93352c8a..f515053b 100644 --- a/contracts/utils/TokenCollector.sol +++ b/contracts/utils/TokenCollector.sol @@ -28,13 +28,7 @@ abstract contract TokenCollector { tokenlonSpender = _tokenlonSpender; } - function _collect( - address token, - address from, - address to, - uint256 amount, - bytes calldata data - ) internal { + function _collect(address token, address from, address to, uint256 amount, bytes calldata data) internal { Source src = Source(uint8(data[0])); if (src == Source.TokenlonSpender) { diff --git a/contracts/utils/UniswapV3PathLib.sol b/contracts/utils/UniswapV3PathLib.sol index 308eb921..6f9bc04f 100644 --- a/contracts/utils/UniswapV3PathLib.sol +++ b/contracts/utils/UniswapV3PathLib.sol @@ -2,11 +2,7 @@ pragma solidity >=0.7.0; library BytesLib { - function slice( - bytes memory _bytes, - uint256 _start, - uint256 _length - ) internal pure returns (bytes memory) { + function slice(bytes memory _bytes, uint256 _start, uint256 _length) internal pure returns (bytes memory) { require(_length + 31 >= _length, "slice_overflow"); require(_start + _length >= _start, "slice_overflow"); require(_bytes.length >= _start + _length, "slice_outOfBounds"); @@ -121,15 +117,7 @@ library Path { /// @return tokenA The first token of the given pool /// @return tokenB The second token of the given pool /// @return fee The fee level of the pool - function decodeFirstPool(bytes memory path) - internal - pure - returns ( - address tokenA, - address tokenB, - uint24 fee - ) - { + function decodeFirstPool(bytes memory path) internal pure returns (address tokenA, address tokenB, uint24 fee) { tokenA = path.toAddress(0); fee = path.toUint24(ADDR_SIZE); tokenB = path.toAddress(NEXT_OFFSET); diff --git a/contracts/xLON.sol b/contracts/xLON.sol index af28d3e4..13d93e00 100644 --- a/contracts/xLON.sol +++ b/contracts/xLON.sol @@ -4,9 +4,5 @@ pragma solidity 0.7.6; import "@openzeppelin/contracts/proxy/TransparentUpgradeableProxy.sol"; contract xLON is TransparentUpgradeableProxy { - constructor( - address _logic, - address _admin, - bytes memory _data - ) payable TransparentUpgradeableProxy(_logic, _admin, _data) {} + constructor(address _logic, address _admin, bytes memory _data) payable TransparentUpgradeableProxy(_logic, _admin, _data) {} } diff --git a/foundry.toml b/foundry.toml index e09c1e6e..17963b28 100644 --- a/foundry.toml +++ b/foundry.toml @@ -7,6 +7,7 @@ optimizer = true # enable or disabl optimizer_runs = 1000 # the number of optimizer runs verbosity = 3 # The verbosity of tests fs_permissions = [{ access = "read", path = "./test/utils/config/"}, { access = "read", path = "./test/signing/payload/"}] +odyssey = true [profile.ci] force = false # whether to ignore the cache (clean build) diff --git a/lib/forge-std b/lib/forge-std index eb980e1d..3b20d60d 160000 --- a/lib/forge-std +++ b/lib/forge-std @@ -1 +1 @@ -Subproject commit eb980e1d4f0e8173ec27da77297ae411840c8ccb +Subproject commit 3b20d60d14b343ee4f908cb8079495c07f5e8981 diff --git a/package.json b/package.json index 399d707a..d1a14ef3 100644 --- a/package.json +++ b/package.json @@ -11,6 +11,7 @@ }, "scripts": { "setup": "yarn install --frozen-lockfile", + "format": "prettier --write .", "check-pretty": "prettier --check .", "lint": "solhint \"contracts/**/*.sol\"", "compile": "forge build --force", diff --git a/poc/L2Deposit/Signing.t.sol b/poc/L2Deposit/Signing.t.sol index 5878bd6d..9fd64b3b 100644 --- a/poc/L2Deposit/Signing.t.sol +++ b/poc/L2Deposit/Signing.t.sol @@ -29,11 +29,7 @@ contract TestL2DepositWrapperSigning is StrategySharedSetup { require(keccak256(sig) == keccak256(expectedSig), "Not expected L2Deposit sig"); } - function _signL2Deposit( - address l2DepositAddr, - uint256 privateKey, - L2DepositLibEIP712.Deposit memory deposit - ) internal returns (bytes memory sig) { + function _signL2Deposit(address l2DepositAddr, uint256 privateKey, L2DepositLibEIP712.Deposit memory deposit) internal returns (bytes memory sig) { bytes32 depositHash = L2DepositLibEIP712._getDepositHash(deposit); bytes32 EIP712SignDigest = getEIP712Hash(computeMainnetEIP712DomainSeparator(l2DepositAddr), depositHash); (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, EIP712SignDigest); diff --git a/test/AllowanceTarget/CompleteSetSpender.t.sol b/test/AllowanceTarget/CompleteSetSpender.t.sol index 71f8c0ac..10a23061 100644 --- a/test/AllowanceTarget/CompleteSetSpender.t.sol +++ b/test/AllowanceTarget/CompleteSetSpender.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/AllowanceTarget/Setup.t.sol"; diff --git a/test/AllowanceTarget/ExecuteCall.t.sol b/test/AllowanceTarget/ExecuteCall.t.sol index 504897d2..8497f082 100644 --- a/test/AllowanceTarget/ExecuteCall.t.sol +++ b/test/AllowanceTarget/ExecuteCall.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/AllowanceTarget/Setup.t.sol"; import "test/utils/BalanceSnapshot.sol"; diff --git a/test/AllowanceTarget/SetSpenderWithTimelock.t.sol b/test/AllowanceTarget/SetSpenderWithTimelock.t.sol index b561017c..8817e996 100644 --- a/test/AllowanceTarget/SetSpenderWithTimelock.t.sol +++ b/test/AllowanceTarget/SetSpenderWithTimelock.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/AllowanceTarget/Setup.t.sol"; diff --git a/test/AllowanceTarget/Setup.t.sol b/test/AllowanceTarget/Setup.t.sol index 88d01870..d4c3d7bf 100644 --- a/test/AllowanceTarget/Setup.t.sol +++ b/test/AllowanceTarget/Setup.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "forge-std/Test.sol"; import "contracts/AllowanceTarget.sol"; diff --git a/test/AllowanceTarget/SetupTest.t.sol b/test/AllowanceTarget/SetupTest.t.sol index 61796072..2201ac74 100644 --- a/test/AllowanceTarget/SetupTest.t.sol +++ b/test/AllowanceTarget/SetupTest.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/AllowanceTarget/Setup.t.sol"; diff --git a/test/AllowanceTarget/Teardown.t.sol b/test/AllowanceTarget/Teardown.t.sol index 9046d8bb..d290b90d 100644 --- a/test/AllowanceTarget/Teardown.t.sol +++ b/test/AllowanceTarget/Teardown.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/AllowanceTarget/Setup.t.sol"; import "test/utils/BalanceSnapshot.sol"; diff --git a/test/LON/Burn.t.sol b/test/LON/Burn.t.sol index 41748c54..4895a990 100644 --- a/test/LON/Burn.t.sol +++ b/test/LON/Burn.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/LON/Setup.t.sol"; diff --git a/test/LON/Constructor.t.sol b/test/LON/Constructor.t.sol index 4fb3544c..c83e898a 100644 --- a/test/LON/Constructor.t.sol +++ b/test/LON/Constructor.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/LON/Setup.t.sol"; diff --git a/test/LON/EmergencyWithdraw.t.sol b/test/LON/EmergencyWithdraw.t.sol index af5a81a5..2a0d46e9 100644 --- a/test/LON/EmergencyWithdraw.t.sol +++ b/test/LON/EmergencyWithdraw.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/LON/Setup.t.sol"; import "test/mocks/MockERC20.sol"; diff --git a/test/LON/Mint.t.sol b/test/LON/Mint.t.sol index 158fd6e7..d32183d4 100644 --- a/test/LON/Mint.t.sol +++ b/test/LON/Mint.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/LON/Setup.t.sol"; diff --git a/test/LON/Permit.t.sol b/test/LON/Permit.t.sol index 29cb0b0f..ad1f7fc7 100644 --- a/test/LON/Permit.t.sol +++ b/test/LON/Permit.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/LON/Setup.t.sol"; import { getEIP712Hash } from "test/utils/Sig.sol"; @@ -88,14 +89,7 @@ contract TestLONPermit is TestLON { * Test Helpers * *********************************/ - function _signPermit(uint256 privateKey, Permit memory permit) - internal - returns ( - uint8, - bytes32, - bytes32 - ) - { + function _signPermit(uint256 privateKey, Permit memory permit) internal returns (uint8, bytes32, bytes32) { bytes32 permitHash = _getPermitHash(permit); bytes32 EIP712SignDigest = getEIP712Hash(lon.DOMAIN_SEPARATOR(), permitHash); diff --git a/test/LON/SetMinter.t.sol b/test/LON/SetMinter.t.sol index 882f4822..22724edb 100644 --- a/test/LON/SetMinter.t.sol +++ b/test/LON/SetMinter.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/LON/Setup.t.sol"; diff --git a/test/LON/Setup.t.sol b/test/LON/Setup.t.sol index be09f258..a44230d3 100644 --- a/test/LON/Setup.t.sol +++ b/test/LON/Setup.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "forge-std/Test.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; diff --git a/test/LONStaking/Permit.t.sol b/test/LONStaking/Permit.t.sol index c1593715..f057190e 100644 --- a/test/LONStaking/Permit.t.sol +++ b/test/LONStaking/Permit.t.sol @@ -83,14 +83,7 @@ contract TestLONStakingPermit is TestLONStaking { * Test Helpers * *********************************/ - function _signPermit(uint256 privateKey, Permit memory permit) - internal - returns ( - uint8, - bytes32, - bytes32 - ) - { + function _signPermit(uint256 privateKey, Permit memory permit) internal returns (uint8, bytes32, bytes32) { bytes32 permitHash = _getPermitHash(permit); bytes32 EIP712SignDigest = getEIP712Hash(lonStaking.DOMAIN_SEPARATOR(), permitHash); diff --git a/test/LONStaking/Redeem.t.sol b/test/LONStaking/Redeem.t.sol index 312224a2..29124234 100644 --- a/test/LONStaking/Redeem.t.sol +++ b/test/LONStaking/Redeem.t.sol @@ -287,11 +287,7 @@ contract TestLONStakingRedeem is TestLONStaking { } } - function testFuzz_RedeemMultipleOneTimeWithBuyback( - uint256[16] memory stakeAmounts, - uint256[16] memory redeemAmounts, - uint256 buybackAmount - ) public { + function testFuzz_RedeemMultipleOneTimeWithBuyback(uint256[16] memory stakeAmounts, uint256[16] memory redeemAmounts, uint256 buybackAmount) public { // Make initial big enough deposit so LON amount will not increase dramatically relative to xLON amount due to buyback // and hence result in later staker getting zero shares lon.mint(makeAddr("initial_depositor"), 10_000_000e18); diff --git a/test/LONStaking/Setup.t.sol b/test/LONStaking/Setup.t.sol index e07429b4..d718cbfe 100644 --- a/test/LONStaking/Setup.t.sol +++ b/test/LONStaking/Setup.t.sol @@ -115,14 +115,7 @@ contract TestLONStaking is Test { uint256[16] memory buybackAmounts, uint256 minStakeAmount, uint256 totalLONAmount - ) - internal - returns ( - uint256[16] memory boundedStakeAmounts, - uint256[16] memory boundedBuybackAmounts, - uint256 newTotalLONAmount - ) - { + ) internal returns (uint256[16] memory boundedStakeAmounts, uint256[16] memory boundedBuybackAmounts, uint256 newTotalLONAmount) { newTotalLONAmount = totalLONAmount; for (uint256 i = 0; i < stakeAmounts.length; i++) { uint256 numStakeAmountLeft = stakeAmounts.length - i - 1; diff --git a/test/LONStaking/StakeWithPermit.t.sol b/test/LONStaking/StakeWithPermit.t.sol index 7d6fb96e..46da60da 100644 --- a/test/LONStaking/StakeWithPermit.t.sol +++ b/test/LONStaking/StakeWithPermit.t.sol @@ -111,14 +111,7 @@ contract TestLONStakingStakeWithPermit is TestLONStaking { ); } - function _signStakeWithPermit(uint256 privateKey, StakeWithPermit memory stakeWithPermit) - internal - returns ( - uint8, - bytes32, - bytes32 - ) - { + function _signStakeWithPermit(uint256 privateKey, StakeWithPermit memory stakeWithPermit) internal returns (uint8, bytes32, bytes32) { bytes32 stakeWithPermitHash = _getStakeWithPermitHash(stakeWithPermit); bytes32 EIP712SignDigest = getEIP712Hash(lon.DOMAIN_SEPARATOR(), stakeWithPermitHash); diff --git a/test/PermanentStorage.t.sol b/test/PermanentStorage.t.sol index b20d9a6f..9d8c4671 100644 --- a/test/PermanentStorage.t.sol +++ b/test/PermanentStorage.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "forge-std/Test.sol"; import "contracts/PermanentStorage.sol"; diff --git a/test/RFQ.t.sol b/test/RFQ.t.sol index 2704a11d..c1ddb9fd 100644 --- a/test/RFQ.t.sol +++ b/test/RFQ.t.sol @@ -2,6 +2,7 @@ pragma solidity 0.7.6; pragma abicoder v2; +import "@openzeppelin/contracts/utils/Address.sol"; import "@openzeppelin/contracts/cryptography/ECDSA.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/math/SafeMath.sol"; @@ -9,11 +10,13 @@ import "contracts/MarketMakerProxy.sol"; import "contracts/RFQ.sol"; import "contracts/utils/SignatureValidator.sol"; import "test/mocks/MockERC1271Wallet.sol"; +import "test/mocks/MockERC7702Wallet.sol"; import "test/utils/BalanceSnapshot.sol"; import "test/utils/StrategySharedSetup.sol"; import { computeMainnetEIP712DomainSeparator, getEIP712Hash } from "test/utils/Sig.sol"; contract RFQTest is StrategySharedSetup { + using Address for address; using SafeMath for uint256; using BalanceSnapshot for BalanceSnapshot.Snapshot; @@ -45,6 +48,7 @@ contract RFQTest is StrategySharedSetup { address[] wallet = [user, maker]; MockERC1271Wallet mockERC1271Wallet; + MockERC7702Wallet mockERC7702Wallet; MarketMakerProxy marketMakerProxy; RFQ rfq; @@ -61,6 +65,7 @@ contract RFQTest is StrategySharedSetup { vm.prank(maker, maker); marketMakerProxy.updateWithdrawWhitelist(maker, true); mockERC1271Wallet = new MockERC1271Wallet(user); + mockERC7702Wallet = new MockERC7702Wallet(); // Deal 100 ETH to each account dealWallet({ wallet: wallet, amount: 100 ether }); @@ -317,6 +322,58 @@ contract RFQTest is StrategySharedSetup { makerMakerAsset.assertChange(-int256(order.makerAssetAmount)); } + function testFillDAIToUSDT_EIP7702UserAndEIP7702Maker() public { + RFQLibEIP712.Order memory order = DEFAULT_ORDER; + bytes memory makerSig = _signOrder({ privateKey: makerPrivateKey, order: order, sigType: SignatureValidator.SignatureType.EIP712 }); + bytes memory userSig = _signFill({ privateKey: userPrivateKey, order: order, sigType: SignatureValidator.SignatureType.EIP712 }); + bytes memory payload = _genFillPayload({ order: order, makerSig: makerSig, userSig: userSig }); + + BalanceSnapshot.Snapshot memory userTakerAsset = BalanceSnapshot.take({ owner: user, token: order.takerAssetAddr }); + BalanceSnapshot.Snapshot memory receiverMakerAsset = BalanceSnapshot.take({ owner: receiver, token: order.makerAssetAddr }); + BalanceSnapshot.Snapshot memory makerTakerAsset = BalanceSnapshot.take({ owner: maker, token: order.takerAssetAddr }); + BalanceSnapshot.Snapshot memory makerMakerAsset = BalanceSnapshot.take({ owner: maker, token: order.makerAssetAddr }); + + vm.signAndAttachDelegation(address(mockERC7702Wallet), userPrivateKey); + vm.signAndAttachDelegation(address(mockERC7702Wallet), makerPrivateKey); + // Verify that taker's account now behaves as a smart contract. + require(user.isContract(), "no code written to user"); + require(maker.isContract(), "no code written to maker"); + + vm.prank(user, user); + userProxy.toRFQ(payload); + + userTakerAsset.assertChange(-int256(order.takerAssetAmount)); + receiverMakerAsset.assertChange(int256(order.makerAssetAmount)); + makerTakerAsset.assertChange(int256(order.takerAssetAmount)); + makerMakerAsset.assertChange(-int256(order.makerAssetAmount)); + } + + function testFillDAIToUSDT_EIP7702UserAndEIP7702Maker_WithEIP1271Method() public { + RFQLibEIP712.Order memory order = DEFAULT_ORDER; + bytes memory makerSig = _signOrder({ privateKey: makerPrivateKey, order: order, sigType: SignatureValidator.SignatureType.WalletBytes32 }); + bytes memory userSig = _signFill({ privateKey: userPrivateKey, order: order, sigType: SignatureValidator.SignatureType.WalletBytes32 }); + bytes memory payload = _genFillPayload({ order: order, makerSig: makerSig, userSig: userSig }); + + BalanceSnapshot.Snapshot memory userTakerAsset = BalanceSnapshot.take({ owner: user, token: order.takerAssetAddr }); + BalanceSnapshot.Snapshot memory receiverMakerAsset = BalanceSnapshot.take({ owner: receiver, token: order.makerAssetAddr }); + BalanceSnapshot.Snapshot memory makerTakerAsset = BalanceSnapshot.take({ owner: maker, token: order.takerAssetAddr }); + BalanceSnapshot.Snapshot memory makerMakerAsset = BalanceSnapshot.take({ owner: maker, token: order.makerAssetAddr }); + + vm.signAndAttachDelegation(address(mockERC7702Wallet), userPrivateKey); + vm.signAndAttachDelegation(address(mockERC7702Wallet), makerPrivateKey); + // Verify that taker's account now behaves as a smart contract. + require(user.isContract(), "no code written to user"); + require(maker.isContract(), "no code written to maker"); + + vm.prank(user, user); + userProxy.toRFQ(payload); + + userTakerAsset.assertChange(-int256(order.takerAssetAmount)); + receiverMakerAsset.assertChange(int256(order.makerAssetAmount)); + makerTakerAsset.assertChange(int256(order.takerAssetAmount)); + makerMakerAsset.assertChange(-int256(order.makerAssetAmount)); + } + function testFillETHToUSDT_EOAUserAndMMPMaker() public { RFQLibEIP712.Order memory order = DEFAULT_ORDER; order.takerAssetAddr = address(weth); @@ -466,22 +523,14 @@ contract RFQTest is StrategySharedSetup { require(keccak256(fillSig) == keccak256(expectedFillSig), "Not expected RFQ fill sig"); } - function _signOrderEIP712( - address rfqAddr, - uint256 privateKey, - RFQLibEIP712.Order memory order - ) internal returns (bytes memory sig) { + function _signOrderEIP712(address rfqAddr, uint256 privateKey, RFQLibEIP712.Order memory order) internal returns (bytes memory sig) { bytes32 orderHash = RFQLibEIP712._getOrderHash(order); bytes32 EIP712SignDigest = getEIP712Hash(computeMainnetEIP712DomainSeparator(rfqAddr), orderHash); (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, EIP712SignDigest); sig = abi.encodePacked(r, s, v, bytes32(0), uint8(2)); } - function _signFillEIP712( - address rfqAddr, - uint256 privateKey, - RFQLibEIP712.Order memory order - ) internal returns (bytes memory sig) { + function _signFillEIP712(address rfqAddr, uint256 privateKey, RFQLibEIP712.Order memory order) internal returns (bytes memory sig) { bytes32 transactionHash = RFQLibEIP712._getTransactionHash(order); bytes32 EIP712SignDigest = getEIP712Hash(computeMainnetEIP712DomainSeparator(rfqAddr), transactionHash); (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, EIP712SignDigest); @@ -492,11 +541,7 @@ contract RFQTest is StrategySharedSetup { * Helpers * *********************************/ - function _signOrder( - uint256 privateKey, - RFQLibEIP712.Order memory order, - SignatureValidator.SignatureType sigType - ) internal returns (bytes memory sig) { + function _signOrder(uint256 privateKey, RFQLibEIP712.Order memory order, SignatureValidator.SignatureType sigType) internal returns (bytes memory sig) { bytes32 orderHash = RFQLibEIP712._getOrderHash(order); bytes32 EIP712SignDigest = getEIP712Hash(rfq.EIP712_DOMAIN_SEPARATOR(), orderHash); @@ -527,11 +572,7 @@ contract RFQTest is StrategySharedSetup { sig = abi.encodePacked(r, s, v, bytes32(0), uint8(sigType)); } - function _signFill( - uint256 privateKey, - RFQLibEIP712.Order memory order, - SignatureValidator.SignatureType sigType - ) internal returns (bytes memory sig) { + function _signFill(uint256 privateKey, RFQLibEIP712.Order memory order, SignatureValidator.SignatureType sigType) internal returns (bytes memory sig) { bytes32 transactionHash = RFQLibEIP712._getTransactionHash(order); bytes32 EIP712SignDigest = getEIP712Hash(rfq.EIP712_DOMAIN_SEPARATOR(), transactionHash); (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, EIP712SignDigest); @@ -551,11 +592,7 @@ contract RFQTest is StrategySharedSetup { sig = abi.encodePacked(r, s, v, bytes32(0), uint8(sigType)); } - function _genFillPayload( - RFQLibEIP712.Order memory order, - bytes memory makerSig, - bytes memory userSig - ) internal view returns (bytes memory payload) { + function _genFillPayload(RFQLibEIP712.Order memory order, bytes memory makerSig, bytes memory userSig) internal view returns (bytes memory payload) { return abi.encodeWithSelector(rfq.fill.selector, order, makerSig, userSig); } } diff --git a/test/Spender.t.sol b/test/Spender.t.sol index 6ffe3b05..013abd0d 100644 --- a/test/Spender.t.sol +++ b/test/Spender.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "forge-std/Test.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; diff --git a/test/TreasuryVester.t.sol b/test/TreasuryVester.t.sol index e28558ec..5dc2ddb9 100644 --- a/test/TreasuryVester.t.sol +++ b/test/TreasuryVester.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "forge-std/Test.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; @@ -161,12 +162,7 @@ contract TreasuryVesterTest is Test { treasuryVester.setRecipient(other); } - function _getVestedAmount( - uint256 vestingAmount, - uint256 lastUpdate, - uint256 beginTimestamp, - uint256 endTimestamp - ) internal view returns (uint256) { + function _getVestedAmount(uint256 vestingAmount, uint256 lastUpdate, uint256 beginTimestamp, uint256 endTimestamp) internal view returns (uint256) { return vestingAmount.mul(block.timestamp - lastUpdate).div(endTimestamp.sub(beginTimestamp)); } diff --git a/test/forkMainnet/AMMQuoter.t.sol b/test/forkMainnet/AMMQuoter.t.sol index 4a040d7f..cf18e2ab 100644 --- a/test/forkMainnet/AMMQuoter.t.sol +++ b/test/forkMainnet/AMMQuoter.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "contracts/AMMQuoter.sol"; import "contracts/interfaces/IBalancerV2Vault.sol"; diff --git a/test/forkMainnet/AMMWrapper/Allowance.t.sol b/test/forkMainnet/AMMWrapper/Allowance.t.sol index dbc63e02..088c7a7c 100644 --- a/test/forkMainnet/AMMWrapper/Allowance.t.sol +++ b/test/forkMainnet/AMMWrapper/Allowance.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/forkMainnet/AMMWrapper/Setup.t.sol"; diff --git a/test/forkMainnet/AMMWrapper/CollectFee.t.sol b/test/forkMainnet/AMMWrapper/CollectFee.t.sol index 35fec134..bc0722d0 100644 --- a/test/forkMainnet/AMMWrapper/CollectFee.t.sol +++ b/test/forkMainnet/AMMWrapper/CollectFee.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "contracts/AMMWrapper.sol"; import "test/forkMainnet/AMMWrapper/Setup.t.sol"; diff --git a/test/forkMainnet/AMMWrapper/DepositETH.t.sol b/test/forkMainnet/AMMWrapper/DepositETH.t.sol index f79ba284..a61544ec 100644 --- a/test/forkMainnet/AMMWrapper/DepositETH.t.sol +++ b/test/forkMainnet/AMMWrapper/DepositETH.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/forkMainnet/AMMWrapper/Setup.t.sol"; diff --git a/test/forkMainnet/AMMWrapper/SetFeeCollector.t.sol b/test/forkMainnet/AMMWrapper/SetFeeCollector.t.sol index 1de7072f..870395c9 100644 --- a/test/forkMainnet/AMMWrapper/SetFeeCollector.t.sol +++ b/test/forkMainnet/AMMWrapper/SetFeeCollector.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/forkMainnet/AMMWrapper/Setup.t.sol"; diff --git a/test/forkMainnet/AMMWrapper/Setup.t.sol b/test/forkMainnet/AMMWrapper/Setup.t.sol index d840b68c..3d74a3d8 100644 --- a/test/forkMainnet/AMMWrapper/Setup.t.sol +++ b/test/forkMainnet/AMMWrapper/Setup.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "contracts/AMMWrapper.sol"; import "contracts/AMMQuoter.sol"; @@ -141,11 +142,7 @@ contract TestAMMWrapper is StrategySharedSetup { sig = abi.encodePacked(r, s, v, bytes32(0), uint8(2)); } - function _genTradePayload( - AMMLibEIP712.Order memory order, - uint256 feeFactor, - bytes memory sig - ) internal pure returns (bytes memory payload) { + function _genTradePayload(AMMLibEIP712.Order memory order, uint256 feeFactor, bytes memory sig) internal pure returns (bytes memory payload) { return abi.encodeWithSignature( "trade(address,address,address,uint256,uint256,uint256,address,address,uint256,uint256,bytes)", diff --git a/test/forkMainnet/AMMWrapper/SetupTest.t.sol b/test/forkMainnet/AMMWrapper/SetupTest.t.sol index 90f6e117..20d7ab6e 100644 --- a/test/forkMainnet/AMMWrapper/SetupTest.t.sol +++ b/test/forkMainnet/AMMWrapper/SetupTest.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/forkMainnet/AMMWrapper/Setup.t.sol"; diff --git a/test/forkMainnet/AMMWrapper/Signing.t.sol b/test/forkMainnet/AMMWrapper/Signing.t.sol index 19aafb4d..ce98c0ab 100644 --- a/test/forkMainnet/AMMWrapper/Signing.t.sol +++ b/test/forkMainnet/AMMWrapper/Signing.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "contracts/utils/AMMLibEIP712.sol"; import "test/utils/StrategySharedSetup.sol"; @@ -29,11 +30,7 @@ contract TestAMMWrapperSigning is StrategySharedSetup { require(keccak256(sig) == keccak256(expectedSig), "Not expected AMM order sig"); } - function _signAMMTrade( - address ammWrapperAddr, - uint256 privateKey, - AMMLibEIP712.Order memory order - ) internal returns (bytes memory sig) { + function _signAMMTrade(address ammWrapperAddr, uint256 privateKey, AMMLibEIP712.Order memory order) internal returns (bytes memory sig) { bytes32 orderHash = AMMLibEIP712._getOrderHash(order); bytes32 EIP712SignDigest = getEIP712Hash(computeMainnetEIP712DomainSeparator(ammWrapperAddr), orderHash); (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, EIP712SignDigest); diff --git a/test/forkMainnet/AMMWrapper/TradeCurveV1.t.sol b/test/forkMainnet/AMMWrapper/TradeCurveV1.t.sol index d5c4443a..e978c052 100644 --- a/test/forkMainnet/AMMWrapper/TradeCurveV1.t.sol +++ b/test/forkMainnet/AMMWrapper/TradeCurveV1.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/forkMainnet/AMMWrapper/Setup.t.sol"; import "test/utils/BalanceSnapshot.sol"; diff --git a/test/forkMainnet/AMMWrapper/TradeSushiswap.t.sol b/test/forkMainnet/AMMWrapper/TradeSushiswap.t.sol index cd8f60d5..98885142 100644 --- a/test/forkMainnet/AMMWrapper/TradeSushiswap.t.sol +++ b/test/forkMainnet/AMMWrapper/TradeSushiswap.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/forkMainnet/AMMWrapper/Setup.t.sol"; import "test/utils/BalanceSnapshot.sol"; diff --git a/test/forkMainnet/AMMWrapper/TradeUniswapV2.t.sol b/test/forkMainnet/AMMWrapper/TradeUniswapV2.t.sol index 57c0a795..759c076c 100644 --- a/test/forkMainnet/AMMWrapper/TradeUniswapV2.t.sol +++ b/test/forkMainnet/AMMWrapper/TradeUniswapV2.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/forkMainnet/AMMWrapper/Setup.t.sol"; import "test/utils/BalanceSnapshot.sol"; diff --git a/test/forkMainnet/AMMWrapper/UpgradeSpender.t.sol b/test/forkMainnet/AMMWrapper/UpgradeSpender.t.sol index 19276f92..e070a10f 100644 --- a/test/forkMainnet/AMMWrapper/UpgradeSpender.t.sol +++ b/test/forkMainnet/AMMWrapper/UpgradeSpender.t.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import "test/forkMainnet/AMMWrapper/Setup.t.sol"; diff --git a/test/forkMainnet/LimitOrder.t.sol b/test/forkMainnet/LimitOrder.t.sol index 36dca8cd..90b4bb6f 100644 --- a/test/forkMainnet/LimitOrder.t.sol +++ b/test/forkMainnet/LimitOrder.t.sol @@ -2,6 +2,7 @@ pragma solidity 0.7.6; pragma abicoder v2; +import "@openzeppelin/contracts/utils/Address.sol"; import "@openzeppelin/contracts/cryptography/ECDSA.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/math/SafeMath.sol"; @@ -13,6 +14,7 @@ import "contracts/utils/LimitOrderLibEIP712.sol"; import "contracts/utils/LibConstant.sol"; import "test/mocks/MockERC1271Wallet.sol"; +import "test/mocks/MockERC7702Wallet.sol"; import "test/utils/BalanceSnapshot.sol"; import "test/utils/StrategySharedSetup.sol"; import "test/utils/UniswapV3Util.sol"; @@ -21,6 +23,7 @@ import { computeMainnetEIP712DomainSeparator, getEIP712Hash } from "test/utils/S contract LimitOrderTest is StrategySharedSetup { using SafeMath for uint256; + using Address for address; using BalanceSnapshot for BalanceSnapshot.Snapshot; event LimitOrderFilledByTrader( @@ -54,6 +57,7 @@ contract LimitOrderTest is StrategySharedSetup { address feeCollector = makeAddr("feeCollector"); address receiver = makeAddr("receiver"); MockERC1271Wallet mockERC1271Wallet = new MockERC1271Wallet(user); + MockERC7702Wallet mockERC7702Wallet = new MockERC7702Wallet(); address[] wallet = [user, maker, coordinator, address(mockERC1271Wallet)]; address[] allowanceAddrs; @@ -697,6 +701,54 @@ contract LimitOrderTest is StrategySharedSetup { userProxy.toLimitOrder(payload); } + function testFullyFillByEIP7702TraderWithEIP712Method() public { + LimitOrderLibEIP712.Fill memory fill = DEFAULT_FILL; + fill.taker = address(user); + + ILimitOrder.TraderParams memory traderParams = DEFAULT_TRADER_PARAMS; + traderParams.taker = address(user); + traderParams.takerSig = _signFill(userPrivateKey, fill, SignatureValidator.SignatureType.EIP712); + + LimitOrderLibEIP712.AllowFill memory allowFill = DEFAULT_ALLOW_FILL; + allowFill.executor = address(user); + + ILimitOrder.CoordinatorParams memory crdParams = DEFAULT_CRD_PARAMS; + crdParams.sig = _signAllowFill(coordinatorPrivateKey, allowFill, SignatureValidator.SignatureType.EIP712); + + bytes memory payload = _genFillByTraderPayload(DEFAULT_ORDER, DEFAULT_ORDER_MAKER_SIG, traderParams, crdParams); + + vm.signAndAttachDelegation(address(mockERC7702Wallet), userPrivateKey); + // Verify that taker's account now behaves as a smart contract. + require(user.isContract(), "no code written to user"); + + vm.prank(user, user); + userProxy.toLimitOrder(payload); + } + + function testFullyFillByEIP7702TraderWithERC1271Method() public { + LimitOrderLibEIP712.Fill memory fill = DEFAULT_FILL; + fill.taker = address(user); + + ILimitOrder.TraderParams memory traderParams = DEFAULT_TRADER_PARAMS; + traderParams.taker = address(user); + traderParams.takerSig = _signFill(userPrivateKey, fill, SignatureValidator.SignatureType.WalletBytes32); + + LimitOrderLibEIP712.AllowFill memory allowFill = DEFAULT_ALLOW_FILL; + allowFill.executor = address(user); + + ILimitOrder.CoordinatorParams memory crdParams = DEFAULT_CRD_PARAMS; + crdParams.sig = _signAllowFill(coordinatorPrivateKey, allowFill, SignatureValidator.SignatureType.EIP712); + + bytes memory payload = _genFillByTraderPayload(DEFAULT_ORDER, DEFAULT_ORDER_MAKER_SIG, traderParams, crdParams); + + vm.signAndAttachDelegation(address(mockERC7702Wallet), userPrivateKey); + // Verify that taker's account now behaves as a smart contract. + require(user.isContract(), "no code written to user"); + + vm.prank(user, user); + userProxy.toLimitOrder(payload); + } + function testFillBySpecificTaker() public { LimitOrderLibEIP712.Order memory order = DEFAULT_ORDER; // order specify taker address @@ -1339,22 +1391,14 @@ contract LimitOrderTest is StrategySharedSetup { require(keccak256(allowFillSig) == keccak256(expectedAllowFillSig), "Not expected LimitOrder allow fill sig"); } - function _signOrderEIP712( - address limitOrderAddr, - uint256 privateKey, - LimitOrderLibEIP712.Order memory order - ) internal returns (bytes memory sig) { + function _signOrderEIP712(address limitOrderAddr, uint256 privateKey, LimitOrderLibEIP712.Order memory order) internal returns (bytes memory sig) { bytes32 orderHash = LimitOrderLibEIP712._getOrderStructHash(order); bytes32 EIP712SignDigest = getEIP712Hash(computeMainnetEIP712DomainSeparator(limitOrderAddr), orderHash); (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, EIP712SignDigest); sig = abi.encodePacked(r, s, v, bytes32(0), uint8(2)); } - function _signFillEIP712( - address limitOrderAddr, - uint256 privateKey, - LimitOrderLibEIP712.Fill memory fill - ) internal returns (bytes memory sig) { + function _signFillEIP712(address limitOrderAddr, uint256 privateKey, LimitOrderLibEIP712.Fill memory fill) internal returns (bytes memory sig) { bytes32 fillHash = LimitOrderLibEIP712._getFillStructHash(fill); bytes32 EIP712SignDigest = getEIP712Hash(computeMainnetEIP712DomainSeparator(limitOrderAddr), fillHash); (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, EIP712SignDigest); @@ -1407,11 +1451,7 @@ contract LimitOrderTest is StrategySharedSetup { sig = abi.encodePacked(r, s, v, bytes32(0), uint8(sigType)); } - function _signFill( - uint256 privateKey, - LimitOrderLibEIP712.Fill memory fill, - SignatureValidator.SignatureType sigType - ) internal returns (bytes memory sig) { + function _signFill(uint256 privateKey, LimitOrderLibEIP712.Fill memory fill, SignatureValidator.SignatureType sigType) internal returns (bytes memory sig) { bytes32 fillHash = LimitOrderLibEIP712._getFillStructHash(fill); bytes32 EIP712SignDigest = getEIP712Hash(limitOrder.EIP712_DOMAIN_SEPARATOR(), fillHash); (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, EIP712SignDigest); @@ -1471,11 +1511,10 @@ contract LimitOrderTest is StrategySharedSetup { return abi.encodeWithSelector(limitOrder.fillLimitOrderByProtocol.selector, order, orderMakerSig, params, crdParams); } - function _genCancelLimitOrderPayload(LimitOrderLibEIP712.Order memory order, bytes memory cancelOrderMakerSig) - internal - view - returns (bytes memory payload) - { + function _genCancelLimitOrderPayload( + LimitOrderLibEIP712.Order memory order, + bytes memory cancelOrderMakerSig + ) internal view returns (bytes memory payload) { return abi.encodeWithSelector(limitOrder.cancelLimitOrder.selector, order, cancelOrderMakerSig); } } diff --git a/test/forkMainnet/RFQv2.t.sol b/test/forkMainnet/RFQv2.t.sol index 3fe1638c..699d8dc8 100644 --- a/test/forkMainnet/RFQv2.t.sol +++ b/test/forkMainnet/RFQv2.t.sol @@ -2,8 +2,10 @@ pragma solidity 0.7.6; pragma abicoder v2; +import { Address } from "@openzeppelin/contracts/utils/Address.sol"; import { ECDSA } from "@openzeppelin/contracts/cryptography/ECDSA.sol"; +import { MockERC7702Wallet } from "test/mocks/MockERC7702Wallet.sol"; import { StrategySharedSetup } from "test/utils/StrategySharedSetup.sol"; import { BalanceSnapshot } from "test/utils/BalanceSnapshot.sol"; import { getEIP712Hash } from "test/utils/Sig.sol"; @@ -19,6 +21,7 @@ import { IUniswapPermit2 } from "contracts/interfaces/IUniswapPermit2.sol"; import { IWETH } from "contracts/interfaces/IWETH.sol"; contract RFQTest is StrategySharedSetup, Permit2Helper { + using Address for address; using BalanceSnapshot for BalanceSnapshot.Snapshot; event FilledRFQ( @@ -50,6 +53,7 @@ contract RFQTest is StrategySharedSetup, Permit2Helper { Offer defaultOffer; RFQOrder defaultOrder; MarketMakerProxy marketMakerProxy; + MockERC7702Wallet mockERC7702Wallet; RFQv2 rfq; function setUp() public { @@ -61,6 +65,7 @@ contract RFQTest is StrategySharedSetup, Permit2Helper { recipient = payable(address(rfq)); marketMakerProxy = new MarketMakerProxy(maker, maker, IWETH(address(weth))); + mockERC7702Wallet = new MockERC7702Wallet(); deal(maker, 100 ether); setEOABalanceAndApprove(maker, tokens, 100000); @@ -265,6 +270,95 @@ contract RFQTest is StrategySharedSetup, Permit2Helper { recMakerToken.assertChange(int256(offer.makerTokenAmount)); } + function testFillRFQWithEIP7702WalletAndERC1271Signature() public { + BalanceSnapshot.Snapshot memory takerTakerToken = BalanceSnapshot.take({ owner: defaultOffer.taker, token: defaultOffer.takerToken }); + BalanceSnapshot.Snapshot memory takerMakerToken = BalanceSnapshot.take({ owner: defaultOffer.taker, token: defaultOffer.makerToken }); + BalanceSnapshot.Snapshot memory makerTakerToken = BalanceSnapshot.take({ owner: defaultOffer.maker, token: defaultOffer.takerToken }); + BalanceSnapshot.Snapshot memory makerMakerToken = BalanceSnapshot.take({ owner: defaultOffer.maker, token: defaultOffer.makerToken }); + BalanceSnapshot.Snapshot memory recTakerToken = BalanceSnapshot.take({ owner: recipient, token: defaultOffer.takerToken }); + BalanceSnapshot.Snapshot memory recMakerToken = BalanceSnapshot.take({ owner: recipient, token: defaultOffer.makerToken }); + BalanceSnapshot.Snapshot memory feeCollectorMakerToken = BalanceSnapshot.take({ owner: feeCollector, token: defaultOffer.makerToken }); + + uint256 fee = (defaultOffer.makerTokenAmount * defaultOffer.feeFactor) / LibConstant.BPS_MAX; + uint256 amountAfterFee = defaultOffer.makerTokenAmount - fee; + vm.expectEmit(true, true, true, true); + emit FilledRFQ( + getOfferHash(defaultOffer), + defaultOffer.taker, + defaultOffer.maker, + defaultOffer.takerToken, + defaultOffer.takerTokenAmount, + defaultOffer.makerToken, + defaultOffer.makerTokenAmount, + defaultOrder.recipient, + amountAfterFee, + defaultOffer.feeFactor + ); + + bytes memory takerSig = _signRFQOrder(takerPrivateKey, defaultOrder, SignatureValidator.SignatureType.WalletBytes32); + bytes memory payload = _genFillRFQPayload(defaultOrder, defaultMakerSig, defaultPermit, takerSig, defaultPermit); + + vm.signAndAttachDelegation(address(mockERC7702Wallet), takerPrivateKey); + require(defaultOffer.taker.isContract(), "no code written to taker"); + + vm.prank(defaultOffer.taker, defaultOffer.taker); + userProxy.toRFQv2(payload); + + takerTakerToken.assertChange(-int256(defaultOffer.takerTokenAmount)); + takerMakerToken.assertChange(int256(0)); + makerTakerToken.assertChange(int256(defaultOffer.takerTokenAmount)); + makerMakerToken.assertChange(-int256(defaultOffer.makerTokenAmount)); + recTakerToken.assertChange(int256(0)); + // recipient gets less than original makerTokenAmount because of the fee for relayer + recMakerToken.assertChange(int256(amountAfterFee)); + feeCollectorMakerToken.assertChange(int256(fee)); + } + + function testFillRFQWithEIP7702WalletAndERC712Signature() public { + BalanceSnapshot.Snapshot memory takerTakerToken = BalanceSnapshot.take({ owner: defaultOffer.taker, token: defaultOffer.takerToken }); + BalanceSnapshot.Snapshot memory takerMakerToken = BalanceSnapshot.take({ owner: defaultOffer.taker, token: defaultOffer.makerToken }); + BalanceSnapshot.Snapshot memory makerTakerToken = BalanceSnapshot.take({ owner: defaultOffer.maker, token: defaultOffer.takerToken }); + BalanceSnapshot.Snapshot memory makerMakerToken = BalanceSnapshot.take({ owner: defaultOffer.maker, token: defaultOffer.makerToken }); + BalanceSnapshot.Snapshot memory recTakerToken = BalanceSnapshot.take({ owner: recipient, token: defaultOffer.takerToken }); + BalanceSnapshot.Snapshot memory recMakerToken = BalanceSnapshot.take({ owner: recipient, token: defaultOffer.makerToken }); + BalanceSnapshot.Snapshot memory feeCollectorMakerToken = BalanceSnapshot.take({ owner: feeCollector, token: defaultOffer.makerToken }); + + uint256 fee = (defaultOffer.makerTokenAmount * defaultOffer.feeFactor) / LibConstant.BPS_MAX; + uint256 amountAfterFee = defaultOffer.makerTokenAmount - fee; + vm.expectEmit(true, true, true, true); + emit FilledRFQ( + getOfferHash(defaultOffer), + defaultOffer.taker, + defaultOffer.maker, + defaultOffer.takerToken, + defaultOffer.takerTokenAmount, + defaultOffer.makerToken, + defaultOffer.makerTokenAmount, + defaultOrder.recipient, + amountAfterFee, + defaultOffer.feeFactor + ); + + bytes memory takerSig = _signRFQOrder(takerPrivateKey, defaultOrder, SignatureValidator.SignatureType.EIP712); + bytes memory payload = _genFillRFQPayload(defaultOrder, defaultMakerSig, defaultPermit, takerSig, defaultPermit); + + vm.signAndAttachDelegation(address(mockERC7702Wallet), takerPrivateKey); + // Verify that taker's account now behaves as a smart contract. + require(defaultOffer.taker.isContract(), "no code written to taker"); + + vm.prank(defaultOffer.taker, defaultOffer.taker); + userProxy.toRFQv2(payload); + + takerTakerToken.assertChange(-int256(defaultOffer.takerTokenAmount)); + takerMakerToken.assertChange(int256(0)); + makerTakerToken.assertChange(int256(defaultOffer.takerTokenAmount)); + makerMakerToken.assertChange(-int256(defaultOffer.makerTokenAmount)); + recTakerToken.assertChange(int256(0)); + // recipient gets less than original makerTokenAmount because of the fee for relayer + recMakerToken.assertChange(int256(amountAfterFee)); + feeCollectorMakerToken.assertChange(int256(fee)); + } + function testFillRFQWithRawETH() public { // case : taker token is ETH Offer memory offer = defaultOffer; @@ -296,6 +390,42 @@ contract RFQTest is StrategySharedSetup, Permit2Helper { recMakerToken.assertChange(int256(offer.makerTokenAmount)); } + function testFillRFQWithEIP7702WalletAndRawETH() public { + // case : taker token is ETH + Offer memory offer = defaultOffer; + offer.takerToken = LibConstant.ZERO_ADDRESS; + offer.takerTokenAmount = 1 ether; + offer.feeFactor = 0; + RFQOrder memory rfqOrder = RFQOrder({ offer: offer, recipient: payable(recipient) }); + + bytes memory makerSig = _signOffer(makerPrivateKey, offer, SignatureValidator.SignatureType.EIP712); + bytes memory takerSig = _signRFQOrder(takerPrivateKey, rfqOrder, SignatureValidator.SignatureType.EIP712); + + BalanceSnapshot.Snapshot memory takerTakerToken = BalanceSnapshot.take({ owner: offer.taker, token: offer.takerToken }); + BalanceSnapshot.Snapshot memory takerMakerToken = BalanceSnapshot.take({ owner: offer.taker, token: offer.makerToken }); + // maker should receive WETH instead + BalanceSnapshot.Snapshot memory makerTakerToken = BalanceSnapshot.take({ owner: offer.maker, token: address(weth) }); + BalanceSnapshot.Snapshot memory makerMakerToken = BalanceSnapshot.take({ owner: offer.maker, token: offer.makerToken }); + BalanceSnapshot.Snapshot memory recTakerToken = BalanceSnapshot.take({ owner: recipient, token: offer.takerToken }); + BalanceSnapshot.Snapshot memory recMakerToken = BalanceSnapshot.take({ owner: recipient, token: offer.makerToken }); + + bytes memory payload = _genFillRFQPayload(rfqOrder, makerSig, defaultPermit, takerSig, defaultPermit); + + vm.signAndAttachDelegation(address(mockERC7702Wallet), takerPrivateKey); + // Verify that taker's account now behaves as a smart contract. + require(offer.taker.isContract(), "no code written to taker"); + + vm.prank(offer.taker, offer.taker); + userProxy.toRFQv2{ value: offer.takerTokenAmount }(payload); + + takerTakerToken.assertChange(-int256(offer.takerTokenAmount)); + takerMakerToken.assertChange(int256(0)); + makerTakerToken.assertChange(int256(offer.takerTokenAmount)); + makerMakerToken.assertChange(-int256(offer.makerTokenAmount)); + recTakerToken.assertChange(int256(0)); + recMakerToken.assertChange(int256(offer.makerTokenAmount)); + } + function testFillRFQTakerGetRawETH() public { // case : maker token is WETH Offer memory offer = defaultOffer; @@ -327,6 +457,42 @@ contract RFQTest is StrategySharedSetup, Permit2Helper { recMakerToken.assertChange(int256(offer.makerTokenAmount)); } + function testFillRFQWithEIP7702TakerGetRawETH() public { + // case : maker token is WETH + Offer memory offer = defaultOffer; + offer.makerToken = address(weth); + offer.makerTokenAmount = 1 ether; + offer.feeFactor = 0; + RFQOrder memory rfqOrder = RFQOrder({ offer: offer, recipient: payable(recipient) }); + + bytes memory makerSig = _signOffer(makerPrivateKey, offer, SignatureValidator.SignatureType.EIP712); + bytes memory takerSig = _signRFQOrder(takerPrivateKey, rfqOrder, SignatureValidator.SignatureType.EIP712); + + BalanceSnapshot.Snapshot memory takerTakerToken = BalanceSnapshot.take({ owner: offer.taker, token: offer.takerToken }); + BalanceSnapshot.Snapshot memory takerMakerToken = BalanceSnapshot.take({ owner: offer.taker, token: offer.makerToken }); + BalanceSnapshot.Snapshot memory makerTakerToken = BalanceSnapshot.take({ owner: offer.maker, token: offer.takerToken }); + BalanceSnapshot.Snapshot memory makerMakerToken = BalanceSnapshot.take({ owner: offer.maker, token: offer.makerToken }); + // recipient should receive raw ETH + BalanceSnapshot.Snapshot memory recTakerToken = BalanceSnapshot.take({ owner: recipient, token: offer.takerToken }); + BalanceSnapshot.Snapshot memory recMakerToken = BalanceSnapshot.take({ owner: recipient, token: LibConstant.ETH_ADDRESS }); + + bytes memory payload = _genFillRFQPayload(rfqOrder, makerSig, defaultPermit, takerSig, defaultPermit); + + vm.signAndAttachDelegation(address(mockERC7702Wallet), takerPrivateKey); + // Verify that taker's account now behaves as a smart contract. + require(offer.taker.isContract(), "no code written to taker"); + + vm.prank(offer.taker, offer.taker); + userProxy.toRFQv2(payload); + + takerTakerToken.assertChange(-int256(offer.takerTokenAmount)); + takerMakerToken.assertChange(int256(0)); + makerTakerToken.assertChange(int256(offer.takerTokenAmount)); + makerMakerToken.assertChange(-int256(offer.makerTokenAmount)); + recTakerToken.assertChange(int256(0)); + recMakerToken.assertChange(int256(offer.makerTokenAmount)); + } + function testFillRFQWithWETH() public { // case : taker token is WETH Offer memory offer = defaultOffer; @@ -487,31 +653,19 @@ contract RFQTest is StrategySharedSetup, Permit2Helper { userProxy.toRFQv2(payload); } - function _signOffer( - uint256 _privateKey, - Offer memory _offer, - SignatureValidator.SignatureType _sigType - ) private view returns (bytes memory sig) { + function _signOffer(uint256 _privateKey, Offer memory _offer, SignatureValidator.SignatureType _sigType) private view returns (bytes memory sig) { bytes32 offerHash = getOfferHash(_offer); bytes32 EIP712SignDigest = getEIP712Hash(rfq.EIP712_DOMAIN_SEPARATOR(), offerHash); return _signEIP712Digest(_privateKey, EIP712SignDigest, _sigType); } - function _signRFQOrder( - uint256 _privateKey, - RFQOrder memory _rfqOrder, - SignatureValidator.SignatureType _sigType - ) private view returns (bytes memory sig) { + function _signRFQOrder(uint256 _privateKey, RFQOrder memory _rfqOrder, SignatureValidator.SignatureType _sigType) private view returns (bytes memory sig) { (, bytes32 rfqOrderHash) = getRFQOrderHash(_rfqOrder); bytes32 EIP712SignDigest = getEIP712Hash(rfq.EIP712_DOMAIN_SEPARATOR(), rfqOrderHash); return _signEIP712Digest(_privateKey, EIP712SignDigest, _sigType); } - function _signEIP712Digest( - uint256 _privateKey, - bytes32 _digest, - SignatureValidator.SignatureType _sigType - ) internal pure returns (bytes memory) { + function _signEIP712Digest(uint256 _privateKey, bytes32 _digest, SignatureValidator.SignatureType _sigType) internal pure returns (bytes memory) { if ( _sigType == SignatureValidator.SignatureType.EIP712 || _sigType == SignatureValidator.SignatureType.WalletBytes || diff --git a/test/forkMainnet/RewardDistributor.t.sol b/test/forkMainnet/RewardDistributor.t.sol index bf313318..93271561 100644 --- a/test/forkMainnet/RewardDistributor.t.sol +++ b/test/forkMainnet/RewardDistributor.t.sol @@ -852,34 +852,24 @@ contract RewardDistributorTest is Addresses { miningTreasuryLON.assertChange(int256(lonToMiningTreasury)); } - function _splitBuyback(SetFeeTokenParams memory feeToken, uint256 buybackAmount) - internal - pure - returns (uint256 buybackToFeeRecipient, uint256 buybackToSwap) - { + function _splitBuyback( + SetFeeTokenParams memory feeToken, + uint256 buybackAmount + ) internal pure returns (uint256 buybackToFeeRecipient, uint256 buybackToSwap) { buybackToFeeRecipient = buybackAmount.mul(feeToken.LFactor).div(100); buybackToSwap = buybackAmount.sub(buybackToFeeRecipient); } - function _splitBuybackLON(SetFeeTokenParams memory feeToken, uint256 lonAmount) - internal - view - returns ( - uint256 lonToTreasury, - uint256 lonToStaking, - uint256 lonToMiningTreasury - ) - { + function _splitBuybackLON( + SetFeeTokenParams memory feeToken, + uint256 lonAmount + ) internal view returns (uint256 lonToTreasury, uint256 lonToStaking, uint256 lonToMiningTreasury) { lonToTreasury = lonAmount.mul(feeToken.RFactor).div(100); lonToStaking = lonAmount.sub(lonToTreasury); lonToMiningTreasury = lonAmount.mul(rewardDistributor.miningFactor()).div(100); } - function _expectBuybackEvent( - SetFeeTokenParams memory feeToken, - uint256 swapAmount, - uint256 lonAmount - ) internal { + function _expectBuybackEvent(SetFeeTokenParams memory feeToken, uint256 swapAmount, uint256 lonAmount) internal { vm.expectEmit(true, true, true, true); emit BuyBack(feeToken.feeTokenAddr, swapAmount, lonAmount, feeToken.LFactor, feeToken.RFactor, feeToken.minBuy, feeToken.maxBuy); } diff --git a/test/forkMainnet/TokenCollector.t.sol b/test/forkMainnet/TokenCollector.t.sol index 54a6a747..f7521516 100644 --- a/test/forkMainnet/TokenCollector.t.sol +++ b/test/forkMainnet/TokenCollector.t.sol @@ -13,13 +13,7 @@ import { StrategySharedSetup } from "test/utils/StrategySharedSetup.sol"; contract Strategy is TokenCollector { constructor(address _uniswapPermit2, address _tokenlonSpender) TokenCollector(_uniswapPermit2, _tokenlonSpender) {} - function collect( - address token, - address from, - address to, - uint256 amount, - bytes calldata data - ) external { + function collect(address token, address from, address to, uint256 amount, bytes calldata data) external { _collect(token, from, to, amount, data); } } @@ -126,12 +120,7 @@ contract TestTokenCollector is StrategySharedSetup, Permit2Helper { return keccak256(abi.encodePacked("\x19\x01", tokenWithPermit.DOMAIN_SEPARATOR(), structHash)); } - function encodeTokenPermitData( - TokenPermit memory permit, - uint8 v, - bytes32 r, - bytes32 s - ) private pure returns (bytes memory) { + function encodeTokenPermitData(TokenPermit memory permit, uint8 v, bytes32 r, bytes32 s) private pure returns (bytes memory) { return abi.encodePacked(TokenCollector.Source.TokenPermit, abi.encode(permit.owner, permit.spender, permit.amount, permit.deadline, v, r, s)); } diff --git a/test/mocks/MockDeflationaryERC20.sol b/test/mocks/MockDeflationaryERC20.sol index d1abb416..ca055492 100644 --- a/test/mocks/MockDeflationaryERC20.sol +++ b/test/mocks/MockDeflationaryERC20.sol @@ -37,21 +37,13 @@ contract MockDeflationaryERC20 is IERC20 { return true; } - function transferFrom( - address sender, - address recipient, - uint256 amount - ) public override returns (bool) { + function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } - function _approve( - address owner, - address spender, - uint256 amount - ) internal { + function _approve(address owner, address spender, uint256 amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); @@ -60,11 +52,7 @@ contract MockDeflationaryERC20 is IERC20 { emit Approval(owner, spender, amount); } - function _transfer( - address sender, - address recipient, - uint256 amount - ) internal { + function _transfer(address sender, address recipient, uint256 amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); diff --git a/test/mocks/MockERC1271Wallet.sol b/test/mocks/MockERC1271Wallet.sol index fe61dc20..cbf8a0bb 100644 --- a/test/mocks/MockERC1271Wallet.sol +++ b/test/mocks/MockERC1271Wallet.sol @@ -14,7 +14,7 @@ contract MockERC1271Wallet is IERC1271Wallet { bytes4 internal constant ERC1271_MAGICVALUE = 0x20c13b0b; // bytes4(keccak256("isValidSignature(bytes32,bytes)")) bytes4 internal constant ERC1271_MAGICVALUE_BYTES32 = 0x1626ba7e; - uint256 private constant MAX_UINT = 2**256 - 1; + uint256 private constant MAX_UINT = 2 ** 256 - 1; address public operator; diff --git a/test/mocks/MockERC20.sol b/test/mocks/MockERC20.sol index f4eb756f..76585fe9 100644 --- a/test/mocks/MockERC20.sol +++ b/test/mocks/MockERC20.sol @@ -4,11 +4,7 @@ pragma solidity 0.7.6; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; contract MockERC20 is ERC20 { - constructor( - string memory _name, - string memory _symbol, - uint8 _decimals - ) ERC20(_name, _symbol) { + constructor(string memory _name, string memory _symbol, uint8 _decimals) ERC20(_name, _symbol) { _setupDecimals(_decimals); } diff --git a/test/mocks/MockERC20Permit.sol b/test/mocks/MockERC20Permit.sol index d888f3a6..596c988e 100644 --- a/test/mocks/MockERC20Permit.sol +++ b/test/mocks/MockERC20Permit.sol @@ -11,9 +11,5 @@ contract MockERC20Permit is ERC20Permit, MockERC20 { // solhint-disable-next-line var-name-mixedcase bytes32 public constant _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); - constructor( - string memory _name, - string memory _symbol, - uint8 _decimals - ) ERC20Permit(_name) MockERC20(_name, _symbol, _decimals) {} + constructor(string memory _name, string memory _symbol, uint8 _decimals) ERC20Permit(_name) MockERC20(_name, _symbol, _decimals) {} } diff --git a/test/mocks/MockERC7702Wallet.sol b/test/mocks/MockERC7702Wallet.sol new file mode 100644 index 00000000..332a3da3 --- /dev/null +++ b/test/mocks/MockERC7702Wallet.sol @@ -0,0 +1,16 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.7.6; + +import "@openzeppelin/contracts/cryptography/ECDSA.sol"; + +contract MockERC7702Wallet { + // bytes4(keccak256("isValidSignature(bytes32,bytes)")) + bytes4 internal constant ERC1271_MAGICVALUE_BYTES32 = 0x1626ba7e; + + receive() external payable {} + + function isValidSignature(bytes32 _hash, bytes calldata _signature) external view returns (bytes4 magicValue) { + require(address(this) == ECDSA.recover(_hash, _signature), "MockERC7702Wallet: invalid signature"); + return ERC1271_MAGICVALUE_BYTES32; + } +} diff --git a/test/mocks/MockNoReturnERC20.sol b/test/mocks/MockNoReturnERC20.sol index 697c1368..a2af11f8 100644 --- a/test/mocks/MockNoReturnERC20.sol +++ b/test/mocks/MockNoReturnERC20.sol @@ -37,20 +37,12 @@ contract MockNoReturnERC20 { _transfer(msg.sender, recipient, amount); } - function transferFrom( - address sender, - address recipient, - uint256 amount - ) public { + function transferFrom(address sender, address recipient, uint256 amount) public { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance")); } - function _approve( - address owner, - address spender, - uint256 amount - ) internal { + function _approve(address owner, address spender, uint256 amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); @@ -59,11 +51,7 @@ contract MockNoReturnERC20 { emit Approval(owner, spender, amount); } - function _transfer( - address sender, - address recipient, - uint256 amount - ) internal { + function _transfer(address sender, address recipient, uint256 amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); diff --git a/test/mocks/MockNoRevertERC20.sol b/test/mocks/MockNoRevertERC20.sol index 41fab0bb..51523f8b 100644 --- a/test/mocks/MockNoRevertERC20.sol +++ b/test/mocks/MockNoRevertERC20.sol @@ -17,11 +17,7 @@ contract MockNoRevertERC20 is ERC20 { return true; } - function transferFrom( - address sender, - address recipient, - uint256 amount - ) public override returns (bool) { + function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { if (balanceOf(msg.sender) < amount || allowance(sender, msg.sender) < amount) { return false; } diff --git a/test/mocks/MockWETH.sol b/test/mocks/MockWETH.sol index e2c6054b..ef144121 100644 --- a/test/mocks/MockWETH.sol +++ b/test/mocks/MockWETH.sol @@ -7,11 +7,7 @@ contract MockWETH is ERC20 { event Deposit(address indexed dst, uint256 wad); event Withdrawal(address indexed src, uint256 wad); - constructor( - string memory _name, - string memory _symbol, - uint8 _decimals - ) ERC20(_name, _symbol) { + constructor(string memory _name, string memory _symbol, uint8 _decimals) ERC20(_name, _symbol) { _setupDecimals(_decimals); } diff --git a/test/utils/AMMUtil.sol b/test/utils/AMMUtil.sol index 4bf4adf2..a1b2b5c4 100644 --- a/test/utils/AMMUtil.sol +++ b/test/utils/AMMUtil.sol @@ -9,11 +9,7 @@ function _encodeUniswapSinglePoolData(uint256 swapType, uint24 poolFee) pure ret return abi.encode(swapType, poolFee); } -function _encodeUniswapMultiPoolData( - uint256 swapType, - address[] memory path, - uint24[] memory poolFees -) pure returns (bytes memory) { +function _encodeUniswapMultiPoolData(uint256 swapType, address[] memory path, uint24[] memory poolFees) pure returns (bytes memory) { return abi.encode(swapType, encodePath(path, poolFees)); } diff --git a/test/utils/Addresses.sol b/test/utils/Addresses.sol index c13f41a5..51bba8e8 100644 --- a/test/utils/Addresses.sol +++ b/test/utils/Addresses.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import { Test, Vm } from "forge-std/Test.sol"; import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; diff --git a/test/utils/BalanceUtil.sol b/test/utils/BalanceUtil.sol index c2ef6b35..ad818848 100644 --- a/test/utils/BalanceUtil.sol +++ b/test/utils/BalanceUtil.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import { stdStorage, StdStorage } from "forge-std/Test.sol"; import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; @@ -11,11 +12,7 @@ contract BalanceUtil is Addresses { using SafeERC20 for IERC20; using stdStorage for StdStorage; - function setERC20Balance( - address tokenAddr, - address userAddr, - uint256 amount - ) internal { + function setERC20Balance(address tokenAddr, address userAddr, uint256 amount) internal { uint256 decimals = uint256(ERC20(tokenAddr).decimals()); // Skip setting WETH's totalSupply because WETH does not store total supply in storage // Only update WETH's totalSupply in local env @@ -23,16 +20,12 @@ contract BalanceUtil is Addresses { deal( tokenAddr, userAddr, - amount * (10**decimals), + amount * (10 ** decimals), updateTotalSupply // also update totalSupply ); } - function approveERC20( - IERC20[] memory tokens, - address userAddr, - address target - ) internal { + function approveERC20(IERC20[] memory tokens, address userAddr, address target) internal { vm.startPrank(userAddr); for (uint256 i = 0; i < tokens.length; i++) { tokens[i].safeApprove(target, type(uint256).max); diff --git a/test/utils/Permit2Helper.sol b/test/utils/Permit2Helper.sol index a7a40911..b190959b 100644 --- a/test/utils/Permit2Helper.sol +++ b/test/utils/Permit2Helper.sol @@ -48,11 +48,7 @@ contract Permit2Helper is Test { return abi.encodePacked(r, s, v); } - function encodeAllowanceTransfer( - address owner, - IUniswapPermit2.PermitSingle memory permit, - bytes memory permitSig - ) public pure returns (bytes memory) { + function encodeAllowanceTransfer(address owner, IUniswapPermit2.PermitSingle memory permit, bytes memory permitSig) public pure returns (bytes memory) { bytes memory permit2Calldata = abi.encode(owner, permit, permitSig); return abi.encodePacked(TokenCollector.Source.Permit2AllowanceTransfer, permit2Calldata); } @@ -62,12 +58,7 @@ contract Permit2Helper is Test { } // will return encoded AllownaceTransfer data - function getTokenlonPermit2Data( - address owner, - uint256 ownerPrivateKey, - address token, - address spender - ) public view returns (bytes memory) { + function getTokenlonPermit2Data(address owner, uint256 ownerPrivateKey, address token, address spender) public view returns (bytes memory) { uint256 expiration = block.timestamp + 1 days; (, , uint48 nonce) = permit2.allowance(owner, token, spender); diff --git a/test/utils/RegisterCurveIndexes.sol b/test/utils/RegisterCurveIndexes.sol index 73e54f02..831938ec 100644 --- a/test/utils/RegisterCurveIndexes.sol +++ b/test/utils/RegisterCurveIndexes.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import { PermanentStorage } from "contracts/PermanentStorage.sol"; import { Addresses, ETH_ADDRESS } from "test/utils/Addresses.sol"; diff --git a/test/utils/StrategySharedSetup.sol b/test/utils/StrategySharedSetup.sol index c8a6a5f9..e1e33475 100644 --- a/test/utils/StrategySharedSetup.sol +++ b/test/utils/StrategySharedSetup.sol @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.7.6; +pragma abicoder v2; import { Test } from "forge-std/Test.sol"; import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; @@ -112,11 +113,7 @@ contract StrategySharedSetup is BalanceUtil, RegisterCurveIndexes { } } - function setEOABalanceAndApprove( - address eoa, - IERC20[] memory tokens, - uint256 amount - ) internal { + function setEOABalanceAndApprove(address eoa, IERC20[] memory tokens, uint256 amount) internal { require(address(allowanceTarget) != address(0), "System contracts not setup yet"); vm.startPrank(eoa); for (uint256 i = 0; i < tokens.length; i++) { @@ -126,12 +123,7 @@ contract StrategySharedSetup is BalanceUtil, RegisterCurveIndexes { vm.stopPrank(); } - function setWalletContractBalanceAndApprove( - address owner, - address walletContract, - IERC20[] memory tokens, - uint256 amount - ) internal { + function setWalletContractBalanceAndApprove(address owner, address walletContract, IERC20[] memory tokens, uint256 amount) internal { require(address(allowanceTarget) != address(0), "System contracts not setup yet"); address[] memory tokenAddresses = new address[](tokens.length); for (uint256 i = 0; i < tokens.length; i++) { diff --git a/test/utils/SushiswapUtil.sol b/test/utils/SushiswapUtil.sol index 2b8ca6d4..65060933 100644 --- a/test/utils/SushiswapUtil.sol +++ b/test/utils/SushiswapUtil.sol @@ -4,10 +4,6 @@ pragma solidity 0.7.6; import "./Addresses.sol"; import "contracts/interfaces/IUniswapRouterV2.sol"; -function getSushiAmountsOut( - address sushiswap, - uint256 amountIn, - address[] memory path -) view returns (uint256[] memory amounts) { +function getSushiAmountsOut(address sushiswap, uint256 amountIn, address[] memory path) view returns (uint256[] memory amounts) { return IUniswapRouterV2(sushiswap).getAmountsOut(amountIn, path); } diff --git a/test/utils/UniswapV3Util.sol b/test/utils/UniswapV3Util.sol index 68a331db..7cca63e0 100644 --- a/test/utils/UniswapV3Util.sol +++ b/test/utils/UniswapV3Util.sol @@ -38,10 +38,6 @@ function encodePath(address[] memory path, uint24[] memory fees) pure returns (b return res; } -function quoteUniswapV3ExactInput( - address uni_v3_quoter, - bytes memory path, - uint256 amountIn -) returns (uint256) { +function quoteUniswapV3ExactInput(address uni_v3_quoter, bytes memory path, uint256 amountIn) returns (uint256) { return IQuoter(uni_v3_quoter).quoteExactInput(path, amountIn); } diff --git a/test/utils/config/local.json b/test/utils/config/local.json index 3d515664..fccd625b 100644 --- a/test/utils/config/local.json +++ b/test/utils/config/local.json @@ -4,32 +4,32 @@ "USDC_ADDRESS": "0x0000000000000000000000000000000000000000", "CRV_ADDRESS": "0x0000000000000000000000000000000000000000", "TUSD_ADDRESS": "0x0000000000000000000000000000000000000000", - "DAI_ADDRESS": "0x000000000000000000000000000000000000000", - "LON_ADDRESS": "0x000000000000000000000000000000000000000", + "DAI_ADDRESS": "0x0000000000000000000000000000000000000000", + "LON_ADDRESS": "0x0000000000000000000000000000000000000000", "WBTC_ADDRESS": "0x0000000000000000000000000000000000000000", - "ANKRETH_ADDRESS": "0x000000000000000000000000000000000000000", + "ANKRETH_ADDRESS": "0x0000000000000000000000000000000000000000", - "UNISWAP_V2_ADDRESS": "0x000000000000000000000000000000000000000", - "SUSHISWAP_ADDRESS": "0x000000000000000000000000000000000000000", - "UNISWAP_V3_ADDRESS": "0x000000000000000000000000000000000000000", - "UNISWAP_V3_QUOTER_ADDRESS": "0x000000000000000000000000000000000000000", - "UNISWAP_PERMIT2_ADDRESS": "0x000000000000000000000000000000000000000", - "CURVE_USDT_POOL_ADDRESS": "0x000000000000000000000000000000000000000", - "CURVE_COMPOUND_POOL_ADDRESS": "0x000000000000000000000000000000000000000", - "CURVE_Y_POOL_ADDRESS": "0x000000000000000000000000000000000000000", - "CURVE_3_POOL_ADDRESS": "0x000000000000000000000000000000000000000", - "CURVE_TRICRYPTO2_POOL_ADDRESS": "0x000000000000000000000000000000000000000", - "CURVE_ANKRETH_POOL_ADDRESS": "0x000000000000000000000000000000000000000", - "BALANCER_V2_ADDRESS": "0x000000000000000000000000000000000000000", + "UNISWAP_V2_ADDRESS": "0x0000000000000000000000000000000000000000", + "SUSHISWAP_ADDRESS": "0x0000000000000000000000000000000000000000", + "UNISWAP_V3_ADDRESS": "0x0000000000000000000000000000000000000000", + "UNISWAP_V3_QUOTER_ADDRESS": "0x0000000000000000000000000000000000000000", + "UNISWAP_PERMIT2_ADDRESS": "0x0000000000000000000000000000000000000000", + "CURVE_USDT_POOL_ADDRESS": "0x0000000000000000000000000000000000000000", + "CURVE_COMPOUND_POOL_ADDRESS": "0x0000000000000000000000000000000000000000", + "CURVE_Y_POOL_ADDRESS": "0x0000000000000000000000000000000000000000", + "CURVE_3_POOL_ADDRESS": "0x0000000000000000000000000000000000000000", + "CURVE_TRICRYPTO2_POOL_ADDRESS": "0x0000000000000000000000000000000000000000", + "CURVE_ANKRETH_POOL_ADDRESS": "0x0000000000000000000000000000000000000000", + "BALANCER_V2_ADDRESS": "0x0000000000000000000000000000000000000000", - "cDAI_ADDRESS": "0x000000000000000000000000000000000000000", - "cUSDC_ADDRESS": "0x000000000000000000000000000000000000000", - "yDAI_ADDRESS": "0x000000000000000000000000000000000000000", - "yUSDC_ADDRESS": "0x000000000000000000000000000000000000000", - "yUSDT_ADDRESS": "0x000000000000000000000000000000000000000", - "yTUSD_ADDRESS": "0x000000000000000000000000000000000000000", + "cDAI_ADDRESS": "0x0000000000000000000000000000000000000000", + "cUSDC_ADDRESS": "0x0000000000000000000000000000000000000000", + "yDAI_ADDRESS": "0x0000000000000000000000000000000000000000", + "yUSDC_ADDRESS": "0x0000000000000000000000000000000000000000", + "yUSDT_ADDRESS": "0x0000000000000000000000000000000000000000", + "yTUSD_ADDRESS": "0x0000000000000000000000000000000000000000", - "ARBITRUM_L1_GATEWAY_ROUTER_ADDR": "0x000000000000000000000000000000000000000", - "ARBITRUM_L1_BRIDGE_ADDR": "0x000000000000000000000000000000000000000", - "OPTIMISM_L1_STANDARD_BRIDGE_ADDR": "0x000000000000000000000000000000000000000" + "ARBITRUM_L1_GATEWAY_ROUTER_ADDR": "0x0000000000000000000000000000000000000000", + "ARBITRUM_L1_BRIDGE_ADDR": "0x0000000000000000000000000000000000000000", + "OPTIMISM_L1_STANDARD_BRIDGE_ADDR": "0x0000000000000000000000000000000000000000" }