From 03b43e49da6d3ef70b4ba318eb3db50940c0ea8a Mon Sep 17 00:00:00 2001 From: xhad Date: Sat, 19 Oct 2024 00:54:34 +0800 Subject: [PATCH 1/2] Convert to ETH starter vault --- script/Actors.sol | 44 +- script/Contracts.sol | 21 +- script/Deploy.s.sol | 43 +- src/IVaultFactory.sol | 45 -- src/SingleVault.sol | 91 ++- src/VaultFactory.sol | 47 +- src/{ => interface}/ISingleVault.sol | 10 +- src/interface/IVaultFactory.sol | 24 + src/interface/IWETH.sol | 15 + test/factory/create.t.sol | 30 +- test/helpers/Assets.sol | 17 +- test/helpers/Etches.sol | 11 +- test/helpers/Setup.sol | 28 +- test/mocks/MockWETH.sol | 754 ++++++++++++++++++++++++ test/single/integration/ynBNB.bsc.t.sol | 268 ++++----- test/single/unit/access.t.sol | 4 +- test/single/unit/admin.t.sol | 84 --- test/single/unit/deposit.t.sol | 17 +- test/single/unit/initialize.t.sol | 12 +- test/single/unit/invariants.sol | 19 +- test/single/unit/upgrade.t.sol | 6 +- test/single/unit/withdraw.t.sol | 14 +- 22 files changed, 1092 insertions(+), 512 deletions(-) delete mode 100644 src/IVaultFactory.sol rename src/{ => interface}/ISingleVault.sol (70%) create mode 100644 src/interface/IVaultFactory.sol create mode 100644 src/interface/IWETH.sol create mode 100644 test/mocks/MockWETH.sol delete mode 100644 test/single/unit/admin.t.sol diff --git a/script/Actors.sol b/script/Actors.sol index 8e47dc0..30a8850 100644 --- a/script/Actors.sol +++ b/script/Actors.sol @@ -5,62 +5,26 @@ interface IActors { function ADMIN() external view returns (address); function UNAUTHORIZED() external view returns (address); function PROPOSER_1() external view returns (address); - function PROPOSER_2() external view returns (address); function EXECUTOR_1() external view returns (address); - function EXECUTOR_2() external view returns (address); } contract LocalActors is IActors { address public constant ADMIN = address(1); address public constant UNAUTHORIZED = address(3); - address public constant PROPOSER_1 = address(1); - address public constant PROPOSER_2 = address(2); - address public constant EXECUTOR_1 = address(3); - address public constant EXECUTOR_2 = address(4); -} - -contract AnvilActors is IActors { - address public constant ADMIN = 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266; - address public constant UNAUTHORIZED = address(0); - - address public constant PROPOSER_1 = 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266; - address public constant PROPOSER_2 = 0x70997970C51812dc3A010C7d01b50e0d17dc79C8; - - address public constant EXECUTOR_1 = 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266; - address public constant EXECUTOR_2 = 0x70997970C51812dc3A010C7d01b50e0d17dc79C8; } contract HoleskyActors is IActors { address public constant ADMIN = 0x743b91CDB1C694D4F51bCDA3a4A59DcC0d02b913; address public constant UNAUTHORIZED = address(0); - address public constant PROPOSER_1 = 0x743b91CDB1C694D4F51bCDA3a4A59DcC0d02b913; - address public constant PROPOSER_2 = 0x9Dd8F69b62ddFd990241530F47dcEd0Dad7f7d39; - address public constant EXECUTOR_1 = 0x743b91CDB1C694D4F51bCDA3a4A59DcC0d02b913; - address public constant EXECUTOR_2 = 0x9Dd8F69b62ddFd990241530F47dcEd0Dad7f7d39; -} - -contract ChapelActors is IActors { - address public constant ADMIN = 0x0c099101d43e9094E4ae9bC2FC38f8b9875c23c5; - address public constant UNAUTHORIZED = address(0); - - address public constant PROPOSER_1 = 0x9f0A34ccb5ba9C71336F0c8Cd6181205928B8404; - address public constant PROPOSER_2 = 0x9f0A34ccb5ba9C71336F0c8Cd6181205928B8404; - - address public constant EXECUTOR_1 = 0x9f0A34ccb5ba9C71336F0c8Cd6181205928B8404; - address public constant EXECUTOR_2 = 0x9f0A34ccb5ba9C71336F0c8Cd6181205928B8404; } -contract BscActors is IActors { - address public constant ADMIN = 0x721688652DEa9Cabec70BD99411EAEAB9485d436; +contract MainnetActors is IActors { + address public constant ADMIN = 0xfcad670592a3b24869C0b51a6c6FDED4F95D6975; address public constant UNAUTHORIZED = address(0); - - address public constant PROPOSER_1 = 0x721688652DEa9Cabec70BD99411EAEAB9485d436; - address public constant PROPOSER_2 = 0x721688652DEa9Cabec70BD99411EAEAB9485d436; - - address public constant EXECUTOR_1 = 0x721688652DEa9Cabec70BD99411EAEAB9485d436; - address public constant EXECUTOR_2 = 0x721688652DEa9Cabec70BD99411EAEAB9485d436; + address public constant PROPOSER_1 = 0xfcad670592a3b24869C0b51a6c6FDED4F95D6975; + address public constant EXECUTOR_1 = 0xfcad670592a3b24869C0b51a6c6FDED4F95D6975; } diff --git a/script/Contracts.sol b/script/Contracts.sol index eeeea2f..7d1ef38 100644 --- a/script/Contracts.sol +++ b/script/Contracts.sol @@ -1,23 +1,10 @@ // SPDX-License-Identifier: BSD-3-Clause pragma solidity ^0.8.24; -contract ChapelContracts { - address public constant ACTORS = 0xbA02225f0fdB684c80ad1e829FC31f048c416Ce6; - address public constant VAULT_FACTORY = 0x964C6d4050e052D627b8234CAD9CdF0981E40EB3; - address public constant SINGLE_VAULT = 0xa2aE2b28c578Fbd7C18B554E7aA388Bf6694a42c; - address public constant KERNEL_VAULT = address(0); - address public constant KARAK_KslisBNB = address(0); - address public constant KARAK_SUPERVISOR = address(0); - address public constant slisBNB = 0x80815ee920Bd9d856562633C36D3eB0E43cb15e2; +library HoleskyContracts { + address public constant WETH = 0x94373a4919B3240D86eA41593D5eBa789FEF3848; } -contract BscContracts { - address public constant ACTORS = 0x1AA714a271047fA5AAFD190F084b66aA77Ba3562; - address public constant VAULT_FACTORY = 0xf6B9b69B7e13D37D3846698bA2625e404C7586aF; - address public constant SINGLE_VAULT = 0x40020796C11750975aD8758a1F2ab725f6b72Db2; - address public constant KERNEL_VAULT = address(0); - address public constant KARAK_KslisBNB = 0x8529019503c5BD707d8Eb98C5C87bF5237F89135; - address public constant KARAK_VAULT_SUPERVISOR = 0x4a2b015CcB8658998692Db9eD4522B8e846962eD; - address public constant slisBNB = 0xB0b84D294e0C75A6abe60171b70edEb2EFd14A1B; - address public constant ListaStakeManager = 0x1adB950d8bB3dA4bE104211D5AB038628e477fE6; +library MainnetContracts { + address public constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; } diff --git a/script/Deploy.s.sol b/script/Deploy.s.sol index 3e4ccfb..06db436 100644 --- a/script/Deploy.s.sol +++ b/script/Deploy.s.sol @@ -4,64 +4,53 @@ pragma solidity ^0.8.24; import "lib/forge-std/src/Script.sol"; import {VaultFactory} from "src/VaultFactory.sol"; -import {IVaultFactory} from "src/IVaultFactory.sol"; -import {AnvilActors, HoleskyActors, ChapelActors, BscActors, IActors} from "script/Actors.sol"; +import {IVaultFactory} from "src/interface/IVaultFactory.sol"; +import {IActors, MainnetActors, HoleskyActors} from "script/Actors.sol"; +import {MainnetContracts,HoleskyContracts} from "script/Contracts.sol"; import {SingleVault} from "src/SingleVault.sol"; import {TransparentUpgradeableProxy, TimelockController} from "src/Common.sol"; contract DeployVaultFactory is Script { + function run() public { - if (block.chainid == 31337) { - vm.startBroadcast(); - AnvilActors actors = new AnvilActors(); - uint256 minDelay = 10; // seconds - deployVaultFactory(actors, minDelay); - } if (block.chainid == 17000) { vm.startBroadcast(); HoleskyActors actors = new HoleskyActors(); uint256 minDelay = 10; // seconds - deployVaultFactory(actors, minDelay); - } - - if (block.chainid == 97) { - vm.startBroadcast(); - ChapelActors actors = new ChapelActors(); - uint256 minDelay = 10; // seconds - deployVaultFactory(actors, minDelay); + address weth = HoleskyContracts.WETH; + deployVaultFactory(actors, minDelay, weth); } - if (block.chainid == 56) { + if (block.chainid == 1 || block.chainid == 31337) { vm.startBroadcast(); - BscActors actors = new BscActors(); - uint256 minDelay = 86400; // 24 hours in seconds - deployVaultFactory(actors, minDelay); + MainnetActors actors = new MainnetActors(); + uint256 minDelay = 86400; // seconds + address weth = MainnetContracts.WETH; + deployVaultFactory(actors, minDelay, weth); } } - function deployVaultFactory(IActors actors, uint256 minDelay) public returns (address) { + function deployVaultFactory(IActors actors, uint256 minDelay, address weth) public returns (address) { address vaultFactoryImpl = address(new VaultFactory()); address singleVaultImpl = address(new SingleVault()); - address[] memory proposers = new address[](2); + address[] memory proposers = new address[](1); proposers[0] = actors.PROPOSER_1(); - proposers[1] = actors.PROPOSER_2(); - address[] memory executors = new address[](2); + address[] memory executors = new address[](1); executors[0] = actors.EXECUTOR_1(); - executors[1] = actors.EXECUTOR_2(); address admin = actors.ADMIN(); - string memory funcSig = "initialize(address,address,address)"; + string memory funcSig = "initialize(address,address,address,address)"; TimelockController timelock = new TimelockController(minDelay, proposers, executors, admin); TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy( vaultFactoryImpl, address(timelock), - abi.encodeWithSignature(funcSig, singleVaultImpl, admin, address(timelock)) + abi.encodeWithSignature(funcSig, singleVaultImpl, admin, address(timelock), weth) ); return address(proxy); } diff --git a/src/IVaultFactory.sol b/src/IVaultFactory.sol deleted file mode 100644 index 75edec1..0000000 --- a/src/IVaultFactory.sol +++ /dev/null @@ -1,45 +0,0 @@ -// SPDX-License-Identifier: BSD-3-Clause -pragma solidity ^0.8.24; - -import {IERC20, IERC4626, IAccessControl} from "src/Common.sol"; - -interface IVaultFactory is IAccessControl { - enum VaultType { - SingleAsset, - MultiAsset - } - - /** - * @dev Represents a vault with its timelock, name, symbol, and type. - * @param timelock The address of the timelock controller for the vault. - * @param name The name of the vault. - * @param symbol The symbol of the vault. - * @param vaultType The type of the vault, either SingleAsset or MultiAsset. - */ - struct Vault { - address timelock; - string name; - string symbol; - VaultType vaultType; - } - - function timelock() external view returns (address); - - function singleVaultImpl() external view returns (address); - - function multiVaultImpl() external view returns (address); - - function initialize(address singleVaultImpl_, address admin, address timelock_) external; - - function createSingleVault( - IERC20 asset_, - string memory name_, - string memory symbol_, - address admin_, - uint256 minDelay_, - address[] memory proposers_, - address[] memory executors_ - ) external returns (address); - - function setVaultVersion(address implementation_, VaultType vaultType) external; -} diff --git a/src/SingleVault.sol b/src/SingleVault.sol index ef68255..601945a 100644 --- a/src/SingleVault.sol +++ b/src/SingleVault.sol @@ -3,47 +3,34 @@ pragma solidity ^0.8.24; import { ERC4626Upgradeable, + AccessControlUpgradeable, ReentrancyGuardUpgradeable, - TimelockControllerUpgradeable, IERC20, - IERC4626, - IStakeManager, Math } from "src/Common.sol"; -import {ISingleVault} from "src/ISingleVault.sol"; +import {ISingleVault} from "src/interface/ISingleVault.sol"; -contract SingleVault is ISingleVault, ERC4626Upgradeable, TimelockControllerUpgradeable, ReentrancyGuardUpgradeable { - using Math for uint256; +/* ynETH Pre-Launch Vault */ - bytes32 private constant ERC4626StorageLocation = 0x0773e532dfede91f04b12a73d3d2acd361424f41f76b4fb79f090161e36b4e00; - IStakeManager private constant stakeManager = IStakeManager(0x1adB950d8bB3dA4bE104211D5AB038628e477fE6); +contract SingleVault is ISingleVault, + ERC4626Upgradeable, + AccessControlUpgradeable, + ReentrancyGuardUpgradeable +{ + using Math for uint256; constructor() { _disableInitializers(); } - /** - * @dev Initializes the SingleVault contract. - * @param asset_ The address of the ERC20 asset. - * @param name_ The name of the vault. - * @param symbol_ The symbol of the vault. - * @param admin_ The address of the admin. - * @param minDelay_ The minimum delay for timelock. - * @param proposers_ The addresses of the proposers. - * @param executors_ The addresses of the executors. - */ function initialize( IERC20 asset_, string memory name_, string memory symbol_, - address admin_, - uint256 minDelay_, - address[] calldata proposers_, - address[] calldata executors_ + address admin_ ) public initializer { - _verifyParamsAreValid(asset_, name_, symbol_, admin_, proposers_, executors_); - __TimelockController_init(minDelay_, proposers_, executors_, admin_); + _verifyParamsAreValid(asset_, name_, symbol_, admin_); __ERC20_init(name_, symbol_); __ERC4626_init(asset_); __AccessControl_init(); @@ -51,49 +38,45 @@ contract SingleVault is ISingleVault, ERC4626Upgradeable, TimelockControllerUpgr _grantRole(DEFAULT_ADMIN_ROLE, admin_); } + receive() external payable nonReentrant() { + if (msg.value > 0) { + _mintSharesForETH(msg.value); + } + } + + fallback() external payable nonReentrant() { + if (msg.value > 0) { + _mintSharesForETH(msg.value); + } + } + + function _mintSharesForETH(uint256 amount) private { + + IERC20 weth = _retrieveERC4626Storage()._asset; + + (bool success,) = address(weth).call{value: amount}(""); + if (!success) revert DepositFailed(); + + if (msg.sender != address(this)) { + _mint(msg.sender, amount); + } + } + function _verifyParamsAreValid( IERC20 asset_, string memory name_, string memory symbol_, - address admin_, - address[] calldata proposers_, - address[] calldata executors_ + address admin_ ) internal pure { if (asset_ == IERC20(address(0))) revert AssetZeroAddress(); if (bytes(name_).length == 0) revert NameEmpty(); if (bytes(symbol_).length == 0) revert SymbolEmpty(); if (admin_ == address(0)) revert AdminZeroAddress(); - if (proposers_.length == 0) revert ProposersEmpty(); - if (executors_.length == 0) revert ExecutorsEmpty(); } function _retrieveERC4626Storage() internal pure returns (ERC4626Storage storage $) { assembly { - $.slot := ERC4626StorageLocation + $.slot := 0x0773e532dfede91f04b12a73d3d2acd361424f41f76b4fb79f090161e36b4e00 } } - - function totalAssets() public view override(ERC4626Upgradeable, IERC4626) returns (uint256) { - ERC4626Storage storage $ = _retrieveERC4626Storage(); - uint256 assetBalance = $._asset.balanceOf(address(this)); - return _convertSnBnbToBnb(assetBalance); - } - - function _convertSnBnbToBnb(uint256 amount) internal view returns (uint256) { - return stakeManager.convertSnBnbToBnb(amount); - } - - function _convertBnbToSnBnb(uint256 amount) internal view returns (uint256) { - return stakeManager.convertBnbToSnBnb(amount); - } - - function _convertToShares(uint256 assets, Math.Rounding rounding) internal view override returns (uint256) { - uint256 bnbAssets = _convertSnBnbToBnb(assets); - return bnbAssets.mulDiv(totalSupply() + 10 ** _decimalsOffset(), totalAssets() + 1, rounding); - } - - function _convertToAssets(uint256 shares, Math.Rounding rounding) internal view override returns (uint256) { - uint256 bnbShares = shares.mulDiv(totalAssets() + 1, totalSupply() + 10 ** _decimalsOffset(), rounding); - return _convertBnbToSnBnb(bnbShares); - } } diff --git a/src/VaultFactory.sol b/src/VaultFactory.sol index d3fbebc..26b955c 100644 --- a/src/VaultFactory.sol +++ b/src/VaultFactory.sol @@ -3,7 +3,8 @@ pragma solidity ^0.8.24; import {AccessControlUpgradeable, TransparentUpgradeableProxy, IERC20, IERC4626} from "src/Common.sol"; -import {IVaultFactory} from "src/IVaultFactory.sol"; +import {IVaultFactory} from "src/interface/IVaultFactory.sol"; +import {IWETH} from "src/interface/IWETH.sol"; contract VaultFactory is IVaultFactory, AccessControlUpgradeable { /// @dev This timelock is the Vault Proxy Admin. @@ -12,16 +13,14 @@ contract VaultFactory is IVaultFactory, AccessControlUpgradeable { /// @dev The address of the SingleVault implementation contract. address public singleVaultImpl; - /// @dev The address of the MultiVault implementation contract. - address public multiVaultImpl; - - /// @dev Mapping of vault addresses to their respective Vault structs. - mapping(address => Vault) public vaults; + IWETH public weth; event NewVault(address indexed vault, string name, string symbol, VaultType vaultType); event SetVersion(address indexed implementation, VaultType vaultType); + event WethReturned(address receiver, uint256 amount); error ZeroAddress(); + error InvalidWethAddress(); constructor() { _disableInitializers(); @@ -33,13 +32,14 @@ contract VaultFactory is IVaultFactory, AccessControlUpgradeable { * @param admin The address of the administrator. * @param timelock_ The Vault admin for proxy upgrades */ - function initialize(address singleVaultImpl_, address admin, address timelock_) external initializer { + function initialize(address singleVaultImpl_, address admin, address timelock_, address weth_) external initializer { _grantRole(DEFAULT_ADMIN_ROLE, admin); // NOTES: There are two timelocks. This timelock is for vault upgrades but // the vault is the second timelock controller, which has the same proposers and executors // as the proxy admins singleVaultImpl = singleVaultImpl_; timelock = timelock_; + weth = IWETH(payable(weth_)); } /** @@ -47,31 +47,26 @@ contract VaultFactory is IVaultFactory, AccessControlUpgradeable { * @param asset_ The ERC20 asset to be used by the vault. * @param name_ The name of the vault. * @param symbol_ The symbol of the vault. - * @param admin_ The address of the admin. - * @param minDelay_ The timelock delay for transactions. - * @param proposers_ Array of transaction proposers. - * @param executors_ Array of transaction executors. + * @param admin_ The address of the timelock. * @return address The address of the newly created vault. */ function createSingleVault( IERC20 asset_, string memory name_, string memory symbol_, - address admin_, - uint256 minDelay_, - address[] memory proposers_, - address[] memory executors_ + address admin_ ) public onlyRole(DEFAULT_ADMIN_ROLE) returns (address) { - string memory funcSig = "initialize(address,string,string,address,uint256,address[],address[])"; + string memory funcSig = "initialize(address,string,string,address)"; + + if (address(asset_) != address(weth)) revert InvalidWethAddress(); TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy( singleVaultImpl, timelock, - abi.encodeWithSignature(funcSig, asset_, name_, symbol_, admin_, minDelay_, proposers_, executors_) + abi.encodeWithSignature(funcSig, asset_, name_, symbol_, admin_) ); - vaults[address(proxy)] = Vault(address(timelock), name_, symbol_, VaultType.SingleAsset); - // bootstrap 1 ether of underlying to prevent donation attacks + // bootstrap 1 ether of weth to prevent donation attacks IERC20(asset_).approve(address(proxy), 1 ether); IERC4626(address(proxy)).deposit(1 ether, admin_); emit NewVault(address(proxy), name_, symbol_, VaultType.SingleAsset); @@ -79,13 +74,13 @@ contract VaultFactory is IVaultFactory, AccessControlUpgradeable { } /** - * @dev Sets the SingleVault implementation contract address. - * @param implementation_ The address of the SingleVault implementation contract. - * @param vaultType Enum VaultType + * @dev Returns the WETH that was deposited to the factory. + * @param receiver The address to receiver the boostrapped weth. */ - function setVaultVersion(address implementation_, VaultType vaultType) public onlyRole(DEFAULT_ADMIN_ROLE) { - if (implementation_ == address(0)) revert ZeroAddress(); - vaultType == VaultType.SingleAsset ? singleVaultImpl = implementation_ : multiVaultImpl = implementation_; - emit SetVersion(implementation_, vaultType); + function getDepositedWETH(address receiver) public onlyRole(DEFAULT_ADMIN_ROLE) { + uint256 balance = IERC20(weth).balanceOf(address(this)); + IERC20(weth).approve(receiver, balance); + IERC20(weth).transfer(receiver, balance); + emit WethReturned(receiver, balance); } } diff --git a/src/ISingleVault.sol b/src/interface/ISingleVault.sol similarity index 70% rename from src/ISingleVault.sol rename to src/interface/ISingleVault.sol index cd3b401..1353759 100644 --- a/src/ISingleVault.sol +++ b/src/interface/ISingleVault.sol @@ -8,16 +8,12 @@ interface ISingleVault is IERC20, IERC4626, IAccessControl { error NameEmpty(); error SymbolEmpty(); error AdminZeroAddress(); - error ProposersEmpty(); - error ExecutorsEmpty(); - + error DepositFailed(); + function initialize( IERC20 asset_, string calldata name_, string calldata symbol_, - address admin_, - uint256 minDelay_, - address[] calldata proposers_, - address[] calldata executors_ + address admin_ ) external; } diff --git a/src/interface/IVaultFactory.sol b/src/interface/IVaultFactory.sol new file mode 100644 index 0000000..7f24e38 --- /dev/null +++ b/src/interface/IVaultFactory.sol @@ -0,0 +1,24 @@ +// SPDX-License-Identifier: BSD-3-Clause +pragma solidity ^0.8.24; + +import {IERC20, IERC4626, IAccessControl} from "src/Common.sol"; + +interface IVaultFactory is IAccessControl { + enum VaultType { + SingleAsset, + MultiAsset + } + + function timelock() external view returns (address); + + function singleVaultImpl() external view returns (address); + + function initialize(address singleVaultImpl_, address admin, address timelock_, address weth_) external; + + function createSingleVault( + IERC20 asset_, + string memory name_, + string memory symbol_, + address admin_ + ) external returns (address); +} diff --git a/src/interface/IWETH.sol b/src/interface/IWETH.sol new file mode 100644 index 0000000..46a13ea --- /dev/null +++ b/src/interface/IWETH.sol @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: BSD-3-Clause +pragma solidity ^0.8.24; + +import {IERC20} from "src/Common.sol"; + +interface IWETH is IERC20 { + // Deposit ETH and receive WETH + function deposit() external payable; + + // Withdraw ETH and burn WETH + function withdraw(uint256 amount) external; + + // Fallback function to handle direct ETH transfers + receive() external payable; +} diff --git a/test/factory/create.t.sol b/test/factory/create.t.sol index fc092f4..9b6db3a 100644 --- a/test/factory/create.t.sol +++ b/test/factory/create.t.sol @@ -3,13 +3,15 @@ pragma solidity ^0.8.24; import "lib/forge-std/src/Test.sol"; import {IERC20, ProxyAdmin} from "src/Common.sol"; -import {MockERC20} from "test/mocks/MockERC20.sol"; +import {ISingleVault} from "src/interface/ISingleVault.sol"; import {LocalActors, IActors} from "script/Actors.sol"; import {TestConstants} from "test/helpers/Constants.sol"; import {SingleVault} from "src/SingleVault.sol"; import {VaultFactory} from "src/VaultFactory.sol"; import {DeployVaultFactory} from "script/Deploy.s.sol"; import {Etches} from "test/helpers/Etches.sol"; +import {MainnetContracts} from "script/Contracts.sol"; +import {AssetHelper} from "test/helpers/Assets.sol"; contract CreateTest is Test, LocalActors, TestConstants { VaultFactory public factory; @@ -20,33 +22,29 @@ contract CreateTest is Test, LocalActors, TestConstants { function setUp() public { vm.startPrank(ADMIN); - asset = IERC20(address(new MockERC20(ASSET_NAME, ASSET_SYMBOL))); + asset = IERC20(address(MainnetContracts.WETH)); actors = new LocalActors(); Etches etches = new Etches(); - etches.mockListaStakeManager(); + etches.mockWETH9(); - proposers = [PROPOSER_1, PROPOSER_2]; - executors = [EXECUTOR_1, EXECUTOR_2]; + + proposers = [PROPOSER_1]; + executors = [EXECUTOR_1]; DeployVaultFactory factoryDeployer = new DeployVaultFactory(); - factory = VaultFactory(factoryDeployer.deployVaultFactory(actors, 0)); + factory = VaultFactory(factoryDeployer.deployVaultFactory(actors, 0, MainnetContracts.WETH)); } function testCreateSingleVault() public { - asset.approve(address(factory), 1 ether); - asset.transfer(address(factory), 1 ether); - address vault = factory.createSingleVault(asset, VAULT_NAME, VAULT_SYMBOL, ADMIN, 0, proposers, executors); - (,, string memory symbol,) = factory.vaults(vault); - assertEq(symbol, VAULT_SYMBOL, "Vault timelock should match the expected address"); + AssetHelper assetHelper = new AssetHelper(); + assetHelper.get_weth(address(factory), 1 ether); + + address vault = factory.createSingleVault(asset, VAULT_NAME, VAULT_SYMBOL, ADMIN); + assertEq(ISingleVault(vault).symbol(), VAULT_SYMBOL, "Vault symbol should match"); } function testVaultFactoryAdmin() public view { assertTrue(factory.hasRole(factory.DEFAULT_ADMIN_ROLE(), ADMIN)); } - - function skip_testCreateSingleVaultRevertsIfNotAdmin() public { - vm.expectRevert(abi.encodeWithSelector(bytes4(keccak256("AccessControl: must have admin role")))); - factory.createSingleVault(asset, VAULT_NAME, VAULT_SYMBOL, ADMIN, 0, proposers, executors); - } } diff --git a/test/helpers/Assets.sol b/test/helpers/Assets.sol index 0ada505..7bcdd5b 100644 --- a/test/helpers/Assets.sol +++ b/test/helpers/Assets.sol @@ -2,17 +2,18 @@ pragma solidity ^0.8.24; import {IERC20} from "src/Common.sol"; -import {BscContracts} from "script/Contracts.sol"; +import {IWETH} from "src/interface/IWETH.sol"; +import {MainnetContracts} from "script/Contracts.sol"; import "forge-std/Test.sol"; -contract AssetHelper is Test, BscContracts { - address slisBNB_WHALE = 0x6F28FeC449dbd2056b76ac666350Af8773E03873; +contract AssetHelper is Test { - function get_slisBNB(address user, uint256 amount) public { - IERC20 slisBNB = IERC20(slisBNB); - vm.startPrank(slisBNB_WHALE); - slisBNB.approve(user, amount); - slisBNB.transfer(user, amount); + function get_weth(address user, uint256 amount) public { + IWETH weth = IWETH(payable(MainnetContracts.WETH)); + deal(address(this), amount); + weth.deposit{value: amount}(); + weth.approve(user, amount); + weth.transfer(user, amount); } } diff --git a/test/helpers/Etches.sol b/test/helpers/Etches.sol index 057ebbe..f6be11e 100644 --- a/test/helpers/Etches.sol +++ b/test/helpers/Etches.sol @@ -2,12 +2,15 @@ pragma solidity ^0.8.24; import {MockStakeManager} from "test/mocks/MockListaStakeManager.sol"; +import {WETH9} from "test/mocks/MockWETH.sol"; +import {MainnetContracts} from "script/Contracts.sol"; + import "forge-std/Test.sol"; contract Etches is Test { - function mockListaStakeManager() public { - MockStakeManager stakeManager = new MockStakeManager(); - bytes memory code = address(stakeManager).code; - vm.etch(0x1adB950d8bB3dA4bE104211D5AB038628e477fE6, code); + function mockWETH9() public { + WETH9 weth = new WETH9(); + bytes memory code = address(weth).code; + vm.etch(MainnetContracts.WETH, code); } } diff --git a/test/helpers/Setup.sol b/test/helpers/Setup.sol index 5f35d1e..2342187 100644 --- a/test/helpers/Setup.sol +++ b/test/helpers/Setup.sol @@ -2,11 +2,13 @@ pragma solidity ^0.8.24; import "forge-std/Test.sol"; import {IActors, LocalActors} from "script/Actors.sol"; +import {MainnetContracts} from "script/Contracts.sol"; import {DeployVaultFactory} from "script/Deploy.s.sol"; import {SingleVault} from "src/SingleVault.sol"; -import {IVaultFactory} from "src/IVaultFactory.sol"; +import {IVaultFactory} from "src/interface/IVaultFactory.sol"; import {IERC20} from "src/Common.sol"; import {TestConstants} from "test/helpers/Constants.sol"; +import {IWETH} from "src/interface/IWETH.sol"; contract SetupHelper is Test, LocalActors, TestConstants { IVaultFactory public factory; @@ -14,29 +16,23 @@ contract SetupHelper is Test, LocalActors, TestConstants { constructor() { IActors actors = new LocalActors(); DeployVaultFactory factoryDeployer = new DeployVaultFactory(); - factory = IVaultFactory(factoryDeployer.deployVaultFactory(actors, 0)); + factory = IVaultFactory(factoryDeployer.deployVaultFactory(actors, 0, MainnetContracts.WETH)); } - function createVault(IERC20 asset) public returns (SingleVault vault) { + function createVault() public returns (SingleVault vault) { vm.startPrank(ADMIN); - address[] memory proposers = new address[](2); - proposers[0] = PROPOSER_1; - proposers[1] = PROPOSER_2; - address[] memory executors = new address[](2); - executors[0] = EXECUTOR_1; - executors[1] = EXECUTOR_2; - asset.approve(address(factory), 1 ether); - asset.transfer(address(factory), 1 ether); + deal(ADMIN, 100_000 ether); + IWETH(payable(MainnetContracts.WETH)).deposit{value: 1 ether}(); + IERC20(MainnetContracts.WETH).transfer(address(factory), 1 ether); + address vaultAddress = factory.createSingleVault( - asset, + IERC20(MainnetContracts.WETH), VAULT_NAME, VAULT_SYMBOL, - ADMIN, - 0, // time delay - proposers, - executors + ADMIN ); vault = SingleVault(payable(vaultAddress)); + vm.stopPrank(); } } diff --git a/test/mocks/MockWETH.sol b/test/mocks/MockWETH.sol new file mode 100644 index 0000000..0f0b7dc --- /dev/null +++ b/test/mocks/MockWETH.sol @@ -0,0 +1,754 @@ +// Copyright (C) 2015, 2016, 2017 Dapphub + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +pragma solidity ^0.8.24; + +contract WETH9 { + string public name = "Wrapped Ether"; + string public symbol = "WETH"; + uint8 public decimals = 18; + + event Approval(address indexed src, address indexed guy, uint256 wad); + event Transfer(address indexed src, address indexed dst, uint256 wad); + event Deposit(address indexed dst, uint256 wad); + event Withdrawal(address indexed src, uint256 wad); + + mapping(address => uint256) public balanceOf; + mapping(address => mapping(address => uint256)) public allowance; + + receive() external payable { + deposit(); + } + + function deposit() public payable { + balanceOf[msg.sender] += msg.value; + emit Deposit(msg.sender, msg.value); + } + + function withdraw(uint256 wad) public { + require(balanceOf[msg.sender] >= wad); + balanceOf[msg.sender] -= wad; + payable(msg.sender).transfer(wad); + emit Withdrawal(msg.sender, wad); + } + + function totalSupply() public view returns (uint256) { + return address(this).balance; + } + + function approve(address guy, uint256 wad) public returns (bool) { + allowance[msg.sender][guy] = wad; + emit Approval(msg.sender, guy, wad); + return true; + } + + function transfer(address dst, uint256 wad) public returns (bool) { + return transferFrom(msg.sender, dst, wad); + } + + function transferFrom(address src, address dst, uint256 wad) public returns (bool) { + require(balanceOf[src] >= wad); + + if (src != msg.sender && allowance[src][msg.sender] != type(uint256).max) { + require(allowance[src][msg.sender] >= wad); + allowance[src][msg.sender] -= wad; + } + + balanceOf[src] -= wad; + balanceOf[dst] += wad; + + emit Transfer(src, dst, wad); + + return true; + } +} + +/* + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. + +*/ diff --git a/test/single/integration/ynBNB.bsc.t.sol b/test/single/integration/ynBNB.bsc.t.sol index 1167887..dfbbc17 100644 --- a/test/single/integration/ynBNB.bsc.t.sol +++ b/test/single/integration/ynBNB.bsc.t.sol @@ -1,134 +1,134 @@ -// SPDX-License-Identifier: BSD-3-Clause -pragma solidity ^0.8.24; - -import {BscContracts} from "script/Contracts.sol"; -import {BscActors} from "script/Actors.sol"; -import {VaultFactory} from "src/VaultFactory.sol"; -import {SingleVault} from "src/SingleVault.sol"; -import {ynBNBConstants} from "script/Constants.sol"; -import {IERC20, IERC4626} from "src/Common.sol"; -import {AssetHelper} from "test/helpers/Assets.sol"; - -import "lib/forge-std/src/Test.sol"; - -interface IKarakVaultSupervisor { - function deposit(address vault, uint256 amount, uint256 minSharesOut) external; -} - -contract KslisBNB_Test is Test, BscActors, BscContracts, ynBNBConstants, AssetHelper { - VaultFactory public factory; - SingleVault public ynBNB; - IERC20 public slis; - IERC4626 public kslis = IERC4626(KARAK_KslisBNB); - IKarakVaultSupervisor public ksup = IKarakVaultSupervisor(KARAK_VAULT_SUPERVISOR); - - address public USER = 0x0c099101d43e9094E4ae9bC2FC38f8b9875c23c5; - - modifier onlyBsc() { - if (block.chainid != 56) return; - _; - } - - function setUp() public onlyBsc { - slis = IERC20(slisBNB); - get_slisBNB(address(this), 100_000 ether); - factory = VaultFactory(address(VAULT_FACTORY)); - slis.approve(address(factory), 1 ether); - slis.transfer(address(factory), 1 ether); - - address[] memory proposers = new address[](2); - proposers[0] = PROPOSER_1; - proposers[1] = PROPOSER_2; - - address[] memory executors = new address[](2); - executors[0] = EXECUTOR_1; - executors[1] = EXECUTOR_2; - - vm.startPrank(ADMIN); - address vaultAddress = - factory.createSingleVault(IERC20(slisBNB), VAULT_NAME, VAULT_SYMBOL, ADMIN, MIN_DELAY, proposers, executors); - ynBNB = SingleVault(payable(vaultAddress)); - assertEq(ynBNB.symbol(), VAULT_SYMBOL); - vm.stopPrank(); - } - - function depositForUser(address user, uint256 amount) public returns (uint256 shares) { - slis.approve(user, amount); - slis.transfer(user, amount); - - vm.startPrank(user); - slis.approve(address(ynBNB), amount); - shares = ynBNB.deposit(amount, user); - - assertEq(ynBNB.totalSupply(), shares + 1 ether); - assertEq(ynBNB.totalAssets(), shares + 1 ether); - vm.stopPrank(); - } - - function withdrawForUser(address user, uint256 amount) public returns (uint256 shares) { - vm.startPrank(user); - - uint256 previousTotalSupply = ynBNB.totalSupply(); - uint256 previousTotalAssets = ynBNB.totalAssets(); - uint256 userMaxWithdraw = ynBNB.previewWithdraw(amount); - - shares = ynBNB.withdraw(userMaxWithdraw, user, user); - - assertEq(ynBNB.totalSupply(), previousTotalSupply - shares); - assertEq(ynBNB.totalAssets(), previousTotalAssets - shares); - vm.stopPrank(); - } - - function test_ynBNB_deposit_withdraw() public onlyBsc { - depositForUser(USER, 3 ether); - withdrawForUser(USER, 3 ether); - } - - function test_KslisBNB_deposit() public onlyBsc { - slis.transfer(USER, 1 ether); - vm.startPrank(USER); - slis.approve(address(kslis), 1 ether); - ksup.deposit(address(kslis), 1 ether, 1 ether); - } - - function test_ynBNB_deposit_withdraw_sameAmount_fuzz(uint256 amount, uint256 rewards) public onlyBsc { - address user = USER; - vm.assume(amount > 0 && amount <= 10000 ether); - vm.assume(rewards >= 0 && rewards <= 10000 ether); - - slis.approve(user, amount); - slis.transfer(user, amount); - - slis.transfer(address(ynBNB), rewards); - - vm.startPrank(user); - slis.approve(address(ynBNB), amount); - uint256 shares = ynBNB.deposit(amount, user); - - assertEq(ynBNB.totalSupply(), shares + 1 ether, "Total supply should equal shares plus initial 1 ether"); - assertEq( - ynBNB.totalAssets(), amount + rewards + 1 ether, "Total assets should equal shares plus initial 1 ether" - ); - vm.stopPrank(); - - // Withdraw shares and assert received amount - vm.startPrank(user); - uint256 preWithdrawBalance = slis.balanceOf(user); - uint256 assetsReceived = ynBNB.redeem(shares, user, user); - uint256 postWithdrawBalance = slis.balanceOf(user); - - assertEq( - postWithdrawBalance - preWithdrawBalance, assetsReceived, "User balance delta should equal assetsReceived" - ); - - assertGe(amount, assetsReceived, "Amount deposited should be greater than or equal to assets received"); - - uint256 assetLoss = amount - assetsReceived; - uint256 maxLoss = (amount > rewards ? amount : rewards) / 1e18; - assertLe(assetLoss, maxLoss + 2, "Asset loss should be less than or equal to maxLoss"); - - assertEq(ynBNB.totalSupply(), 1 ether, "Total supply should return to initial 1 ether"); - assertEq(ynBNB.totalAssets(), rewards + 1 ether + assetLoss, "Total assets should return to initial 1 ether"); - vm.stopPrank(); - } -} +// // SPDX-License-Identifier: BSD-3-Clause +// pragma solidity ^0.8.24; + +// import {BscContracts} from "script/Contracts.sol"; +// import {BscActors} from "script/Actors.sol"; +// import {VaultFactory} from "src/VaultFactory.sol"; +// import {SingleVault} from "src/SingleVault.sol"; +// import {ynBNBConstants} from "script/Constants.sol"; +// import {IERC20, IERC4626} from "src/Common.sol"; +// import {AssetHelper} from "test/helpers/Assets.sol"; + +// import "lib/forge-std/src/Test.sol"; + +// interface IKarakVaultSupervisor { +// function deposit(address vault, uint256 amount, uint256 minSharesOut) external; +// } + +// contract KslisBNB_Test is Test, BscActors, BscContracts, ynBNBConstants, AssetHelper { +// VaultFactory public factory; +// SingleVault public ynBNB; +// IERC20 public slis; +// IERC4626 public kslis = IERC4626(KARAK_KslisBNB); +// IKarakVaultSupervisor public ksup = IKarakVaultSupervisor(KARAK_VAULT_SUPERVISOR); + +// address public USER = 0x0c099101d43e9094E4ae9bC2FC38f8b9875c23c5; + +// modifier onlyBsc() { +// if (block.chainid != 56) return; +// _; +// } + +// function setUp() public onlyBsc { +// slis = IERC20(slisBNB); +// get_slisBNB(address(this), 100_000 ether); +// factory = VaultFactory(address(VAULT_FACTORY)); +// slis.approve(address(factory), 1 ether); +// slis.transfer(address(factory), 1 ether); + +// address[] memory proposers = new address[](2); +// proposers[0] = PROPOSER_1; +// proposers[1] = PROPOSER_2; + +// address[] memory executors = new address[](2); +// executors[0] = EXECUTOR_1; +// executors[1] = EXECUTOR_2; + +// vm.startPrank(ADMIN); +// address vaultAddress = +// factory.createSingleVault(IERC20(slisBNB), VAULT_NAME, VAULT_SYMBOL, ADMIN, MIN_DELAY, proposers, executors); +// ynBNB = SingleVault(payable(vaultAddress)); +// assertEq(ynBNB.symbol(), VAULT_SYMBOL); +// vm.stopPrank(); +// } + +// function depositForUser(address user, uint256 amount) public returns (uint256 shares) { +// slis.approve(user, amount); +// slis.transfer(user, amount); + +// vm.startPrank(user); +// slis.approve(address(ynBNB), amount); +// shares = ynBNB.deposit(amount, user); + +// assertEq(ynBNB.totalSupply(), shares + 1 ether); +// assertEq(ynBNB.totalAssets(), shares + 1 ether); +// vm.stopPrank(); +// } + +// function withdrawForUser(address user, uint256 amount) public returns (uint256 shares) { +// vm.startPrank(user); + +// uint256 previousTotalSupply = ynBNB.totalSupply(); +// uint256 previousTotalAssets = ynBNB.totalAssets(); +// uint256 userMaxWithdraw = ynBNB.previewWithdraw(amount); + +// shares = ynBNB.withdraw(userMaxWithdraw, user, user); + +// assertEq(ynBNB.totalSupply(), previousTotalSupply - shares); +// assertEq(ynBNB.totalAssets(), previousTotalAssets - shares); +// vm.stopPrank(); +// } + +// function test_ynBNB_deposit_withdraw() public onlyBsc { +// depositForUser(USER, 3 ether); +// withdrawForUser(USER, 3 ether); +// } + +// function test_KslisBNB_deposit() public onlyBsc { +// slis.transfer(USER, 1 ether); +// vm.startPrank(USER); +// slis.approve(address(kslis), 1 ether); +// ksup.deposit(address(kslis), 1 ether, 1 ether); +// } + +// function test_ynBNB_deposit_withdraw_sameAmount_fuzz(uint256 amount, uint256 rewards) public onlyBsc { +// address user = USER; +// vm.assume(amount > 0 && amount <= 10000 ether); +// vm.assume(rewards >= 0 && rewards <= 10000 ether); + +// slis.approve(user, amount); +// slis.transfer(user, amount); + +// slis.transfer(address(ynBNB), rewards); + +// vm.startPrank(user); +// slis.approve(address(ynBNB), amount); +// uint256 shares = ynBNB.deposit(amount, user); + +// assertEq(ynBNB.totalSupply(), shares + 1 ether, "Total supply should equal shares plus initial 1 ether"); +// assertEq( +// ynBNB.totalAssets(), amount + rewards + 1 ether, "Total assets should equal shares plus initial 1 ether" +// ); +// vm.stopPrank(); + +// // Withdraw shares and assert received amount +// vm.startPrank(user); +// uint256 preWithdrawBalance = slis.balanceOf(user); +// uint256 assetsReceived = ynBNB.redeem(shares, user, user); +// uint256 postWithdrawBalance = slis.balanceOf(user); + +// assertEq( +// postWithdrawBalance - preWithdrawBalance, assetsReceived, "User balance delta should equal assetsReceived" +// ); + +// assertGe(amount, assetsReceived, "Amount deposited should be greater than or equal to assets received"); + +// uint256 assetLoss = amount - assetsReceived; +// uint256 maxLoss = (amount > rewards ? amount : rewards) / 1e18; +// assertLe(assetLoss, maxLoss + 2, "Asset loss should be less than or equal to maxLoss"); + +// assertEq(ynBNB.totalSupply(), 1 ether, "Total supply should return to initial 1 ether"); +// assertEq(ynBNB.totalAssets(), rewards + 1 ether + assetLoss, "Total assets should return to initial 1 ether"); +// vm.stopPrank(); +// } +// } diff --git a/test/single/unit/access.t.sol b/test/single/unit/access.t.sol index 0ea22ed..d6cec63 100644 --- a/test/single/unit/access.t.sol +++ b/test/single/unit/access.t.sol @@ -19,10 +19,10 @@ contract AccessControlTest is Test, LocalActors, TestConstants { asset = IERC20(address(new MockERC20(ASSET_NAME, ASSET_SYMBOL))); Etches etches = new Etches(); - etches.mockListaStakeManager(); + etches.mockWETH9(); SetupHelper setup = new SetupHelper(); - vault = setup.createVault(asset); + vault = setup.createVault(); } function testAdminRoleSet() public view { diff --git a/test/single/unit/admin.t.sol b/test/single/unit/admin.t.sol deleted file mode 100644 index d61cb9e..0000000 --- a/test/single/unit/admin.t.sol +++ /dev/null @@ -1,84 +0,0 @@ -// SPDX-License-Identifier: BSD-3-Clause -pragma solidity ^0.8.24; - -import "lib/forge-std/src/Test.sol"; -import {SingleVault} from "src/SingleVault.sol"; -import {IERC20, TimelockControllerUpgradeable} from "src/Common.sol"; -import {MockERC20} from "test/mocks/MockERC20.sol"; -import {LocalActors} from "script/Actors.sol"; -import {ChapelContracts} from "script/Contracts.sol"; -import {TestConstants} from "test/helpers/Constants.sol"; -import {SingleVault, ISingleVault} from "src/SingleVault.sol"; -import {IVaultFactory} from "src/IVaultFactory.sol"; -import {DeployVaultFactory} from "script/Deploy.s.sol"; -import {SetupHelper} from "test/helpers/Setup.sol"; -import {Etches} from "test/helpers/Etches.sol"; - -contract AdminTest is Test, LocalActors, TestConstants, ChapelContracts { - SingleVault public vault; - MockERC20 public asset; - - function setUp() public { - vm.startPrank(ADMIN); - asset = MockERC20(address(new MockERC20(ASSET_NAME, ASSET_SYMBOL))); - - Etches etches = new Etches(); - etches.mockListaStakeManager(); - - SetupHelper setup = new SetupHelper(); - vault = setup.createVault(asset); - } - - modifier onlyLocal() { - if (block.chainid != 31337) return; - _; - } - - function testScheduleTransaction() public onlyLocal { - uint256 amount = 100 * 10 ** 18; - asset.mint(amount); - asset.approve(address(vault), amount); - address USER = address(33); - - vault.deposit(amount, USER); - - uint256 assetAmount = asset.balanceOf(address(vault)); - - // schedule a transaction - address target = address(asset); - uint256 value = 0; - address kernelVault = address(3); - bytes memory data = abi.encodeWithSelector(IERC20.transfer.selector, kernelVault, assetAmount); - bytes32 predecessor = bytes32(0); - bytes32 salt = keccak256("chad"); - uint256 delay = 1; - - vm.startPrank(PROPOSER_1); - vault.schedule(target, value, data, predecessor, salt, delay); - vm.stopPrank(); - - bytes32 id = keccak256(abi.encode(target, value, data, predecessor, salt)); - - assert(vault.getOperationState(id) == TimelockControllerUpgradeable.OperationState.Waiting); - - assertEq(vault.isOperationReady(id), false); - assertEq(vault.isOperationDone(id), false); - assertEq(vault.isOperation(id), true); - - uint256 previousBalance = asset.balanceOf(kernelVault); - - //execute the transaction - vm.warp(500); - vm.startPrank(EXECUTOR_1); - vault.execute(target, value, data, predecessor, salt); - - uint256 currentBalance = asset.balanceOf(kernelVault); - uint256 expectedBalance = currentBalance - previousBalance; - - // Verify the transaction was executed successfully - assertEq(assetAmount, expectedBalance); - assertEq(vault.isOperationReady(id), false); - assertEq(vault.isOperationDone(id), true); - assert(vault.getOperationState(id) == TimelockControllerUpgradeable.OperationState.Done); - } -} diff --git a/test/single/unit/deposit.t.sol b/test/single/unit/deposit.t.sol index 1399f12..9e8a696 100644 --- a/test/single/unit/deposit.t.sol +++ b/test/single/unit/deposit.t.sol @@ -3,33 +3,34 @@ pragma solidity ^0.8.24; import "lib/forge-std/src/Test.sol"; import {IERC20, IERC4626} from "src/Common.sol"; -import {MockERC20} from "test/mocks/MockERC20.sol"; +import {WETH9} from "test/mocks/MockWETH.sol"; import {LocalActors} from "script/Actors.sol"; import {TestConstants} from "test/helpers/Constants.sol"; import {SingleVault, ISingleVault} from "src/SingleVault.sol"; -import {IVaultFactory} from "src/IVaultFactory.sol"; +import {IVaultFactory} from "src/interface/IVaultFactory.sol"; import {DeployVaultFactory} from "script/Deploy.s.sol"; import {SetupHelper} from "test/helpers/Setup.sol"; import {Etches} from "test/helpers/Etches.sol"; +import {MainnetContracts} from "script/Contracts.sol"; contract DepositTest is Test, LocalActors, TestConstants { SingleVault public vault; - MockERC20 public asset; + WETH9 public asset; function setUp() public { vm.startPrank(ADMIN); - asset = MockERC20(address(new MockERC20(ASSET_NAME, ASSET_SYMBOL))); + asset = WETH9(payable(MainnetContracts.WETH)); Etches etches = new Etches(); - etches.mockListaStakeManager(); + etches.mockWETH9(); SetupHelper setup = new SetupHelper(); - vault = setup.createVault(asset); + vault = setup.createVault(); } function testDeposit() public { uint256 amount = 100 * 10 ** 18; // Assuming 18 decimals for the asset - asset.mint(amount); + asset.deposit{value: amount}(); asset.approve(address(vault), amount); address USER = address(33); @@ -43,7 +44,7 @@ contract DepositTest is Test, LocalActors, TestConstants { assertEq(asset.balanceOf(address(vault)), amount + 1 ether, "Vault should have received the asset"); assertEq( vault.totalAssets(), - ((amount + 1 ether) * 1.02 ether) / 1 ether, + amount + 1 ether, "Vault totalAsset should be amount deposited" ); assertEq(vault.totalSupply(), totalShares, "Vault totalSupply should be amount deposited"); diff --git a/test/single/unit/initialize.t.sol b/test/single/unit/initialize.t.sol index ec31366..319f438 100644 --- a/test/single/unit/initialize.t.sol +++ b/test/single/unit/initialize.t.sol @@ -20,27 +20,25 @@ contract InitializeTest is Test, LocalActors, TestConstants { asset = IERC20(address(new MockERC20(ASSET_NAME, ASSET_SYMBOL))); Etches etches = new Etches(); - etches.mockListaStakeManager(); + etches.mockWETH9(); SetupHelper setup = new SetupHelper(); - vault = setup.createVault(asset); + vault = setup.createVault(); } function testInitialize() public { SingleVault vaultImplementation = new SingleVault(); - address[] memory proposers = new address[](2); + address[] memory proposers = new address[](1); proposers[0] = PROPOSER_1; - proposers[1] = PROPOSER_2; - address[] memory executors = new address[](2); + address[] memory executors = new address[](1); executors[0] = EXECUTOR_1; - executors[1] = EXECUTOR_2; TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy( address(vaultImplementation), address(this), abi.encodeWithSignature( - "initialize(address,string,string,address,uint256,address[],address[])", + "initialize(address,string,string,address)", asset, VAULT_NAME, VAULT_SYMBOL, diff --git a/test/single/unit/invariants.sol b/test/single/unit/invariants.sol index 3d06fd9..4a91f9f 100644 --- a/test/single/unit/invariants.sol +++ b/test/single/unit/invariants.sol @@ -2,12 +2,13 @@ pragma solidity ^0.8.24; import {SingleVault} from "src/SingleVault.sol"; -import {MockERC20} from "test/mocks/MockERC20.sol"; -import {Math} from "src/Common.sol"; +import {WETH9} from "test/mocks/MockWETH.sol"; +import {Math,IERC20} from "src/Common.sol"; import {SetupHelper} from "test/helpers/Setup.sol"; import {Etches} from "test/helpers/Etches.sol"; import {TestConstants} from "test/helpers/Constants.sol"; import {LocalActors} from "script/Actors.sol"; +import {MainnetContracts} from "script/Contracts.sol"; import "forge-std/Test.sol"; @@ -15,18 +16,19 @@ contract SingleInvariantTests is Test, LocalActors, TestConstants { using Math for uint256; SingleVault public vault; - MockERC20 public asset; address public USER = address(33); + WETH9 public asset; + function setUp() public { vm.startPrank(ADMIN); - asset = MockERC20(address(new MockERC20(ASSET_NAME, ASSET_SYMBOL))); + asset = WETH9(payable(MainnetContracts.WETH)); Etches etches = new Etches(); - etches.mockListaStakeManager(); + etches.mockWETH9(); SetupHelper setup = new SetupHelper(); - vault = setup.createVault(asset); + vault = setup.createVault(); } event Log(uint256 amount, string name); @@ -74,8 +76,9 @@ contract SingleInvariantTests is Test, LocalActors, TestConstants { function depositHelper(address user, uint256 depositAmount) public { vm.startPrank(user); - asset.mint(depositAmount); - asset.approve(address(vault), depositAmount); + deal(user, depositAmount); + asset.deposit{value: depositAmount}(); + IERC20(address(asset)).approve(address(vault), depositAmount); vault.deposit(depositAmount, address(this)); vm.stopPrank(); } diff --git a/test/single/unit/upgrade.t.sol b/test/single/unit/upgrade.t.sol index 413b9ed..69a6e57 100644 --- a/test/single/unit/upgrade.t.sol +++ b/test/single/unit/upgrade.t.sol @@ -8,7 +8,7 @@ import {Etches} from "test/helpers/Etches.sol"; import {LocalActors} from "script/Actors.sol"; import {TestConstants} from "test/helpers/Constants.sol"; import {IERC20} from "src/Common.sol"; -import {IVaultFactory} from "src/IVaultFactory.sol"; +import {IVaultFactory} from "src/interface/IVaultFactory.sol"; import {MockSingleVault} from "test/mocks/MockSingleVault.sol"; import {TimelockController} from "src/Common.sol"; @@ -24,10 +24,10 @@ contract SingleVaultUpgradeTests is Test, LocalActors, TestConstants { asset = MockERC20(address(new MockERC20(ASSET_NAME, ASSET_SYMBOL))); Etches etches = new Etches(); - etches.mockListaStakeManager(); + etches.mockWETH9(); SetupHelper setup = new SetupHelper(); - vault = setup.createVault(asset); + vault = setup.createVault(); factory = IVaultFactory(setup.factory()); } diff --git a/test/single/unit/withdraw.t.sol b/test/single/unit/withdraw.t.sol index 9b132f4..7e43864 100644 --- a/test/single/unit/withdraw.t.sol +++ b/test/single/unit/withdraw.t.sol @@ -4,34 +4,36 @@ pragma solidity ^0.8.24; import "lib/forge-std/src/Test.sol"; import {SingleVault} from "src/SingleVault.sol"; import {IERC20} from "lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol"; -import {MockERC20} from "test/mocks/MockERC20.sol"; +import {WETH9} from "test/mocks/MockWETH.sol"; import {LocalActors} from "script/Actors.sol"; import {TestConstants} from "test/helpers/Constants.sol"; import {IERC4626} from "lib/openzeppelin-contracts/contracts/interfaces/IERC4626.sol"; import {SingleVault, ISingleVault} from "src/SingleVault.sol"; import {SetupHelper} from "test/helpers/Setup.sol"; import {Etches} from "test/helpers/Etches.sol"; +import {MainnetContracts} from "script/Contracts.sol"; contract WithdrawTest is Test, LocalActors, TestConstants { SingleVault public vault; - MockERC20 public asset; + WETH9 public asset; function setUp() public { vm.startPrank(ADMIN); - asset = MockERC20(address(new MockERC20(ASSET_NAME, ASSET_SYMBOL))); + asset = WETH9(payable(MainnetContracts.WETH)); Etches etches = new Etches(); - etches.mockListaStakeManager(); + etches.mockWETH9(); SetupHelper setup = new SetupHelper(); - vault = setup.createVault(asset); + vault = setup.createVault(); } function testWithdraw() public { address USER = address(33); vm.startPrank(USER); uint256 amount = 100 * 10 ** 18; - asset.mint(amount); + deal(USER,amount); + asset.deposit{value: amount}(); asset.approve(address(vault), amount); uint256 previousTotalAssets = vault.totalAssets(); From e8d687702064df86134d03abbdca29a03db32ac1 Mon Sep 17 00:00:00 2001 From: xhad Date: Sat, 19 Oct 2024 01:00:26 +0800 Subject: [PATCH 2/2] run forge fmt --- script/Deploy.s.sol | 4 +--- src/SingleVault.sol | 36 +++++++++------------------------ src/VaultFactory.sol | 20 +++++++++--------- src/interface/ISingleVault.sol | 9 ++------- src/interface/IVaultFactory.sol | 9 +++------ test/factory/create.t.sol | 1 - test/helpers/Assets.sol | 1 - test/helpers/Setup.sol | 7 +------ test/single/unit/deposit.t.sol | 6 +----- test/single/unit/invariants.sol | 2 +- test/single/unit/withdraw.t.sol | 2 +- 11 files changed, 29 insertions(+), 68 deletions(-) diff --git a/script/Deploy.s.sol b/script/Deploy.s.sol index 06db436..c3f6a7d 100644 --- a/script/Deploy.s.sol +++ b/script/Deploy.s.sol @@ -6,14 +6,12 @@ import "lib/forge-std/src/Script.sol"; import {VaultFactory} from "src/VaultFactory.sol"; import {IVaultFactory} from "src/interface/IVaultFactory.sol"; import {IActors, MainnetActors, HoleskyActors} from "script/Actors.sol"; -import {MainnetContracts,HoleskyContracts} from "script/Contracts.sol"; +import {MainnetContracts, HoleskyContracts} from "script/Contracts.sol"; import {SingleVault} from "src/SingleVault.sol"; import {TransparentUpgradeableProxy, TimelockController} from "src/Common.sol"; contract DeployVaultFactory is Script { - function run() public { - if (block.chainid == 17000) { vm.startBroadcast(); HoleskyActors actors = new HoleskyActors(); diff --git a/src/SingleVault.sol b/src/SingleVault.sol index 601945a..ad061c2 100644 --- a/src/SingleVault.sol +++ b/src/SingleVault.sol @@ -1,35 +1,20 @@ // SPDX-License-Identifier: BSD-3-Clause pragma solidity ^0.8.24; -import { - ERC4626Upgradeable, - AccessControlUpgradeable, - ReentrancyGuardUpgradeable, - IERC20, - Math -} from "src/Common.sol"; +import {ERC4626Upgradeable, AccessControlUpgradeable, ReentrancyGuardUpgradeable, IERC20, Math} from "src/Common.sol"; import {ISingleVault} from "src/interface/ISingleVault.sol"; /* ynETH Pre-Launch Vault */ -contract SingleVault is ISingleVault, - ERC4626Upgradeable, - AccessControlUpgradeable, - ReentrancyGuardUpgradeable -{ +contract SingleVault is ISingleVault, ERC4626Upgradeable, AccessControlUpgradeable, ReentrancyGuardUpgradeable { using Math for uint256; constructor() { _disableInitializers(); } - function initialize( - IERC20 asset_, - string memory name_, - string memory symbol_, - address admin_ - ) public initializer { + function initialize(IERC20 asset_, string memory name_, string memory symbol_, address admin_) public initializer { _verifyParamsAreValid(asset_, name_, symbol_, admin_); __ERC20_init(name_, symbol_); __ERC4626_init(asset_); @@ -38,20 +23,19 @@ contract SingleVault is ISingleVault, _grantRole(DEFAULT_ADMIN_ROLE, admin_); } - receive() external payable nonReentrant() { + receive() external payable nonReentrant { if (msg.value > 0) { _mintSharesForETH(msg.value); } } - fallback() external payable nonReentrant() { + fallback() external payable nonReentrant { if (msg.value > 0) { _mintSharesForETH(msg.value); } } function _mintSharesForETH(uint256 amount) private { - IERC20 weth = _retrieveERC4626Storage()._asset; (bool success,) = address(weth).call{value: amount}(""); @@ -62,12 +46,10 @@ contract SingleVault is ISingleVault, } } - function _verifyParamsAreValid( - IERC20 asset_, - string memory name_, - string memory symbol_, - address admin_ - ) internal pure { + function _verifyParamsAreValid(IERC20 asset_, string memory name_, string memory symbol_, address admin_) + internal + pure + { if (asset_ == IERC20(address(0))) revert AssetZeroAddress(); if (bytes(name_).length == 0) revert NameEmpty(); if (bytes(symbol_).length == 0) revert SymbolEmpty(); diff --git a/src/VaultFactory.sol b/src/VaultFactory.sol index 26b955c..dbfb4ca 100644 --- a/src/VaultFactory.sol +++ b/src/VaultFactory.sol @@ -32,7 +32,10 @@ contract VaultFactory is IVaultFactory, AccessControlUpgradeable { * @param admin The address of the administrator. * @param timelock_ The Vault admin for proxy upgrades */ - function initialize(address singleVaultImpl_, address admin, address timelock_, address weth_) external initializer { + function initialize(address singleVaultImpl_, address admin, address timelock_, address weth_) + external + initializer + { _grantRole(DEFAULT_ADMIN_ROLE, admin); // NOTES: There are two timelocks. This timelock is for vault upgrades but // the vault is the second timelock controller, which has the same proposers and executors @@ -50,20 +53,17 @@ contract VaultFactory is IVaultFactory, AccessControlUpgradeable { * @param admin_ The address of the timelock. * @return address The address of the newly created vault. */ - function createSingleVault( - IERC20 asset_, - string memory name_, - string memory symbol_, - address admin_ - ) public onlyRole(DEFAULT_ADMIN_ROLE) returns (address) { + function createSingleVault(IERC20 asset_, string memory name_, string memory symbol_, address admin_) + public + onlyRole(DEFAULT_ADMIN_ROLE) + returns (address) + { string memory funcSig = "initialize(address,string,string,address)"; if (address(asset_) != address(weth)) revert InvalidWethAddress(); TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy( - singleVaultImpl, - timelock, - abi.encodeWithSignature(funcSig, asset_, name_, symbol_, admin_) + singleVaultImpl, timelock, abi.encodeWithSignature(funcSig, asset_, name_, symbol_, admin_) ); // bootstrap 1 ether of weth to prevent donation attacks diff --git a/src/interface/ISingleVault.sol b/src/interface/ISingleVault.sol index 1353759..db040e8 100644 --- a/src/interface/ISingleVault.sol +++ b/src/interface/ISingleVault.sol @@ -9,11 +9,6 @@ interface ISingleVault is IERC20, IERC4626, IAccessControl { error SymbolEmpty(); error AdminZeroAddress(); error DepositFailed(); - - function initialize( - IERC20 asset_, - string calldata name_, - string calldata symbol_, - address admin_ - ) external; + + function initialize(IERC20 asset_, string calldata name_, string calldata symbol_, address admin_) external; } diff --git a/src/interface/IVaultFactory.sol b/src/interface/IVaultFactory.sol index 7f24e38..8dfa5cb 100644 --- a/src/interface/IVaultFactory.sol +++ b/src/interface/IVaultFactory.sol @@ -15,10 +15,7 @@ interface IVaultFactory is IAccessControl { function initialize(address singleVaultImpl_, address admin, address timelock_, address weth_) external; - function createSingleVault( - IERC20 asset_, - string memory name_, - string memory symbol_, - address admin_ - ) external returns (address); + function createSingleVault(IERC20 asset_, string memory name_, string memory symbol_, address admin_) + external + returns (address); } diff --git a/test/factory/create.t.sol b/test/factory/create.t.sol index 9b6db3a..88c49b3 100644 --- a/test/factory/create.t.sol +++ b/test/factory/create.t.sol @@ -28,7 +28,6 @@ contract CreateTest is Test, LocalActors, TestConstants { Etches etches = new Etches(); etches.mockWETH9(); - proposers = [PROPOSER_1]; executors = [EXECUTOR_1]; diff --git a/test/helpers/Assets.sol b/test/helpers/Assets.sol index 7bcdd5b..69a5ff2 100644 --- a/test/helpers/Assets.sol +++ b/test/helpers/Assets.sol @@ -8,7 +8,6 @@ import {MainnetContracts} from "script/Contracts.sol"; import "forge-std/Test.sol"; contract AssetHelper is Test { - function get_weth(address user, uint256 amount) public { IWETH weth = IWETH(payable(MainnetContracts.WETH)); deal(address(this), amount); diff --git a/test/helpers/Setup.sol b/test/helpers/Setup.sol index 2342187..c670f34 100644 --- a/test/helpers/Setup.sol +++ b/test/helpers/Setup.sol @@ -26,12 +26,7 @@ contract SetupHelper is Test, LocalActors, TestConstants { IWETH(payable(MainnetContracts.WETH)).deposit{value: 1 ether}(); IERC20(MainnetContracts.WETH).transfer(address(factory), 1 ether); - address vaultAddress = factory.createSingleVault( - IERC20(MainnetContracts.WETH), - VAULT_NAME, - VAULT_SYMBOL, - ADMIN - ); + address vaultAddress = factory.createSingleVault(IERC20(MainnetContracts.WETH), VAULT_NAME, VAULT_SYMBOL, ADMIN); vault = SingleVault(payable(vaultAddress)); vm.stopPrank(); } diff --git a/test/single/unit/deposit.t.sol b/test/single/unit/deposit.t.sol index 9e8a696..fff3b37 100644 --- a/test/single/unit/deposit.t.sol +++ b/test/single/unit/deposit.t.sol @@ -42,11 +42,7 @@ contract DepositTest is Test, LocalActors, TestConstants { assertEq(shares, previewAmount, "Shares should be equal to the amount deposited"); assertEq(vault.balanceOf(USER), shares, "Balance of the user should be updated"); assertEq(asset.balanceOf(address(vault)), amount + 1 ether, "Vault should have received the asset"); - assertEq( - vault.totalAssets(), - amount + 1 ether, - "Vault totalAsset should be amount deposited" - ); + assertEq(vault.totalAssets(), amount + 1 ether, "Vault totalAsset should be amount deposited"); assertEq(vault.totalSupply(), totalShares, "Vault totalSupply should be amount deposited"); } diff --git a/test/single/unit/invariants.sol b/test/single/unit/invariants.sol index 4a91f9f..31f2f7a 100644 --- a/test/single/unit/invariants.sol +++ b/test/single/unit/invariants.sol @@ -3,7 +3,7 @@ pragma solidity ^0.8.24; import {SingleVault} from "src/SingleVault.sol"; import {WETH9} from "test/mocks/MockWETH.sol"; -import {Math,IERC20} from "src/Common.sol"; +import {Math, IERC20} from "src/Common.sol"; import {SetupHelper} from "test/helpers/Setup.sol"; import {Etches} from "test/helpers/Etches.sol"; import {TestConstants} from "test/helpers/Constants.sol"; diff --git a/test/single/unit/withdraw.t.sol b/test/single/unit/withdraw.t.sol index 7e43864..c10dd7d 100644 --- a/test/single/unit/withdraw.t.sol +++ b/test/single/unit/withdraw.t.sol @@ -32,7 +32,7 @@ contract WithdrawTest is Test, LocalActors, TestConstants { address USER = address(33); vm.startPrank(USER); uint256 amount = 100 * 10 ** 18; - deal(USER,amount); + deal(USER, amount); asset.deposit{value: amount}(); asset.approve(address(vault), amount);