From 737b67f1b411bc64c918180147136882a7a5fa6c Mon Sep 17 00:00:00 2001 From: Kresh Date: Wed, 19 Jun 2024 15:13:33 +0400 Subject: [PATCH] rename stakingController to slasher --- script/deploy/Core.s.sol | 86 +- script/deploy/Vault.s.sol | 72 +- .../defaultLimiter/DefaultLimiter.sol | 8 +- .../v1/Slasher.sol} | 40 +- .../v1/SlasherFactory.sol} | 22 +- src/contracts/vault/v1/Vault.sol | 12 +- src/contracts/vault/v1/VaultStorage.sol | 2 +- .../defaultLimiter/IDefaultLimiter.sol | 2 +- .../v1/ISlasher.sol} | 2 +- .../v1/ISlasherFactory.sol} | 2 +- src/interfaces/vault/v1/IVault.sol | 6 +- src/interfaces/vault/v1/IVaultStorage.sol | 2 +- test/Vault.t.sol | 4532 ++++++++--------- .../DefaultRewardsDistributor.t.sol | 1628 +++--- .../DefaultRewardsDistributorFactory.t.sol | 242 +- 15 files changed, 3329 insertions(+), 3329 deletions(-) rename src/contracts/{stakingController/v1/StakingController.sol => slasher/v1/Slasher.sol} (90%) rename src/contracts/{stakingController/v1/StakingControllerFactory.sol => slasher/v1/SlasherFactory.sol} (55%) rename src/interfaces/{stakingController/v1/IStakingController.sol => slasher/v1/ISlasher.sol} (99%) rename src/interfaces/{stakingController/v1/IStakingControllerFactory.sol => slasher/v1/ISlasherFactory.sol} (87%) diff --git a/script/deploy/Core.s.sol b/script/deploy/Core.s.sol index 5ec766a1..7bb94441 100644 --- a/script/deploy/Core.s.sol +++ b/script/deploy/Core.s.sol @@ -1,49 +1,49 @@ -// SPDX-License-Identifier: UNLICENSED -pragma solidity 0.8.25; +// // SPDX-License-Identifier: UNLICENSED +// pragma solidity 0.8.25; -import "forge-std/Script.sol"; +// import "forge-std/Script.sol"; -import {MetadataService} from "src/contracts/MetadataService.sol"; -import {NetworkMiddlewareService} from "src/contracts/NetworkMiddlewareService.sol"; -import {NetworkOptInService} from "src/contracts/NetworkOptInService.sol"; -import {NetworkRegistry} from "src/contracts/NetworkRegistry.sol"; -import {OperatorOptInService} from "src/contracts/OperatorOptInService.sol"; -import {OperatorRegistry} from "src/contracts/OperatorRegistry.sol"; -import {VaultFactory} from "src/contracts/VaultFactory.sol"; -import {Vault} from "src/contracts/vault/v1/Vault.sol"; +// import {MetadataService} from "src/contracts/MetadataService.sol"; +// import {NetworkMiddlewareService} from "src/contracts/NetworkMiddlewareService.sol"; +// import {NetworkOptInService} from "src/contracts/NetworkOptInService.sol"; +// import {NetworkRegistry} from "src/contracts/NetworkRegistry.sol"; +// import {OperatorOptInService} from "src/contracts/OperatorOptInService.sol"; +// import {OperatorRegistry} from "src/contracts/OperatorRegistry.sol"; +// import {VaultFactory} from "src/contracts/VaultFactory.sol"; +// import {Vault} from "src/contracts/vault/v1/Vault.sol"; -contract CoreScript is Script { - function run(address owner) public { - vm.startBroadcast(); - (,, address deployer) = vm.readCallers(); +// contract CoreScript is Script { +// function run(address owner) public { +// vm.startBroadcast(); +// (,, address deployer) = vm.readCallers(); - VaultFactory vaultFactory = new VaultFactory(deployer); - NetworkRegistry networkRegistry = new NetworkRegistry(); - OperatorRegistry operatorRegistry = new OperatorRegistry(); - MetadataService operatorMetadataService = new MetadataService(address(operatorRegistry)); - MetadataService networkMetadataService = new MetadataService(address(networkRegistry)); - NetworkMiddlewareService networkMiddlewareService = new NetworkMiddlewareService(address(networkRegistry)); - NetworkOptInService networkVaultOptInService = - new NetworkOptInService(address(networkRegistry), address(vaultFactory)); - OperatorOptInService operatorVaultOptInService = - new OperatorOptInService(address(operatorRegistry), address(vaultFactory)); - OperatorOptInService operatorNetworkOptInService = - new OperatorOptInService(address(operatorRegistry), address(networkRegistry)); +// VaultFactory vaultFactory = new VaultFactory(deployer); +// NetworkRegistry networkRegistry = new NetworkRegistry(); +// OperatorRegistry operatorRegistry = new OperatorRegistry(); +// MetadataService operatorMetadataService = new MetadataService(address(operatorRegistry)); +// MetadataService networkMetadataService = new MetadataService(address(networkRegistry)); +// NetworkMiddlewareService networkMiddlewareService = new NetworkMiddlewareService(address(networkRegistry)); +// NetworkOptInService networkVaultOptInService = +// new NetworkOptInService(address(networkRegistry), address(vaultFactory)); +// OperatorOptInService operatorVaultOptInService = +// new OperatorOptInService(address(operatorRegistry), address(vaultFactory)); +// OperatorOptInService operatorNetworkOptInService = +// new OperatorOptInService(address(operatorRegistry), address(networkRegistry)); - vaultFactory.whitelist( - address( - new Vault( - address(vaultFactory), - address(networkRegistry), - address(networkMiddlewareService), - address(networkVaultOptInService), - address(operatorVaultOptInService), - address(operatorNetworkOptInService) - ) - ) - ); - vaultFactory.transferOwnership(owner); +// vaultFactory.whitelist( +// address( +// new Vault( +// address(vaultFactory), +// address(networkRegistry), +// address(networkMiddlewareService), +// address(networkVaultOptInService), +// address(operatorVaultOptInService), +// address(operatorNetworkOptInService) +// ) +// ) +// ); +// vaultFactory.transferOwnership(owner); - vm.stopBroadcast(); - } -} +// vm.stopBroadcast(); +// } +// } diff --git a/script/deploy/Vault.s.sol b/script/deploy/Vault.s.sol index fd04c426..57843c5b 100644 --- a/script/deploy/Vault.s.sol +++ b/script/deploy/Vault.s.sol @@ -1,41 +1,41 @@ -// SPDX-License-Identifier: UNLICENSED -pragma solidity 0.8.25; +// // SPDX-License-Identifier: UNLICENSED +// pragma solidity 0.8.25; -import "forge-std/Script.sol"; +// import "forge-std/Script.sol"; -import {IMigratablesFactory} from "src/interfaces/base/IMigratablesFactory.sol"; -import {IVault} from "src/interfaces/vault/v1/IVault.sol"; +// import {IMigratablesFactory} from "src/interfaces/base/IMigratablesFactory.sol"; +// import {IVault} from "src/interfaces/vault/v1/IVault.sol"; -contract VaultScript is Script { - function run( - address vaultFactory, - address owner, - address collateral, - uint48 epochDuration, - uint48 vetoDuration, - uint48 executeDuration, - address rewardsDistributor, - uint256 adminFee, - bool depositWhitelist - ) public { - vm.startBroadcast(); +// contract VaultScript is Script { +// function run( +// address vaultFactory, +// address owner, +// address collateral, +// uint48 epochDuration, +// uint48 vetoDuration, +// uint48 executeDuration, +// address rewardsDistributor, +// uint256 adminFee, +// bool depositWhitelist +// ) public { +// vm.startBroadcast(); - IMigratablesFactory(vaultFactory).create( - IMigratablesFactory(vaultFactory).lastVersion(), - owner, - abi.encode( - IVault.InitParams({ - collateral: collateral, - epochDuration: epochDuration, - vetoDuration: vetoDuration, - executeDuration: executeDuration, - rewardsDistributor: rewardsDistributor, - adminFee: adminFee, - depositWhitelist: depositWhitelist - }) - ) - ); +// IMigratablesFactory(vaultFactory).create( +// IMigratablesFactory(vaultFactory).lastVersion(), +// owner, +// abi.encode( +// IVault.InitParams({ +// collateral: collateral, +// epochDuration: epochDuration, +// vetoDuration: vetoDuration, +// executeDuration: executeDuration, +// rewardsDistributor: rewardsDistributor, +// adminFee: adminFee, +// depositWhitelist: depositWhitelist +// }) +// ) +// ); - vm.stopBroadcast(); - } -} +// vm.stopBroadcast(); +// } +// } diff --git a/src/contracts/defaultLimiter/DefaultLimiter.sol b/src/contracts/defaultLimiter/DefaultLimiter.sol index d2309c3b..11ec5eb1 100644 --- a/src/contracts/defaultLimiter/DefaultLimiter.sol +++ b/src/contracts/defaultLimiter/DefaultLimiter.sol @@ -55,9 +55,9 @@ contract DefaultLimiter is Initializable, IDefaultLimiter, AccessControlUpgradea mapping(address vault => mapping(address operator => mapping(address network => Limit limit))) internal _operatorNetworkLimit; - modifier onlyStakingController(address vault) { - if (IVault(vault).stakingController() != msg.sender) { - revert NotStakingController(); + modifier onlySlasher(address vault) { + if (IVault(vault).slasher() != msg.sender) { + revert NotSlasher(); } _; } @@ -194,7 +194,7 @@ contract DefaultLimiter is Initializable, IDefaultLimiter, AccessControlUpgradea address resolver, address operator, uint256 slashedAmount - ) external onlyStakingController(vault) { + ) external onlySlasher(vault) { uint256 networkResolverLimit_ = networkResolverLimit(vault, network, resolver); uint256 operatorNetworkLimit_ = operatorNetworkLimit(vault, operator, network); diff --git a/src/contracts/stakingController/v1/StakingController.sol b/src/contracts/slasher/v1/Slasher.sol similarity index 90% rename from src/contracts/stakingController/v1/StakingController.sol rename to src/contracts/slasher/v1/Slasher.sol index 536bdc73..e1fccf1f 100644 --- a/src/contracts/stakingController/v1/StakingController.sol +++ b/src/contracts/slasher/v1/Slasher.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MIT pragma solidity 0.8.25; -import {IStakingController} from "src/interfaces/stakingController/v1/IStakingController.sol"; +import {ISlasher} from "src/interfaces/slasher/v1/ISlasher.sol"; import {IRegistry} from "src/interfaces/base/IRegistry.sol"; import {IVault} from "src/interfaces/vault/v1/IVault.sol"; import {ILimiter} from "src/interfaces/ILimiter.sol"; @@ -14,9 +14,9 @@ import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Ini import {Math} from "@openzeppelin/contracts/utils/math/Math.sol"; import {Time} from "@openzeppelin/contracts/utils/types/Time.sol"; -contract StakingController is Initializable, IStakingController { +contract Slasher is Initializable, ISlasher { /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ address public immutable VAULT_FACTORY; @@ -26,52 +26,52 @@ contract StakingController is Initializable, IStakingController { address internal constant DEAD = address(0xdEaD); /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ address public immutable NETWORK_VAULT_OPT_IN_SERVICE; /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ address public immutable OPERATOR_VAULT_OPT_IN_SERVICE; /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ address public immutable OPERATOR_NETWORK_OPT_IN_SERVICE; /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ address public immutable NETWORK_REGISTRY; /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ address public immutable NETWORK_MIDDLEWARE_SERVICE; /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ address public vault; /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ address public limiter; /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ SlashRequest[] public slashRequests; /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ uint48 public vetoDuration; /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ uint48 public executeDuration; @@ -96,14 +96,14 @@ contract StakingController is Initializable, IStakingController { } /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ function slashRequestsLength() external view returns (uint256) { return slashRequests.length; } /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ function slashableAmountIn( address network, @@ -121,7 +121,7 @@ contract StakingController is Initializable, IStakingController { } /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ function slashableAmount(address network, address resolver, address operator) public view returns (uint256) { return Math.min( @@ -134,7 +134,7 @@ contract StakingController is Initializable, IStakingController { } /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ function minStakeDuring( address network, @@ -173,7 +173,7 @@ contract StakingController is Initializable, IStakingController { } /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ function requestSlash( address network, @@ -242,7 +242,7 @@ contract StakingController is Initializable, IStakingController { } /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ function executeSlash(uint256 slashIndex) external returns (uint256 slashedAmount) { if (slashIndex >= slashRequests.length) { @@ -281,7 +281,7 @@ contract StakingController is Initializable, IStakingController { } /** - * @inheritdoc IStakingController + * @inheritdoc ISlasher */ function vetoSlash(uint256 slashIndex) external { if (slashIndex >= slashRequests.length) { diff --git a/src/contracts/stakingController/v1/StakingControllerFactory.sol b/src/contracts/slasher/v1/SlasherFactory.sol similarity index 55% rename from src/contracts/stakingController/v1/StakingControllerFactory.sol rename to src/contracts/slasher/v1/SlasherFactory.sol index a411fc56..62c33e93 100644 --- a/src/contracts/stakingController/v1/StakingControllerFactory.sol +++ b/src/contracts/slasher/v1/SlasherFactory.sol @@ -1,17 +1,17 @@ // SPDX-License-Identifier: MIT pragma solidity 0.8.25; -import {StakingController} from "./StakingController.sol"; +import {Slasher} from "./Slasher.sol"; import {Registry} from "src/contracts/base/Registry.sol"; -import {IStakingControllerFactory} from "src/interfaces/stakingController/v1/IStakingControllerFactory.sol"; +import {ISlasherFactory} from "src/interfaces/slasher/v1/ISlasherFactory.sol"; import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol"; -contract StakingControllerFactory is Registry, IStakingControllerFactory { +contract SlasherFactory is Registry, ISlasherFactory { using Clones for address; - address private immutable STAKING_CONTROLLER_IMPLEMENTATION; + address private immutable SLASHER_IMPLEMENTATION; constructor( address networkRegistry, @@ -21,8 +21,8 @@ contract StakingControllerFactory is Registry, IStakingControllerFactory { address operatorVaultOptInService, address operatorNetworkOptInService ) { - STAKING_CONTROLLER_IMPLEMENTATION = address( - new StakingController( + SLASHER_IMPLEMENTATION = address( + new Slasher( vaultFactory, networkRegistry, networkMiddlewareService, @@ -34,14 +34,14 @@ contract StakingControllerFactory is Registry, IStakingControllerFactory { } /** - * @inheritdoc IStakingControllerFactory + * @inheritdoc ISlasherFactory */ function create(address vault, uint48 vetoDuration, uint48 executeDuration) external returns (address) { - address stakingController = STAKING_CONTROLLER_IMPLEMENTATION.clone(); - StakingController(stakingController).initialize(vault, vetoDuration, executeDuration); + address slasher = SLASHER_IMPLEMENTATION.clone(); + Slasher(slasher).initialize(vault, vetoDuration, executeDuration); - _addEntity(stakingController); + _addEntity(slasher); - return stakingController; + return slasher; } } diff --git a/src/contracts/vault/v1/Vault.sol b/src/contracts/vault/v1/Vault.sol index 98f47469..d10c4f38 100644 --- a/src/contracts/vault/v1/Vault.sol +++ b/src/contracts/vault/v1/Vault.sol @@ -7,7 +7,7 @@ import {VaultStorage} from "./VaultStorage.sol"; import {ICollateral} from "src/interfaces/base/ICollateral.sol"; import {IRegistry} from "src/interfaces/base/IRegistry.sol"; import {IVault} from "src/interfaces/vault/v1/IVault.sol"; -import {IStakingControllerFactory} from "src/interfaces/stakingController/v1/IStakingControllerFactory.sol"; +import {ISlasherFactory} from "src/interfaces/slasher/v1/ISlasherFactory.sol"; import {Checkpoints} from "src/contracts/libraries/Checkpoints.sol"; import {ERC4626Math} from "src/contracts/libraries/ERC4626Math.sol"; @@ -21,9 +21,9 @@ contract Vault is VaultStorage, MigratableEntity, AccessControlUpgradeable, IVau using Checkpoints for Checkpoints.Trace256; using Math for uint256; - modifier onlyStakingController() { - if (msg.sender != stakingController) { - revert NotStakingController(); + modifier onlySlasher() { + if (msg.sender != slasher) { + revert NotSlasher(); } _; } @@ -171,7 +171,7 @@ contract Vault is VaultStorage, MigratableEntity, AccessControlUpgradeable, IVau /** * @inheritdoc IVault */ - function onSlash(uint256 slashedAmount) external onlyStakingController returns (uint256) { + function onSlash(uint256 slashedAmount) external onlySlasher returns (uint256) { uint256 epoch = currentEpoch(); uint256 totalSupply_ = totalSupply(); uint256 activeSupply_ = activeSupply(); @@ -267,7 +267,7 @@ contract Vault is VaultStorage, MigratableEntity, AccessControlUpgradeable, IVau _grantRole(DEPOSITOR_WHITELIST_ROLE, owner); } - IStakingControllerFactory(params.stakingControllerFactory).create( + ISlasherFactory(params.slasherFactory).create( address(this), params.vetoDuration, params.executeDuration ); } diff --git a/src/contracts/vault/v1/VaultStorage.sol b/src/contracts/vault/v1/VaultStorage.sol index b2b8fdd5..73ec38ea 100644 --- a/src/contracts/vault/v1/VaultStorage.sol +++ b/src/contracts/vault/v1/VaultStorage.sol @@ -37,7 +37,7 @@ contract VaultStorage is IVaultStorage { /** * @inheritdoc IVaultStorage */ - address public stakingController; + address public slasher; /** * @inheritdoc IVaultStorage diff --git a/src/interfaces/defaultLimiter/IDefaultLimiter.sol b/src/interfaces/defaultLimiter/IDefaultLimiter.sol index 8b6a9edf..b518c7e3 100644 --- a/src/interfaces/defaultLimiter/IDefaultLimiter.sol +++ b/src/interfaces/defaultLimiter/IDefaultLimiter.sol @@ -5,7 +5,7 @@ import {ILimiter} from "src/interfaces/ILimiter.sol"; interface IDefaultLimiter is ILimiter { error ExceedsMaxNetworkResolverLimit(); error AlreadySet(); - error NotStakingController(); + error NotSlasher(); error NotNetwork(); /** diff --git a/src/interfaces/stakingController/v1/IStakingController.sol b/src/interfaces/slasher/v1/ISlasher.sol similarity index 99% rename from src/interfaces/stakingController/v1/IStakingController.sol rename to src/interfaces/slasher/v1/ISlasher.sol index 0977372c..fd766578 100644 --- a/src/interfaces/stakingController/v1/IStakingController.sol +++ b/src/interfaces/slasher/v1/ISlasher.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MIT pragma solidity 0.8.25; -interface IStakingController { +interface ISlasher { error InvalidSlashDuration(); error InsufficientSlash(); error NetworkNotOptedInVault(); diff --git a/src/interfaces/stakingController/v1/IStakingControllerFactory.sol b/src/interfaces/slasher/v1/ISlasherFactory.sol similarity index 87% rename from src/interfaces/stakingController/v1/IStakingControllerFactory.sol rename to src/interfaces/slasher/v1/ISlasherFactory.sol index 6b5cf8f0..47ea8f24 100644 --- a/src/interfaces/stakingController/v1/IStakingControllerFactory.sol +++ b/src/interfaces/slasher/v1/ISlasherFactory.sol @@ -3,7 +3,7 @@ pragma solidity 0.8.25; import {IRegistry} from "src/interfaces/base/IRegistry.sol"; -interface IStakingControllerFactory is IRegistry { +interface ISlasherFactory is IRegistry { error NotVault(); /** diff --git a/src/interfaces/vault/v1/IVault.sol b/src/interfaces/vault/v1/IVault.sol index ee30243b..7b1d24d1 100644 --- a/src/interfaces/vault/v1/IVault.sol +++ b/src/interfaces/vault/v1/IVault.sol @@ -14,7 +14,7 @@ interface IVault is IVaultStorage { error InvalidEpochDuration(); error NoDepositWhitelist(); error NotWhitelistedDepositor(); - error NotStakingController(); + error NotSlasher(); error TooMuchWithdraw(); /** @@ -23,7 +23,7 @@ interface IVault is IVaultStorage { * @param epochDuration duration of the vault epoch (it determines sync points for withdrawals) * @param adminFee admin fee (up to ADMIN_FEE_BASE inclusively) * @param depositWhitelist if enabling deposit whitelist - * @param stakingControllerFactory factory for creating vault's staking controller + * @param slasherFactory factory for creating vault's staking controller * @param vetoDuration duration of the veto period for a slash request * @param executeDuration duration of the slash period for a slash request (after the veto duration has passed) */ @@ -32,7 +32,7 @@ interface IVault is IVaultStorage { uint48 epochDuration; uint256 adminFee; bool depositWhitelist; - address stakingControllerFactory; + address slasherFactory; uint48 vetoDuration; uint48 executeDuration; } diff --git a/src/interfaces/vault/v1/IVaultStorage.sol b/src/interfaces/vault/v1/IVaultStorage.sol index 2ac60921..efca3767 100644 --- a/src/interfaces/vault/v1/IVaultStorage.sol +++ b/src/interfaces/vault/v1/IVaultStorage.sol @@ -30,7 +30,7 @@ interface IVaultStorage { * @notice Get a vault's staking controoler. * @return vault's staking controller */ - function stakingController() external view returns (address); + function slasher() external view returns (address); /** * @notice Get a vault collateral. diff --git a/test/Vault.t.sol b/test/Vault.t.sol index dd3c9a2b..c34a8fdd 100644 --- a/test/Vault.t.sol +++ b/test/Vault.t.sol @@ -1,2598 +1,2598 @@ -// SPDX-License-Identifier: MIT -pragma solidity 0.8.25; - -import {Test, console2} from "forge-std/Test.sol"; - -import {VaultFactory} from "src/contracts/VaultFactory.sol"; -import {NetworkRegistry} from "src/contracts/NetworkRegistry.sol"; -import {OperatorRegistry} from "src/contracts/OperatorRegistry.sol"; -import {MetadataService} from "src/contracts/MetadataService.sol"; -import {NetworkMiddlewareService} from "src/contracts/NetworkMiddlewareService.sol"; -import {NetworkOptInService} from "src/contracts/NetworkOptInService.sol"; -import {OperatorOptInService} from "src/contracts/OperatorOptInService.sol"; - -import {Vault} from "src/contracts/vault/v1/Vault.sol"; -import {IVault} from "src/interfaces/vault/v1/IVault.sol"; -import {IVaultStorage} from "src/interfaces/vault/v1/IVaultStorage.sol"; - -import {Token} from "./mocks/Token.sol"; -import {SimpleCollateral} from "./mocks/SimpleCollateral.sol"; -import {Math} from "@openzeppelin/contracts/utils/math/Math.sol"; - -contract VaultTest is Test { - using Math for uint256; - - address owner; - address alice; - uint256 alicePrivateKey; - address bob; - uint256 bobPrivateKey; - - VaultFactory vaultFactory; - NetworkRegistry networkRegistry; - OperatorRegistry operatorRegistry; - MetadataService operatorMetadataService; - MetadataService networkMetadataService; - NetworkMiddlewareService networkMiddlewareService; - NetworkOptInService networkVaultOptInService; - OperatorOptInService operatorVaultOptInService; - OperatorOptInService operatorNetworkOptInService; - - IVault vault; - - SimpleCollateral collateral; - - function setUp() public { - owner = address(this); - (alice, alicePrivateKey) = makeAddrAndKey("alice"); - (bob, bobPrivateKey) = makeAddrAndKey("bob"); - - vaultFactory = new VaultFactory(owner); - networkRegistry = new NetworkRegistry(); - operatorRegistry = new OperatorRegistry(); - operatorMetadataService = new MetadataService(address(operatorRegistry)); - networkMetadataService = new MetadataService(address(networkRegistry)); - networkMiddlewareService = new NetworkMiddlewareService(address(networkRegistry)); - networkVaultOptInService = new NetworkOptInService(address(networkRegistry), address(vaultFactory)); - operatorVaultOptInService = new OperatorOptInService(address(operatorRegistry), address(vaultFactory)); - operatorNetworkOptInService = new OperatorOptInService(address(operatorRegistry), address(networkRegistry)); - - vaultFactory.whitelist( - address( - new Vault( - address(vaultFactory), - address(networkRegistry), - address(networkMiddlewareService), - address(networkVaultOptInService), - address(operatorVaultOptInService), - address(operatorNetworkOptInService) - ) - ) - ); - - Token token = new Token("Token"); - collateral = new SimpleCollateral(address(token)); - - collateral.mint(token.totalSupply()); - } - - function test_Create( - uint48 epochDuration, - uint48 vetoDuration, - uint48 executeDuration, - address rewardsDistributor, - uint256 adminFee, - bool depositWhitelist - ) public { - epochDuration = uint48(bound(epochDuration, 1, 50 weeks)); - vetoDuration = uint48(bound(vetoDuration, 0, type(uint48).max / 2)); - executeDuration = uint48(bound(executeDuration, 0, type(uint48).max / 2)); - vm.assume(vetoDuration + executeDuration <= epochDuration); - adminFee = bound(adminFee, 0, 10_000); - - vault = IVault( - vaultFactory.create( - vaultFactory.lastVersion(), - alice, - abi.encode( - IVault.InitParams({ - collateral: address(collateral), - epochDuration: epochDuration, - vetoDuration: vetoDuration, - executeDuration: executeDuration, - rewardsDistributor: rewardsDistributor, - adminFee: adminFee, - depositWhitelist: depositWhitelist - }) - ) - ) - ); - - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - - assertEq(vault.ADMIN_FEE_BASE(), 10_000); - assertEq(vault.NETWORK_RESOLVER_LIMIT_SET_ROLE(), keccak256("NETWORK_RESOLVER_LIMIT_SET_ROLE")); - assertEq(vault.OPERATOR_NETWORK_LIMIT_SET_ROLE(), keccak256("OPERATOR_NETWORK_LIMIT_SET_ROLE")); - assertEq(vault.NETWORK_REGISTRY(), address(networkRegistry)); - - assertEq(vault.collateral(), address(collateral)); - assertEq(vault.epochDurationInit(), blockTimestamp); - assertEq(vault.epochDuration(), epochDuration); - vm.expectRevert(IVaultStorage.InvalidTimestamp.selector); - assertEq(vault.epochAt(0), 0); - assertEq(vault.epochAt(uint48(blockTimestamp)), 0); - assertEq(vault.currentEpoch(), 0); - assertEq(vault.currentEpochStart(), blockTimestamp); - vm.expectRevert(IVaultStorage.NoPreviousEpoch.selector); - vault.previousEpochStart(); - assertEq(vault.vetoDuration(), vetoDuration); - assertEq(vault.executeDuration(), executeDuration); - assertEq(vault.totalSupplyIn(0), 0); - assertEq(vault.totalSupply(), 0); - assertEq(vault.activeSharesAt(uint48(blockTimestamp)), 0); - assertEq(vault.activeShares(), 0); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), 0); - assertEq(vault.activeSupply(), 0); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), 0); - assertEq(vault.activeSharesOf(alice), 0); - assertEq(vault.activeSharesOfCheckpointsLength(alice), 0); - vm.expectRevert(); - vault.activeSharesOfCheckpoint(alice, 0); - assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), 0); - assertEq(vault.activeBalanceOf(alice), 0); - assertEq(vault.withdrawals(0), 0); - assertEq(vault.withdrawalShares(0), 0); - assertEq(vault.pendingWithdrawalSharesOf(0, alice), 0); - assertEq(vault.firstDepositAt(alice), 0); - assertEq(vault.slashableAmount(address(0), address(0), address(0)), 0); - assertEq(vault.slashRequestsLength(), 0); - vm.expectRevert(); - vault.slashRequests(0); - assertEq(vault.maxNetworkResolverLimit(address(0), address(0)), 0); - assertEq(vault.networkResolverLimitIn(address(0), address(0), 1), 0); - assertEq(vault.networkResolverLimit(address(0), address(0)), 0); - (uint256 nextNetworkResolverLimitAmount, uint256 nextNetworkResolverLimitTimestamp) = - vault.nextNetworkResolverLimit(address(0), address(0)); - assertEq(nextNetworkResolverLimitAmount, 0); - assertEq(nextNetworkResolverLimitTimestamp, 0); - assertEq(vault.operatorNetworkLimitIn(address(0), address(0), 1), 0); - assertEq(vault.operatorNetworkLimit(address(0), address(0)), 0); - (uint256 nextOperatorNetworkLimitAmount, uint256 nextOperatorNetworkLimitTimestamp) = - vault.nextOperatorNetworkLimit(address(0), address(0)); - assertEq(nextOperatorNetworkLimitAmount, 0); - assertEq(nextOperatorNetworkLimitTimestamp, 0); - assertEq(vault.minStakeDuring(address(0), address(0), address(0), 1), 0); - assertEq(vault.adminFee(), adminFee); - assertEq(vault.depositWhitelist(), depositWhitelist); - assertEq(vault.isDepositorWhitelisted(alice), false); - - blockTimestamp = blockTimestamp + vault.epochDuration() - 1; - vm.warp(blockTimestamp); - - assertEq(vault.epochAt(uint48(blockTimestamp)), 0); - assertEq(vault.epochAt(uint48(blockTimestamp + 1)), 1); - assertEq(vault.currentEpoch(), 0); - assertEq(vault.currentEpochStart(), blockTimestamp - (vault.epochDuration() - 1)); - vm.expectRevert(IVaultStorage.NoPreviousEpoch.selector); - vault.previousEpochStart(); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - assertEq(vault.epochAt(uint48(blockTimestamp)), 1); - assertEq(vault.epochAt(uint48(blockTimestamp + 2 * vault.epochDuration())), 3); - assertEq(vault.currentEpoch(), 1); - assertEq(vault.currentEpochStart(), blockTimestamp); - assertEq(vault.previousEpochStart(), blockTimestamp - vault.epochDuration()); - - blockTimestamp = blockTimestamp + vault.epochDuration() - 1; - vm.warp(blockTimestamp); - - assertEq(vault.epochAt(uint48(blockTimestamp)), 1); - assertEq(vault.epochAt(uint48(blockTimestamp + 1)), 2); - assertEq(vault.currentEpoch(), 1); - assertEq(vault.currentEpochStart(), blockTimestamp - (vault.epochDuration() - 1)); - assertEq(vault.previousEpochStart(), blockTimestamp - (vault.epochDuration() - 1) - vault.epochDuration()); - } - - function test_DepositTwice(uint256 amount1, uint256 amount2) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - - uint256 tokensBefore = collateral.balanceOf(address(vault)); - uint256 shares1 = amount1 * 10 ** 3; - assertEq(_deposit(alice, amount1), shares1); - assertEq(collateral.balanceOf(address(vault)) - tokensBefore, amount1); - - assertEq(vault.totalSupplyIn(0), amount1); - assertEq(vault.totalSupplyIn(1), amount1); - assertEq(vault.totalSupplyIn(2), amount1); - assertEq(vault.totalSupply(), amount1); - assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), 0); - assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares1); - assertEq(vault.activeShares(), shares1); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), 0); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), amount1); - assertEq(vault.activeSupply(), amount1); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), 0); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares1); - assertEq(vault.activeSharesOf(alice), shares1); - assertEq(vault.activeSharesOfCheckpointsLength(alice), 1); - assertEq(vault.activeSharesOfAtHint(alice, uint48(blockTimestamp), 0), shares1); - (uint48 timestampCheckpoint, uint256 valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 0); - assertEq(timestampCheckpoint, blockTimestamp); - assertEq(valueCheckpoint, shares1); - assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), 0); - assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), amount1); - assertEq(vault.activeBalanceOf(alice), amount1); - assertEq(vault.firstDepositAt(alice), uint48(blockTimestamp)); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - uint256 shares2 = amount2 * (shares1 + 10 ** 3) / (amount1 + 1); - assertEq(_deposit(alice, amount2), shares2); - - assertEq(vault.totalSupplyIn(0), amount1 + amount2); - assertEq(vault.totalSupplyIn(1), amount1 + amount2); - assertEq(vault.totalSupplyIn(2), amount1 + amount2); - assertEq(vault.totalSupply(), amount1 + amount2); - assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), shares1); - assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares1 + shares2); - assertEq(vault.activeShares(), shares1 + shares2); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), amount1); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), amount1 + amount2); - assertEq(vault.activeSupply(), amount1 + amount2); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), shares1); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares1 + shares2); - assertEq(vault.activeSharesOf(alice), shares1 + shares2); - assertEq(vault.activeSharesOfCheckpointsLength(alice), 2); - uint256 gasLeft = gasleft(); - assertEq(vault.activeSharesOfAtHint(alice, uint48(blockTimestamp - 1), 1), shares1); - uint256 gasSpent = gasLeft - gasleft(); - gasLeft = gasleft(); - assertEq(vault.activeSharesOfAtHint(alice, uint48(blockTimestamp - 1), 0), shares1); - assertGt(gasSpent, gasLeft - gasleft()); - gasLeft = gasleft(); - assertEq(vault.activeSharesOfAtHint(alice, uint48(blockTimestamp), 0), shares1 + shares2); - gasSpent = gasLeft - gasleft(); - gasLeft = gasleft(); - assertEq(vault.activeSharesOfAtHint(alice, uint48(blockTimestamp), 1), shares1 + shares2); - assertGt(gasSpent, gasLeft - gasleft()); - (timestampCheckpoint, valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 0); - assertEq(timestampCheckpoint, blockTimestamp - 1); - assertEq(valueCheckpoint, shares1); - (timestampCheckpoint, valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 1); - assertEq(timestampCheckpoint, blockTimestamp); - assertEq(valueCheckpoint, shares1 + shares2); - assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), amount1); - assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), amount1 + amount2); - assertEq(vault.activeBalanceOf(alice), amount1 + amount2); - assertEq(vault.firstDepositAt(alice), uint48(blockTimestamp - 1)); - } - - function test_DepositBoth(uint256 amount1, uint256 amount2) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - - uint256 shares1 = amount1 * 10 ** 3; - assertEq(_deposit(alice, amount1), shares1); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - uint256 shares2 = amount2 * (shares1 + 10 ** 3) / (amount1 + 1); - assertEq(_deposit(bob, amount2), shares2); - - assertEq(vault.totalSupply(), amount1 + amount2); - assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), shares1); - assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares1 + shares2); - assertEq(vault.activeShares(), shares1 + shares2); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), amount1); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), amount1 + amount2); - assertEq(vault.activeSupply(), amount1 + amount2); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), shares1); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares1); - assertEq(vault.activeSharesOf(alice), shares1); - assertEq(vault.activeSharesOfCheckpointsLength(alice), 1); - (uint48 timestampCheckpoint, uint256 valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 0); - assertEq(timestampCheckpoint, blockTimestamp - 1); - assertEq(valueCheckpoint, shares1); - assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), amount1); - assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), amount1); - assertEq(vault.activeBalanceOf(alice), amount1); - assertEq(vault.activeSharesOfAt(bob, uint48(blockTimestamp - 1)), 0); - assertEq(vault.activeSharesOfAt(bob, uint48(blockTimestamp)), shares2); - assertEq(vault.activeSharesOf(bob), shares2); - assertEq(vault.activeSharesOfCheckpointsLength(bob), 1); - (timestampCheckpoint, valueCheckpoint) = vault.activeSharesOfCheckpoint(bob, 0); - assertEq(timestampCheckpoint, blockTimestamp); - assertEq(valueCheckpoint, shares2); - assertEq(vault.activeBalanceOfAt(bob, uint48(blockTimestamp - 1)), 0); - assertEq(vault.activeBalanceOfAt(bob, uint48(blockTimestamp)), amount2); - assertEq(vault.activeBalanceOf(bob), amount2); - } - - function test_DepositRevertInsufficientDeposit() public { - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - vm.startPrank(alice); - vm.expectRevert(IVault.InsufficientDeposit.selector); - vault.deposit(alice, 0); - vm.stopPrank(); - } - - function test_WithdrawTwice(uint256 amount1, uint256 amount2, uint256 amount3) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - amount3 = bound(amount3, 1, 100 * 10 ** 18); - vm.assume(amount1 >= amount2 + amount3); - - // uint48 epochDuration = 1; - // uint48 vetoDuration = 0; - // uint48 executeDuration = 1; - vault = _getVault(1, 0, 1); - - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - - uint256 shares = _deposit(alice, amount1); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - uint256 tokensBefore = collateral.balanceOf(address(vault)); - uint256 burnedShares = amount2 * (shares + 10 ** 3) / (amount1 + 1); - uint256 mintedShares = amount2 * 10 ** 3; - (uint256 burnedShares_, uint256 mintedShares_) = _withdraw(alice, amount2); - assertEq(burnedShares_, burnedShares); - assertEq(mintedShares_, mintedShares); - assertEq(tokensBefore - collateral.balanceOf(address(vault)), 0); - - assertEq(vault.totalSupplyIn(0), amount1); - assertEq(vault.totalSupplyIn(1), amount1); - assertEq(vault.totalSupplyIn(2), amount1 - amount2); - assertEq(vault.totalSupply(), amount1); - assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), shares); - assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares - burnedShares); - assertEq(vault.activeShares(), shares - burnedShares); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), amount1); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), amount1 - amount2); - assertEq(vault.activeSupply(), amount1 - amount2); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), shares); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares - burnedShares); - assertEq(vault.activeSharesOf(alice), shares - burnedShares); - assertEq(vault.activeSharesOfCheckpointsLength(alice), 2); - (uint48 timestampCheckpoint, uint256 valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 1); - assertEq(timestampCheckpoint, blockTimestamp); - assertEq(valueCheckpoint, shares - burnedShares); - assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), amount1); - assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), amount1 - amount2); - assertEq(vault.activeBalanceOf(alice), amount1 - amount2); - assertEq(vault.withdrawals(vault.currentEpoch()), 0); - assertEq(vault.withdrawals(vault.currentEpoch() + 1), amount2); - assertEq(vault.withdrawals(vault.currentEpoch() + 2), 0); - assertEq(vault.withdrawalShares(vault.currentEpoch()), 0); - assertEq(vault.withdrawalShares(vault.currentEpoch() + 1), mintedShares); - assertEq(vault.withdrawalShares(vault.currentEpoch() + 2), 0); - assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch(), alice), 0); - assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch() + 1, alice), mintedShares); - assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch() + 2, alice), 0); - - shares -= burnedShares; - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - burnedShares = amount3 * (shares + 10 ** 3) / (amount1 - amount2 + 1); - mintedShares = amount3 * 10 ** 3; - (burnedShares_, mintedShares_) = _withdraw(alice, amount3); - assertEq(burnedShares_, burnedShares); - assertEq(mintedShares_, mintedShares); - - assertEq(vault.totalSupplyIn(0), amount1); - assertEq(vault.totalSupplyIn(1), amount1 - amount2); - assertEq(vault.totalSupplyIn(2), amount1 - amount2 - amount3); - assertEq(vault.totalSupply(), amount1); - assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), shares); - assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares - burnedShares); - assertEq(vault.activeShares(), shares - burnedShares); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), amount1 - amount2); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), amount1 - amount2 - amount3); - assertEq(vault.activeSupply(), amount1 - amount2 - amount3); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), shares); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares - burnedShares); - assertEq(vault.activeSharesOf(alice), shares - burnedShares); - assertEq(vault.activeSharesOfCheckpointsLength(alice), 3); - (timestampCheckpoint, valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 2); - assertEq(timestampCheckpoint, blockTimestamp); - assertEq(valueCheckpoint, shares - burnedShares); - assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), amount1 - amount2); - assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), amount1 - amount2 - amount3); - assertEq(vault.activeBalanceOf(alice), amount1 - amount2 - amount3); - assertEq(vault.withdrawals(vault.currentEpoch() - 1), 0); - assertEq(vault.withdrawals(vault.currentEpoch()), amount2); - assertEq(vault.withdrawals(vault.currentEpoch() + 1), amount3); - assertEq(vault.withdrawals(vault.currentEpoch() + 2), 0); - assertEq(vault.withdrawalShares(vault.currentEpoch() - 1), 0); - assertEq(vault.withdrawalShares(vault.currentEpoch()), amount2 * 10 ** 3); - assertEq(vault.withdrawalShares(vault.currentEpoch() + 1), amount3 * 10 ** 3); - assertEq(vault.withdrawalShares(vault.currentEpoch() + 2), 0); - assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch() - 1, alice), 0); - assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch(), alice), amount2 * 10 ** 3); - assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch() + 1, alice), amount3 * 10 ** 3); - assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch() + 2, alice), 0); - - shares -= burnedShares; - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - assertEq(vault.totalSupplyIn(0), amount1 - amount2); - assertEq(vault.totalSupplyIn(1), amount1 - amount2 - amount3); - assertEq(vault.totalSupplyIn(2), amount1 - amount2 - amount3); - assertEq(vault.totalSupply(), amount1 - amount2); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - assertEq(vault.totalSupplyIn(0), amount1 - amount2 - amount3); - assertEq(vault.totalSupplyIn(1), amount1 - amount2 - amount3); - assertEq(vault.totalSupplyIn(2), amount1 - amount2 - amount3); - assertEq(vault.totalSupply(), amount1 - amount2 - amount3); - } - - function test_WithdrawRevertInsufficientWithdrawal(uint256 amount1) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - _deposit(alice, amount1); - - vm.expectRevert(IVault.InsufficientWithdrawal.selector); - _withdraw(alice, 0); - } - - function test_WithdrawRevertTooMuchWithdraw(uint256 amount1) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - _deposit(alice, amount1); - - vm.expectRevert(IVault.TooMuchWithdraw.selector); - _withdraw(alice, amount1 + 1); - } - - function test_Claim(uint256 amount1, uint256 amount2) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - vm.assume(amount1 >= amount2); - - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// // SPDX-License-Identifier: MIT +// pragma solidity 0.8.25; + +// import {Test, console2} from "forge-std/Test.sol"; + +// import {VaultFactory} from "src/contracts/VaultFactory.sol"; +// import {NetworkRegistry} from "src/contracts/NetworkRegistry.sol"; +// import {OperatorRegistry} from "src/contracts/OperatorRegistry.sol"; +// import {MetadataService} from "src/contracts/MetadataService.sol"; +// import {NetworkMiddlewareService} from "src/contracts/NetworkMiddlewareService.sol"; +// import {NetworkOptInService} from "src/contracts/NetworkOptInService.sol"; +// import {OperatorOptInService} from "src/contracts/OperatorOptInService.sol"; + +// import {Vault} from "src/contracts/vault/v1/Vault.sol"; +// import {IVault} from "src/interfaces/vault/v1/IVault.sol"; +// import {IVaultStorage} from "src/interfaces/vault/v1/IVaultStorage.sol"; + +// import {Token} from "./mocks/Token.sol"; +// import {SimpleCollateral} from "./mocks/SimpleCollateral.sol"; +// import {Math} from "@openzeppelin/contracts/utils/math/Math.sol"; + +// contract VaultTest is Test { +// using Math for uint256; + +// address owner; +// address alice; +// uint256 alicePrivateKey; +// address bob; +// uint256 bobPrivateKey; + +// VaultFactory vaultFactory; +// NetworkRegistry networkRegistry; +// OperatorRegistry operatorRegistry; +// MetadataService operatorMetadataService; +// MetadataService networkMetadataService; +// NetworkMiddlewareService networkMiddlewareService; +// NetworkOptInService networkVaultOptInService; +// OperatorOptInService operatorVaultOptInService; +// OperatorOptInService operatorNetworkOptInService; + +// IVault vault; + +// SimpleCollateral collateral; + +// function setUp() public { +// owner = address(this); +// (alice, alicePrivateKey) = makeAddrAndKey("alice"); +// (bob, bobPrivateKey) = makeAddrAndKey("bob"); + +// vaultFactory = new VaultFactory(owner); +// networkRegistry = new NetworkRegistry(); +// operatorRegistry = new OperatorRegistry(); +// operatorMetadataService = new MetadataService(address(operatorRegistry)); +// networkMetadataService = new MetadataService(address(networkRegistry)); +// networkMiddlewareService = new NetworkMiddlewareService(address(networkRegistry)); +// networkVaultOptInService = new NetworkOptInService(address(networkRegistry), address(vaultFactory)); +// operatorVaultOptInService = new OperatorOptInService(address(operatorRegistry), address(vaultFactory)); +// operatorNetworkOptInService = new OperatorOptInService(address(operatorRegistry), address(networkRegistry)); + +// vaultFactory.whitelist( +// address( +// new Vault( +// address(vaultFactory), +// address(networkRegistry), +// address(networkMiddlewareService), +// address(networkVaultOptInService), +// address(operatorVaultOptInService), +// address(operatorNetworkOptInService) +// ) +// ) +// ); + +// Token token = new Token("Token"); +// collateral = new SimpleCollateral(address(token)); + +// collateral.mint(token.totalSupply()); +// } + +// function test_Create( +// uint48 epochDuration, +// uint48 vetoDuration, +// uint48 executeDuration, +// address rewardsDistributor, +// uint256 adminFee, +// bool depositWhitelist +// ) public { +// epochDuration = uint48(bound(epochDuration, 1, 50 weeks)); +// vetoDuration = uint48(bound(vetoDuration, 0, type(uint48).max / 2)); +// executeDuration = uint48(bound(executeDuration, 0, type(uint48).max / 2)); +// vm.assume(vetoDuration + executeDuration <= epochDuration); +// adminFee = bound(adminFee, 0, 10_000); + +// vault = IVault( +// vaultFactory.create( +// vaultFactory.lastVersion(), +// alice, +// abi.encode( +// IVault.InitParams({ +// collateral: address(collateral), +// epochDuration: epochDuration, +// vetoDuration: vetoDuration, +// executeDuration: executeDuration, +// rewardsDistributor: rewardsDistributor, +// adminFee: adminFee, +// depositWhitelist: depositWhitelist +// }) +// ) +// ) +// ); + +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; + +// assertEq(vault.ADMIN_FEE_BASE(), 10_000); +// assertEq(vault.NETWORK_RESOLVER_LIMIT_SET_ROLE(), keccak256("NETWORK_RESOLVER_LIMIT_SET_ROLE")); +// assertEq(vault.OPERATOR_NETWORK_LIMIT_SET_ROLE(), keccak256("OPERATOR_NETWORK_LIMIT_SET_ROLE")); +// assertEq(vault.NETWORK_REGISTRY(), address(networkRegistry)); + +// assertEq(vault.collateral(), address(collateral)); +// assertEq(vault.epochDurationInit(), blockTimestamp); +// assertEq(vault.epochDuration(), epochDuration); +// vm.expectRevert(IVaultStorage.InvalidTimestamp.selector); +// assertEq(vault.epochAt(0), 0); +// assertEq(vault.epochAt(uint48(blockTimestamp)), 0); +// assertEq(vault.currentEpoch(), 0); +// assertEq(vault.currentEpochStart(), blockTimestamp); +// vm.expectRevert(IVaultStorage.NoPreviousEpoch.selector); +// vault.previousEpochStart(); +// assertEq(vault.vetoDuration(), vetoDuration); +// assertEq(vault.executeDuration(), executeDuration); +// assertEq(vault.totalSupplyIn(0), 0); +// assertEq(vault.totalSupply(), 0); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp)), 0); +// assertEq(vault.activeShares(), 0); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), 0); +// assertEq(vault.activeSupply(), 0); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), 0); +// assertEq(vault.activeSharesOf(alice), 0); +// assertEq(vault.activeSharesOfCheckpointsLength(alice), 0); +// vm.expectRevert(); +// vault.activeSharesOfCheckpoint(alice, 0); +// assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), 0); +// assertEq(vault.activeBalanceOf(alice), 0); +// assertEq(vault.withdrawals(0), 0); +// assertEq(vault.withdrawalShares(0), 0); +// assertEq(vault.pendingWithdrawalSharesOf(0, alice), 0); +// assertEq(vault.firstDepositAt(alice), 0); +// assertEq(vault.slashableAmount(address(0), address(0), address(0)), 0); +// assertEq(vault.slashRequestsLength(), 0); +// vm.expectRevert(); +// vault.slashRequests(0); +// assertEq(vault.maxNetworkResolverLimit(address(0), address(0)), 0); +// assertEq(vault.networkResolverLimitIn(address(0), address(0), 1), 0); +// assertEq(vault.networkResolverLimit(address(0), address(0)), 0); +// (uint256 nextNetworkResolverLimitAmount, uint256 nextNetworkResolverLimitTimestamp) = +// vault.nextNetworkResolverLimit(address(0), address(0)); +// assertEq(nextNetworkResolverLimitAmount, 0); +// assertEq(nextNetworkResolverLimitTimestamp, 0); +// assertEq(vault.operatorNetworkLimitIn(address(0), address(0), 1), 0); +// assertEq(vault.operatorNetworkLimit(address(0), address(0)), 0); +// (uint256 nextOperatorNetworkLimitAmount, uint256 nextOperatorNetworkLimitTimestamp) = +// vault.nextOperatorNetworkLimit(address(0), address(0)); +// assertEq(nextOperatorNetworkLimitAmount, 0); +// assertEq(nextOperatorNetworkLimitTimestamp, 0); +// assertEq(vault.minStakeDuring(address(0), address(0), address(0), 1), 0); +// assertEq(vault.adminFee(), adminFee); +// assertEq(vault.depositWhitelist(), depositWhitelist); +// assertEq(vault.isDepositorWhitelisted(alice), false); + +// blockTimestamp = blockTimestamp + vault.epochDuration() - 1; +// vm.warp(blockTimestamp); + +// assertEq(vault.epochAt(uint48(blockTimestamp)), 0); +// assertEq(vault.epochAt(uint48(blockTimestamp + 1)), 1); +// assertEq(vault.currentEpoch(), 0); +// assertEq(vault.currentEpochStart(), blockTimestamp - (vault.epochDuration() - 1)); +// vm.expectRevert(IVaultStorage.NoPreviousEpoch.selector); +// vault.previousEpochStart(); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// assertEq(vault.epochAt(uint48(blockTimestamp)), 1); +// assertEq(vault.epochAt(uint48(blockTimestamp + 2 * vault.epochDuration())), 3); +// assertEq(vault.currentEpoch(), 1); +// assertEq(vault.currentEpochStart(), blockTimestamp); +// assertEq(vault.previousEpochStart(), blockTimestamp - vault.epochDuration()); + +// blockTimestamp = blockTimestamp + vault.epochDuration() - 1; +// vm.warp(blockTimestamp); + +// assertEq(vault.epochAt(uint48(blockTimestamp)), 1); +// assertEq(vault.epochAt(uint48(blockTimestamp + 1)), 2); +// assertEq(vault.currentEpoch(), 1); +// assertEq(vault.currentEpochStart(), blockTimestamp - (vault.epochDuration() - 1)); +// assertEq(vault.previousEpochStart(), blockTimestamp - (vault.epochDuration() - 1) - vault.epochDuration()); +// } + +// function test_DepositTwice(uint256 amount1, uint256 amount2) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); + +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; + +// uint256 tokensBefore = collateral.balanceOf(address(vault)); +// uint256 shares1 = amount1 * 10 ** 3; +// assertEq(_deposit(alice, amount1), shares1); +// assertEq(collateral.balanceOf(address(vault)) - tokensBefore, amount1); + +// assertEq(vault.totalSupplyIn(0), amount1); +// assertEq(vault.totalSupplyIn(1), amount1); +// assertEq(vault.totalSupplyIn(2), amount1); +// assertEq(vault.totalSupply(), amount1); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), 0); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares1); +// assertEq(vault.activeShares(), shares1); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), 0); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), amount1); +// assertEq(vault.activeSupply(), amount1); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), 0); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares1); +// assertEq(vault.activeSharesOf(alice), shares1); +// assertEq(vault.activeSharesOfCheckpointsLength(alice), 1); +// assertEq(vault.activeSharesOfAtHint(alice, uint48(blockTimestamp), 0), shares1); +// (uint48 timestampCheckpoint, uint256 valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 0); +// assertEq(timestampCheckpoint, blockTimestamp); +// assertEq(valueCheckpoint, shares1); +// assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), 0); +// assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), amount1); +// assertEq(vault.activeBalanceOf(alice), amount1); +// assertEq(vault.firstDepositAt(alice), uint48(blockTimestamp)); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// uint256 shares2 = amount2 * (shares1 + 10 ** 3) / (amount1 + 1); +// assertEq(_deposit(alice, amount2), shares2); + +// assertEq(vault.totalSupplyIn(0), amount1 + amount2); +// assertEq(vault.totalSupplyIn(1), amount1 + amount2); +// assertEq(vault.totalSupplyIn(2), amount1 + amount2); +// assertEq(vault.totalSupply(), amount1 + amount2); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), shares1); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares1 + shares2); +// assertEq(vault.activeShares(), shares1 + shares2); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), amount1); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), amount1 + amount2); +// assertEq(vault.activeSupply(), amount1 + amount2); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), shares1); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares1 + shares2); +// assertEq(vault.activeSharesOf(alice), shares1 + shares2); +// assertEq(vault.activeSharesOfCheckpointsLength(alice), 2); +// uint256 gasLeft = gasleft(); +// assertEq(vault.activeSharesOfAtHint(alice, uint48(blockTimestamp - 1), 1), shares1); +// uint256 gasSpent = gasLeft - gasleft(); +// gasLeft = gasleft(); +// assertEq(vault.activeSharesOfAtHint(alice, uint48(blockTimestamp - 1), 0), shares1); +// assertGt(gasSpent, gasLeft - gasleft()); +// gasLeft = gasleft(); +// assertEq(vault.activeSharesOfAtHint(alice, uint48(blockTimestamp), 0), shares1 + shares2); +// gasSpent = gasLeft - gasleft(); +// gasLeft = gasleft(); +// assertEq(vault.activeSharesOfAtHint(alice, uint48(blockTimestamp), 1), shares1 + shares2); +// assertGt(gasSpent, gasLeft - gasleft()); +// (timestampCheckpoint, valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 0); +// assertEq(timestampCheckpoint, blockTimestamp - 1); +// assertEq(valueCheckpoint, shares1); +// (timestampCheckpoint, valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 1); +// assertEq(timestampCheckpoint, blockTimestamp); +// assertEq(valueCheckpoint, shares1 + shares2); +// assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), amount1); +// assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), amount1 + amount2); +// assertEq(vault.activeBalanceOf(alice), amount1 + amount2); +// assertEq(vault.firstDepositAt(alice), uint48(blockTimestamp - 1)); +// } + +// function test_DepositBoth(uint256 amount1, uint256 amount2) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); + +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; + +// uint256 shares1 = amount1 * 10 ** 3; +// assertEq(_deposit(alice, amount1), shares1); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// uint256 shares2 = amount2 * (shares1 + 10 ** 3) / (amount1 + 1); +// assertEq(_deposit(bob, amount2), shares2); + +// assertEq(vault.totalSupply(), amount1 + amount2); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), shares1); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares1 + shares2); +// assertEq(vault.activeShares(), shares1 + shares2); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), amount1); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), amount1 + amount2); +// assertEq(vault.activeSupply(), amount1 + amount2); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), shares1); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares1); +// assertEq(vault.activeSharesOf(alice), shares1); +// assertEq(vault.activeSharesOfCheckpointsLength(alice), 1); +// (uint48 timestampCheckpoint, uint256 valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 0); +// assertEq(timestampCheckpoint, blockTimestamp - 1); +// assertEq(valueCheckpoint, shares1); +// assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), amount1); +// assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), amount1); +// assertEq(vault.activeBalanceOf(alice), amount1); +// assertEq(vault.activeSharesOfAt(bob, uint48(blockTimestamp - 1)), 0); +// assertEq(vault.activeSharesOfAt(bob, uint48(blockTimestamp)), shares2); +// assertEq(vault.activeSharesOf(bob), shares2); +// assertEq(vault.activeSharesOfCheckpointsLength(bob), 1); +// (timestampCheckpoint, valueCheckpoint) = vault.activeSharesOfCheckpoint(bob, 0); +// assertEq(timestampCheckpoint, blockTimestamp); +// assertEq(valueCheckpoint, shares2); +// assertEq(vault.activeBalanceOfAt(bob, uint48(blockTimestamp - 1)), 0); +// assertEq(vault.activeBalanceOfAt(bob, uint48(blockTimestamp)), amount2); +// assertEq(vault.activeBalanceOf(bob), amount2); +// } + +// function test_DepositRevertInsufficientDeposit() public { +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// vm.startPrank(alice); +// vm.expectRevert(IVault.InsufficientDeposit.selector); +// vault.deposit(alice, 0); +// vm.stopPrank(); +// } + +// function test_WithdrawTwice(uint256 amount1, uint256 amount2, uint256 amount3) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// amount3 = bound(amount3, 1, 100 * 10 ** 18); +// vm.assume(amount1 >= amount2 + amount3); + +// // uint48 epochDuration = 1; +// // uint48 vetoDuration = 0; +// // uint48 executeDuration = 1; +// vault = _getVault(1, 0, 1); + +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; + +// uint256 shares = _deposit(alice, amount1); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// uint256 tokensBefore = collateral.balanceOf(address(vault)); +// uint256 burnedShares = amount2 * (shares + 10 ** 3) / (amount1 + 1); +// uint256 mintedShares = amount2 * 10 ** 3; +// (uint256 burnedShares_, uint256 mintedShares_) = _withdraw(alice, amount2); +// assertEq(burnedShares_, burnedShares); +// assertEq(mintedShares_, mintedShares); +// assertEq(tokensBefore - collateral.balanceOf(address(vault)), 0); + +// assertEq(vault.totalSupplyIn(0), amount1); +// assertEq(vault.totalSupplyIn(1), amount1); +// assertEq(vault.totalSupplyIn(2), amount1 - amount2); +// assertEq(vault.totalSupply(), amount1); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), shares); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares - burnedShares); +// assertEq(vault.activeShares(), shares - burnedShares); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), amount1); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), amount1 - amount2); +// assertEq(vault.activeSupply(), amount1 - amount2); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), shares); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares - burnedShares); +// assertEq(vault.activeSharesOf(alice), shares - burnedShares); +// assertEq(vault.activeSharesOfCheckpointsLength(alice), 2); +// (uint48 timestampCheckpoint, uint256 valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 1); +// assertEq(timestampCheckpoint, blockTimestamp); +// assertEq(valueCheckpoint, shares - burnedShares); +// assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), amount1); +// assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), amount1 - amount2); +// assertEq(vault.activeBalanceOf(alice), amount1 - amount2); +// assertEq(vault.withdrawals(vault.currentEpoch()), 0); +// assertEq(vault.withdrawals(vault.currentEpoch() + 1), amount2); +// assertEq(vault.withdrawals(vault.currentEpoch() + 2), 0); +// assertEq(vault.withdrawalShares(vault.currentEpoch()), 0); +// assertEq(vault.withdrawalShares(vault.currentEpoch() + 1), mintedShares); +// assertEq(vault.withdrawalShares(vault.currentEpoch() + 2), 0); +// assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch(), alice), 0); +// assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch() + 1, alice), mintedShares); +// assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch() + 2, alice), 0); + +// shares -= burnedShares; + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// burnedShares = amount3 * (shares + 10 ** 3) / (amount1 - amount2 + 1); +// mintedShares = amount3 * 10 ** 3; +// (burnedShares_, mintedShares_) = _withdraw(alice, amount3); +// assertEq(burnedShares_, burnedShares); +// assertEq(mintedShares_, mintedShares); + +// assertEq(vault.totalSupplyIn(0), amount1); +// assertEq(vault.totalSupplyIn(1), amount1 - amount2); +// assertEq(vault.totalSupplyIn(2), amount1 - amount2 - amount3); +// assertEq(vault.totalSupply(), amount1); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), shares); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares - burnedShares); +// assertEq(vault.activeShares(), shares - burnedShares); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), amount1 - amount2); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), amount1 - amount2 - amount3); +// assertEq(vault.activeSupply(), amount1 - amount2 - amount3); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), shares); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares - burnedShares); +// assertEq(vault.activeSharesOf(alice), shares - burnedShares); +// assertEq(vault.activeSharesOfCheckpointsLength(alice), 3); +// (timestampCheckpoint, valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 2); +// assertEq(timestampCheckpoint, blockTimestamp); +// assertEq(valueCheckpoint, shares - burnedShares); +// assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), amount1 - amount2); +// assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), amount1 - amount2 - amount3); +// assertEq(vault.activeBalanceOf(alice), amount1 - amount2 - amount3); +// assertEq(vault.withdrawals(vault.currentEpoch() - 1), 0); +// assertEq(vault.withdrawals(vault.currentEpoch()), amount2); +// assertEq(vault.withdrawals(vault.currentEpoch() + 1), amount3); +// assertEq(vault.withdrawals(vault.currentEpoch() + 2), 0); +// assertEq(vault.withdrawalShares(vault.currentEpoch() - 1), 0); +// assertEq(vault.withdrawalShares(vault.currentEpoch()), amount2 * 10 ** 3); +// assertEq(vault.withdrawalShares(vault.currentEpoch() + 1), amount3 * 10 ** 3); +// assertEq(vault.withdrawalShares(vault.currentEpoch() + 2), 0); +// assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch() - 1, alice), 0); +// assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch(), alice), amount2 * 10 ** 3); +// assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch() + 1, alice), amount3 * 10 ** 3); +// assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch() + 2, alice), 0); + +// shares -= burnedShares; + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// assertEq(vault.totalSupplyIn(0), amount1 - amount2); +// assertEq(vault.totalSupplyIn(1), amount1 - amount2 - amount3); +// assertEq(vault.totalSupplyIn(2), amount1 - amount2 - amount3); +// assertEq(vault.totalSupply(), amount1 - amount2); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// assertEq(vault.totalSupplyIn(0), amount1 - amount2 - amount3); +// assertEq(vault.totalSupplyIn(1), amount1 - amount2 - amount3); +// assertEq(vault.totalSupplyIn(2), amount1 - amount2 - amount3); +// assertEq(vault.totalSupply(), amount1 - amount2 - amount3); +// } + +// function test_WithdrawRevertInsufficientWithdrawal(uint256 amount1) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); + +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// _deposit(alice, amount1); + +// vm.expectRevert(IVault.InsufficientWithdrawal.selector); +// _withdraw(alice, 0); +// } + +// function test_WithdrawRevertTooMuchWithdraw(uint256 amount1) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); + +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// _deposit(alice, amount1); + +// vm.expectRevert(IVault.TooMuchWithdraw.selector); +// _withdraw(alice, amount1 + 1); +// } + +// function test_Claim(uint256 amount1, uint256 amount2) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// vm.assume(amount1 >= amount2); + +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - - _deposit(alice, amount1); +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; + +// _deposit(alice, amount1); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - _withdraw(alice, amount2); - - blockTimestamp = blockTimestamp + 2; - vm.warp(blockTimestamp); - - uint256 tokensBefore = collateral.balanceOf(address(vault)); - uint256 tokensBeforeAlice = collateral.balanceOf(alice); - assertEq(_claim(alice, vault.currentEpoch() - 1), amount2); - assertEq(tokensBefore - collateral.balanceOf(address(vault)), amount2); - assertEq(collateral.balanceOf(alice) - tokensBeforeAlice, amount2); - - assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch() - 1, alice), 0); - } - - function test_ClaimRevertInvalidEpoch(uint256 amount1, uint256 amount2) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - vm.assume(amount1 >= amount2); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// _withdraw(alice, amount2); + +// blockTimestamp = blockTimestamp + 2; +// vm.warp(blockTimestamp); + +// uint256 tokensBefore = collateral.balanceOf(address(vault)); +// uint256 tokensBeforeAlice = collateral.balanceOf(alice); +// assertEq(_claim(alice, vault.currentEpoch() - 1), amount2); +// assertEq(tokensBefore - collateral.balanceOf(address(vault)), amount2); +// assertEq(collateral.balanceOf(alice) - tokensBeforeAlice, amount2); + +// assertEq(vault.pendingWithdrawalSharesOf(vault.currentEpoch() - 1, alice), 0); +// } + +// function test_ClaimRevertInvalidEpoch(uint256 amount1, uint256 amount2) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// vm.assume(amount1 >= amount2); - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - _deposit(alice, amount1); +// _deposit(alice, amount1); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - _withdraw(alice, amount2); +// _withdraw(alice, amount2); - blockTimestamp = blockTimestamp + 2; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 2; +// vm.warp(blockTimestamp); - uint256 currentEpoch = vault.currentEpoch(); - vm.expectRevert(IVault.InvalidEpoch.selector); - _claim(alice, currentEpoch); - } +// uint256 currentEpoch = vault.currentEpoch(); +// vm.expectRevert(IVault.InvalidEpoch.selector); +// _claim(alice, currentEpoch); +// } - function test_ClaimRevertInsufficientClaim1(uint256 amount1, uint256 amount2) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - vm.assume(amount1 >= amount2); +// function test_ClaimRevertInsufficientClaim1(uint256 amount1, uint256 amount2) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// vm.assume(amount1 >= amount2); - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - _deposit(alice, amount1); +// _deposit(alice, amount1); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - _withdraw(alice, amount2); +// _withdraw(alice, amount2); - blockTimestamp = blockTimestamp + 2; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 2; +// vm.warp(blockTimestamp); - uint256 currentEpoch = vault.currentEpoch(); - _claim(alice, currentEpoch - 1); +// uint256 currentEpoch = vault.currentEpoch(); +// _claim(alice, currentEpoch - 1); - vm.expectRevert(IVault.InsufficientClaim.selector); - _claim(alice, currentEpoch - 1); - } +// vm.expectRevert(IVault.InsufficientClaim.selector); +// _claim(alice, currentEpoch - 1); +// } - function test_ClaimRevertInsufficientClaim2(uint256 amount1, uint256 amount2) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - vm.assume(amount1 >= amount2); +// function test_ClaimRevertInsufficientClaim2(uint256 amount1, uint256 amount2) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// vm.assume(amount1 >= amount2); - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - _deposit(alice, amount1); +// _deposit(alice, amount1); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - _withdraw(alice, amount2); +// _withdraw(alice, amount2); - blockTimestamp = blockTimestamp + 2; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 2; +// vm.warp(blockTimestamp); - uint256 currentEpoch = vault.currentEpoch(); - vm.expectRevert(IVault.InsufficientClaim.selector); - _claim(alice, currentEpoch - 2); - } +// uint256 currentEpoch = vault.currentEpoch(); +// vm.expectRevert(IVault.InsufficientClaim.selector); +// _claim(alice, currentEpoch - 2); +// } - function test_RequestSlash( - uint256 amount1, - uint256 amount2, - uint256 amount3, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - amount3 = bound(amount2, 1, 100 * 10 ** 18); - vm.assume(amount1 >= amount3); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); +// function test_RequestSlash( +// uint256 amount1, +// uint256 amount2, +// uint256 amount3, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// amount3 = bound(amount2, 1, 100 * 10 ** 18); +// vm.assume(amount1 >= amount3); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); - // uint48 epochDuration = 3; - // uint48 executeDuration = 1; - // uint48 vetoDuration = 1; - vault = _getVault(3, 1, 1); +// // uint48 epochDuration = 3; +// // uint48 executeDuration = 1; +// // uint48 vetoDuration = 1; +// vault = _getVault(3, 1, 1); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - _deposit(alice, amount1); +// _deposit(alice, amount1); - _deposit(bob, amount2); +// _deposit(bob, amount2); - // address network = bob; - _registerNetwork(bob, bob); +// // address network = bob; +// _registerNetwork(bob, bob); - // address operator = bob; - _registerOperator(bob); +// // address operator = bob; +// _registerOperator(bob); - // address resolver = address(1); - _setMaxNetworkResolverLimit(bob, address(1), type(uint256).max); - _optInNetworkVault(bob, address(1)); +// // address resolver = address(1); +// _setMaxNetworkResolverLimit(bob, address(1), type(uint256).max); +// _optInNetworkVault(bob, address(1)); - _optInOperatorVault(bob); +// _optInOperatorVault(bob); - assertEq(vault.minStakeDuring(bob, address(1), bob, 3), 0); - assertEq(vault.slashableAmountIn(bob, address(1), bob, 0), 0); - assertEq(vault.slashableAmountIn(bob, address(1), bob, vault.epochDuration()), 0); - assertEq(vault.slashableAmount(bob, address(1), bob), 0); +// assertEq(vault.minStakeDuring(bob, address(1), bob, 3), 0); +// assertEq(vault.slashableAmountIn(bob, address(1), bob, 0), 0); +// assertEq(vault.slashableAmountIn(bob, address(1), bob, vault.epochDuration()), 0); +// assertEq(vault.slashableAmount(bob, address(1), bob), 0); - _setNetworkResolverLimit(alice, bob, address(1), networkResolverLimit); +// _setNetworkResolverLimit(alice, bob, address(1), networkResolverLimit); - assertEq(vault.minStakeDuring(bob, address(1), bob, 3), 0); - assertEq(vault.slashableAmountIn(bob, address(1), bob, 0), 0); - assertEq(vault.slashableAmountIn(bob, address(1), bob, vault.epochDuration()), 0); - assertEq(vault.slashableAmount(bob, address(1), bob), 0); +// assertEq(vault.minStakeDuring(bob, address(1), bob, 3), 0); +// assertEq(vault.slashableAmountIn(bob, address(1), bob, 0), 0); +// assertEq(vault.slashableAmountIn(bob, address(1), bob, vault.epochDuration()), 0); +// assertEq(vault.slashableAmount(bob, address(1), bob), 0); - _setOperatorNetworkLimit(alice, bob, bob, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, bob, bob, operatorNetworkLimit); - _optInOperatorNetwork(bob, bob); +// _optInOperatorNetwork(bob, bob); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - _withdraw(alice, amount3); +// _withdraw(alice, amount3); - uint256 slashableAmount_ = Math.min(amount1 + amount2, Math.min(networkResolverLimit, operatorNetworkLimit)); +// uint256 slashableAmount_ = Math.min(amount1 + amount2, Math.min(networkResolverLimit, operatorNetworkLimit)); - assertEq( - vault.minStakeDuring(bob, address(1), bob, 3), - Math.min(amount1 + amount2 - amount3, Math.min(networkResolverLimit, operatorNetworkLimit)) - ); - assertEq(vault.slashableAmountIn(bob, address(1), bob, 0), slashableAmount_); - assertEq(vault.slashableAmountIn(bob, address(1), bob, vault.epochDuration()), slashableAmount_); - assertEq( - vault.slashableAmountIn(bob, address(1), bob, 2 * vault.epochDuration()), - Math.min(amount1 + amount2 - amount3, Math.min(networkResolverLimit, operatorNetworkLimit)) - ); - assertEq(vault.slashableAmount(bob, address(1), bob), slashableAmount_); +// assertEq( +// vault.minStakeDuring(bob, address(1), bob, 3), +// Math.min(amount1 + amount2 - amount3, Math.min(networkResolverLimit, operatorNetworkLimit)) +// ); +// assertEq(vault.slashableAmountIn(bob, address(1), bob, 0), slashableAmount_); +// assertEq(vault.slashableAmountIn(bob, address(1), bob, vault.epochDuration()), slashableAmount_); +// assertEq( +// vault.slashableAmountIn(bob, address(1), bob, 2 * vault.epochDuration()), +// Math.min(amount1 + amount2 - amount3, Math.min(networkResolverLimit, operatorNetworkLimit)) +// ); +// assertEq(vault.slashableAmount(bob, address(1), bob), slashableAmount_); - assertEq(_requestSlash(bob, bob, address(1), bob, toSlash), 0); - assertEq(vault.slashRequestsLength(), 1); +// assertEq(_requestSlash(bob, bob, address(1), bob, toSlash), 0); +// assertEq(vault.slashRequestsLength(), 1); - ( - address network_, - address resolver_, - address operator_, - uint256 amount_, - uint48 vetoDeadline_, - uint48 executeDeadline_, - bool completed_ - ) = vault.slashRequests(0); +// ( +// address network_, +// address resolver_, +// address operator_, +// uint256 amount_, +// uint48 vetoDeadline_, +// uint48 executeDeadline_, +// bool completed_ +// ) = vault.slashRequests(0); - assertEq(network_, bob); - assertEq(resolver_, address(1)); - assertEq(operator_, bob); - assertEq(amount_, Math.min(slashableAmount_, toSlash)); - assertEq(vetoDeadline_, uint48(blockTimestamp + vault.vetoDuration())); - assertEq(executeDeadline_, uint48(blockTimestamp + vault.vetoDuration() + vault.executeDuration())); - assertEq(completed_, false); - } +// assertEq(network_, bob); +// assertEq(resolver_, address(1)); +// assertEq(operator_, bob); +// assertEq(amount_, Math.min(slashableAmount_, toSlash)); +// assertEq(vetoDeadline_, uint48(blockTimestamp + vault.vetoDuration())); +// assertEq(executeDeadline_, uint48(blockTimestamp + vault.vetoDuration() + vault.executeDuration())); +// assertEq(completed_, false); +// } - function test_RequestSlashRevertNotNetworkMiddleware( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); +// function test_RequestSlashRevertNotNetworkMiddleware( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - uint256 shares = _deposit(alice, amount1); +// uint256 shares = _deposit(alice, amount1); - shares += _deposit(bob, amount2); +// shares += _deposit(bob, amount2); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - address operator = bob; - _registerOperator(operator); +// address operator = bob; +// _registerOperator(operator); - address resolver = address(1); - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); +// address resolver = address(1); +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); - _optInOperatorVault(operator); +// _optInOperatorVault(operator); - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); - _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); - _optInOperatorNetwork(operator, network); +// _optInOperatorNetwork(operator, network); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - vm.expectRevert(IVault.NotNetworkMiddleware.selector); - _requestSlash(alice, network, resolver, operator, toSlash); - } +// vm.expectRevert(IVault.NotNetworkMiddleware.selector); +// _requestSlash(alice, network, resolver, operator, toSlash); +// } - function test_RequestSlashRevertInsufficientSlash( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); +// function test_RequestSlashRevertInsufficientSlash( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - uint256 shares = _deposit(alice, amount1); +// uint256 shares = _deposit(alice, amount1); - shares += _deposit(bob, amount2); +// shares += _deposit(bob, amount2); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - address operator = bob; - _registerOperator(operator); +// address operator = bob; +// _registerOperator(operator); - address resolver = address(1); - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); +// address resolver = address(1); +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); - _optInOperatorVault(operator); +// _optInOperatorVault(operator); - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); - _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); - _optInOperatorNetwork(operator, network); +// _optInOperatorNetwork(operator, network); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - vm.expectRevert(IVault.InsufficientSlash.selector); - _requestSlash(bob, network, resolver, operator, 0); - } +// vm.expectRevert(IVault.InsufficientSlash.selector); +// _requestSlash(bob, network, resolver, operator, 0); +// } - function test_RequestSlashRevertNetworkNotOptedIn( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); +// function test_RequestSlashRevertNetworkNotOptedIn( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - uint256 shares = _deposit(alice, amount1); +// uint256 shares = _deposit(alice, amount1); - shares += _deposit(bob, amount2); +// shares += _deposit(bob, amount2); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - address operator = bob; - _registerOperator(operator); +// address operator = bob; +// _registerOperator(operator); - address resolver = address(1); - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); +// address resolver = address(1); +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); - _optInOperatorVault(operator); +// _optInOperatorVault(operator); - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); - _optOutNetworkVault(network, resolver); +// _optOutNetworkVault(network, resolver); - _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); - _optInOperatorNetwork(operator, network); +// _optInOperatorNetwork(operator, network); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - vm.expectRevert(IVault.NetworkNotOptedInVault.selector); - _requestSlash(bob, network, resolver, operator, toSlash); - } +// vm.expectRevert(IVault.NetworkNotOptedInVault.selector); +// _requestSlash(bob, network, resolver, operator, toSlash); +// } - function test_RequestSlashRevertOperatorNotOptedInNetwork( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); +// function test_RequestSlashRevertOperatorNotOptedInNetwork( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - uint256 shares = _deposit(alice, amount1); +// uint256 shares = _deposit(alice, amount1); - shares += _deposit(bob, amount2); +// shares += _deposit(bob, amount2); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - address operator = bob; - _registerOperator(operator); +// address operator = bob; +// _registerOperator(operator); - address resolver = address(1); - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); +// address resolver = address(1); +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); - _optInOperatorVault(operator); +// _optInOperatorVault(operator); - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); - _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); - _optInOperatorNetwork(operator, network); +// _optInOperatorNetwork(operator, network); - _optOutOperatorNetwork(operator, network); +// _optOutOperatorNetwork(operator, network); - blockTimestamp = vault.currentEpochStart() + 2 * vault.epochDuration(); - vm.warp(blockTimestamp); +// blockTimestamp = vault.currentEpochStart() + 2 * vault.epochDuration(); +// vm.warp(blockTimestamp); - vm.expectRevert(IVault.OperatorNotOptedInNetwork.selector); - _requestSlash(bob, network, resolver, operator, toSlash); - } +// vm.expectRevert(IVault.OperatorNotOptedInNetwork.selector); +// _requestSlash(bob, network, resolver, operator, toSlash); +// } - function test_RequestSlashRevertOperatorNotOptedInVault( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); +// function test_RequestSlashRevertOperatorNotOptedInVault( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - uint256 shares = _deposit(alice, amount1); +// uint256 shares = _deposit(alice, amount1); - shares += _deposit(bob, amount2); +// shares += _deposit(bob, amount2); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - address operator = bob; - _registerOperator(operator); +// address operator = bob; +// _registerOperator(operator); - address resolver = address(1); - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); +// address resolver = address(1); +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); - _optInOperatorVault(operator); +// _optInOperatorVault(operator); - _optOutOperatorVault(operator); +// _optOutOperatorVault(operator); - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); - _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); - _optInOperatorNetwork(operator, network); +// _optInOperatorNetwork(operator, network); - blockTimestamp = vault.currentEpochStart() + 2 * vault.epochDuration(); - vm.warp(blockTimestamp); +// blockTimestamp = vault.currentEpochStart() + 2 * vault.epochDuration(); +// vm.warp(blockTimestamp); - vm.expectRevert(IVault.OperatorNotOptedInVault.selector); - _requestSlash(bob, network, resolver, operator, toSlash); - } +// vm.expectRevert(IVault.OperatorNotOptedInVault.selector); +// _requestSlash(bob, network, resolver, operator, toSlash); +// } - function test_ExecuteSlash( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); +// function test_ExecuteSlash( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); - // uint48 epochDuration = 3; - // uint48 executeDuration = 1; - // uint48 vetoDuration = 1; - vault = _getVault(3, 1, 1); +// // uint48 epochDuration = 3; +// // uint48 executeDuration = 1; +// // uint48 vetoDuration = 1; +// vault = _getVault(3, 1, 1); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - uint256 shares1 = _deposit(alice, amount1); +// uint256 shares1 = _deposit(alice, amount1); - uint256 shares2 = _deposit(bob, amount2); +// uint256 shares2 = _deposit(bob, amount2); - // address network = bob; - _registerNetwork(bob, bob); +// // address network = bob; +// _registerNetwork(bob, bob); - // address operator = bob; - _registerOperator(bob); +// // address operator = bob; +// _registerOperator(bob); - // address resolver = alice; - _setMaxNetworkResolverLimit(bob, alice, type(uint256).max); - _optInNetworkVault(bob, alice); +// // address resolver = alice; +// _setMaxNetworkResolverLimit(bob, alice, type(uint256).max); +// _optInNetworkVault(bob, alice); - _optInOperatorVault(bob); +// _optInOperatorVault(bob); - _setNetworkResolverLimit(alice, bob, alice, networkResolverLimit); +// _setNetworkResolverLimit(alice, bob, alice, networkResolverLimit); - _setOperatorNetworkLimit(alice, bob, bob, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, bob, bob, operatorNetworkLimit); - _optInOperatorNetwork(bob, bob); +// _optInOperatorNetwork(bob, bob); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - uint256 slashIndex = _requestSlash(bob, bob, alice, bob, toSlash); +// uint256 slashIndex = _requestSlash(bob, bob, alice, bob, toSlash); - (,,, uint256 amount_,,,) = vault.slashRequests(slashIndex); +// (,,, uint256 amount_,,,) = vault.slashRequests(slashIndex); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - uint256 activeSupply_ = vault.activeSupply(); +// uint256 activeSupply_ = vault.activeSupply(); - assertEq(_executeSlash(address(1), slashIndex), amount_); - assertEq(activeSupply_ - amount_.mulDiv(activeSupply_, amount1 + amount2), vault.activeSupply()); +// assertEq(_executeSlash(address(1), slashIndex), amount_); +// assertEq(activeSupply_ - amount_.mulDiv(activeSupply_, amount1 + amount2), vault.activeSupply()); - (,,,,,, bool completed__) = vault.slashRequests(slashIndex); +// (,,,,,, bool completed__) = vault.slashRequests(slashIndex); - assertEq(completed__, true); +// assertEq(completed__, true); - assertEq(vault.totalSupply(), amount1 + amount2 - amount_); - assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), shares1 + shares2); - assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares1 + shares2); - assertEq(vault.activeShares(), shares1 + shares2); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), amount1 + amount2); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), amount1 + amount2 - amount_); - assertEq(vault.activeSupply(), amount1 + amount2 - amount_); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), shares1); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares1); - assertEq(vault.activeSharesOf(alice), shares1); - assertEq(vault.activeSharesOfCheckpointsLength(alice), 1); - (uint48 timestampCheckpoint, uint256 valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 0); - assertEq(timestampCheckpoint, blockTimestamp - 2); - assertEq(valueCheckpoint, shares1); - assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), amount1); - assertEq( - vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), - shares1.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3) - ); - assertEq(vault.activeBalanceOf(alice), shares1.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3)); - assertEq(vault.activeSharesOfAt(bob, uint48(blockTimestamp - 1)), shares2); - assertEq(vault.activeSharesOfAt(bob, uint48(blockTimestamp)), shares2); - assertEq(vault.activeSharesOf(bob), shares2); - assertEq(vault.activeSharesOfCheckpointsLength(bob), 1); - (timestampCheckpoint, valueCheckpoint) = vault.activeSharesOfCheckpoint(bob, 0); - assertEq(timestampCheckpoint, blockTimestamp - 2); - assertEq(valueCheckpoint, shares2); - assertEq(vault.activeBalanceOfAt(bob, uint48(blockTimestamp - 1)), amount2); - assertEq( - vault.activeBalanceOfAt(bob, uint48(blockTimestamp)), - shares2.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3) - ); - assertEq(vault.activeBalanceOf(bob), shares2.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3)); - } - - function test_ExecuteSlashNoResolver( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); - - // uint48 epochDuration = 3; - // uint48 executeDuration = 1; - // uint48 vetoDuration = 1; - vault = _getVault(3, 1, 1); - - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - - uint256 shares1 = _deposit(alice, amount1); - - uint256 shares2 = _deposit(bob, amount2); - - // address network = bob; - _registerNetwork(bob, bob); - - // address operator = bob; - _registerOperator(bob); - - // address resolver = address(0); - _setMaxNetworkResolverLimit(bob, address(0), type(uint256).max); - _optInNetworkVault(bob, address(0)); - - _optInOperatorVault(bob); - - _setNetworkResolverLimit(alice, bob, address(0), networkResolverLimit); - - _setOperatorNetworkLimit(alice, bob, bob, operatorNetworkLimit); - - _optInOperatorNetwork(bob, bob); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - uint256 slashIndex = _requestSlash(bob, bob, address(0), bob, toSlash); - - (,,, uint256 amount_,,,) = vault.slashRequests(slashIndex); - - uint256 activeSupply_ = vault.activeSupply(); - - assertEq(_executeSlash(address(1), slashIndex), amount_); - assertEq(activeSupply_ - amount_.mulDiv(activeSupply_, amount1 + amount2), vault.activeSupply()); - - (,,,,,, bool completed__) = vault.slashRequests(slashIndex); - - assertEq(completed__, true); - - assertEq(vault.totalSupply(), amount1 + amount2 - amount_); - assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), shares1 + shares2); - assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares1 + shares2); - assertEq(vault.activeShares(), shares1 + shares2); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), amount1 + amount2); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), amount1 + amount2 - amount_); - assertEq(vault.activeSupply(), amount1 + amount2 - amount_); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), shares1); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares1); - assertEq(vault.activeSharesOf(alice), shares1); - assertEq(vault.activeSharesOfCheckpointsLength(alice), 1); - (uint48 timestampCheckpoint, uint256 valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 0); - assertEq(timestampCheckpoint, blockTimestamp - 1); - assertEq(valueCheckpoint, shares1); - assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), amount1); - assertEq( - vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), - shares1.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3) - ); - assertEq(vault.activeBalanceOf(alice), shares1.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3)); - assertEq(vault.activeSharesOfAt(bob, uint48(blockTimestamp - 1)), shares2); - assertEq(vault.activeSharesOfAt(bob, uint48(blockTimestamp)), shares2); - assertEq(vault.activeSharesOf(bob), shares2); - assertEq(vault.activeSharesOfCheckpointsLength(bob), 1); - (timestampCheckpoint, valueCheckpoint) = vault.activeSharesOfCheckpoint(bob, 0); - assertEq(timestampCheckpoint, blockTimestamp - 1); - assertEq(valueCheckpoint, shares2); - assertEq(vault.activeBalanceOfAt(bob, uint48(blockTimestamp - 1)), amount2); - assertEq( - vault.activeBalanceOfAt(bob, uint48(blockTimestamp)), - shares2.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3) - ); - assertEq(vault.activeBalanceOf(bob), shares2.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3)); - } - - function test_ExecuteSlashEdgeCase(uint256 networkResolverLimit, uint256 operatorNetworkLimit) public { - uint256 toDeposit = 2; - uint256 toWithdraw = 1; - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - uint256 toSlash = 1; +// assertEq(vault.totalSupply(), amount1 + amount2 - amount_); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), shares1 + shares2); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares1 + shares2); +// assertEq(vault.activeShares(), shares1 + shares2); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), amount1 + amount2); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), amount1 + amount2 - amount_); +// assertEq(vault.activeSupply(), amount1 + amount2 - amount_); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), shares1); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares1); +// assertEq(vault.activeSharesOf(alice), shares1); +// assertEq(vault.activeSharesOfCheckpointsLength(alice), 1); +// (uint48 timestampCheckpoint, uint256 valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 0); +// assertEq(timestampCheckpoint, blockTimestamp - 2); +// assertEq(valueCheckpoint, shares1); +// assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), amount1); +// assertEq( +// vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), +// shares1.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3) +// ); +// assertEq(vault.activeBalanceOf(alice), shares1.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3)); +// assertEq(vault.activeSharesOfAt(bob, uint48(blockTimestamp - 1)), shares2); +// assertEq(vault.activeSharesOfAt(bob, uint48(blockTimestamp)), shares2); +// assertEq(vault.activeSharesOf(bob), shares2); +// assertEq(vault.activeSharesOfCheckpointsLength(bob), 1); +// (timestampCheckpoint, valueCheckpoint) = vault.activeSharesOfCheckpoint(bob, 0); +// assertEq(timestampCheckpoint, blockTimestamp - 2); +// assertEq(valueCheckpoint, shares2); +// assertEq(vault.activeBalanceOfAt(bob, uint48(blockTimestamp - 1)), amount2); +// assertEq( +// vault.activeBalanceOfAt(bob, uint48(blockTimestamp)), +// shares2.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3) +// ); +// assertEq(vault.activeBalanceOf(bob), shares2.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3)); +// } + +// function test_ExecuteSlashNoResolver( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); + +// // uint48 epochDuration = 3; +// // uint48 executeDuration = 1; +// // uint48 vetoDuration = 1; +// vault = _getVault(3, 1, 1); + +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; + +// uint256 shares1 = _deposit(alice, amount1); + +// uint256 shares2 = _deposit(bob, amount2); + +// // address network = bob; +// _registerNetwork(bob, bob); + +// // address operator = bob; +// _registerOperator(bob); + +// // address resolver = address(0); +// _setMaxNetworkResolverLimit(bob, address(0), type(uint256).max); +// _optInNetworkVault(bob, address(0)); + +// _optInOperatorVault(bob); + +// _setNetworkResolverLimit(alice, bob, address(0), networkResolverLimit); + +// _setOperatorNetworkLimit(alice, bob, bob, operatorNetworkLimit); + +// _optInOperatorNetwork(bob, bob); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// uint256 slashIndex = _requestSlash(bob, bob, address(0), bob, toSlash); + +// (,,, uint256 amount_,,,) = vault.slashRequests(slashIndex); + +// uint256 activeSupply_ = vault.activeSupply(); + +// assertEq(_executeSlash(address(1), slashIndex), amount_); +// assertEq(activeSupply_ - amount_.mulDiv(activeSupply_, amount1 + amount2), vault.activeSupply()); + +// (,,,,,, bool completed__) = vault.slashRequests(slashIndex); + +// assertEq(completed__, true); + +// assertEq(vault.totalSupply(), amount1 + amount2 - amount_); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), shares1 + shares2); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares1 + shares2); +// assertEq(vault.activeShares(), shares1 + shares2); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), amount1 + amount2); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), amount1 + amount2 - amount_); +// assertEq(vault.activeSupply(), amount1 + amount2 - amount_); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), shares1); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares1); +// assertEq(vault.activeSharesOf(alice), shares1); +// assertEq(vault.activeSharesOfCheckpointsLength(alice), 1); +// (uint48 timestampCheckpoint, uint256 valueCheckpoint) = vault.activeSharesOfCheckpoint(alice, 0); +// assertEq(timestampCheckpoint, blockTimestamp - 1); +// assertEq(valueCheckpoint, shares1); +// assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), amount1); +// assertEq( +// vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), +// shares1.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3) +// ); +// assertEq(vault.activeBalanceOf(alice), shares1.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3)); +// assertEq(vault.activeSharesOfAt(bob, uint48(blockTimestamp - 1)), shares2); +// assertEq(vault.activeSharesOfAt(bob, uint48(blockTimestamp)), shares2); +// assertEq(vault.activeSharesOf(bob), shares2); +// assertEq(vault.activeSharesOfCheckpointsLength(bob), 1); +// (timestampCheckpoint, valueCheckpoint) = vault.activeSharesOfCheckpoint(bob, 0); +// assertEq(timestampCheckpoint, blockTimestamp - 1); +// assertEq(valueCheckpoint, shares2); +// assertEq(vault.activeBalanceOfAt(bob, uint48(blockTimestamp - 1)), amount2); +// assertEq( +// vault.activeBalanceOfAt(bob, uint48(blockTimestamp)), +// shares2.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3) +// ); +// assertEq(vault.activeBalanceOf(bob), shares2.mulDiv(vault.activeSupply() + 1, vault.activeShares() + 10 ** 3)); +// } + +// function test_ExecuteSlashEdgeCase(uint256 networkResolverLimit, uint256 operatorNetworkLimit) public { +// uint256 toDeposit = 2; +// uint256 toWithdraw = 1; +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// uint256 toSlash = 1; - // uint48 epochDuration = 3; - // uint48 executeDuration = 1; - // uint48 vetoDuration = 1; - vault = _getVault(3, 1, 1); +// // uint48 epochDuration = 3; +// // uint48 executeDuration = 1; +// // uint48 vetoDuration = 1; +// vault = _getVault(3, 1, 1); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - uint256 shares = _deposit(alice, toDeposit); - (uint256 burnedShares,) = _withdraw(alice, toWithdraw); +// uint256 shares = _deposit(alice, toDeposit); +// (uint256 burnedShares,) = _withdraw(alice, toWithdraw); - // address network = bob; - _registerNetwork(bob, bob); +// // address network = bob; +// _registerNetwork(bob, bob); - // address operator = bob; - _registerOperator(bob); +// // address operator = bob; +// _registerOperator(bob); - // address resolver = alice; - _setMaxNetworkResolverLimit(bob, alice, type(uint256).max); - _optInNetworkVault(bob, alice); +// // address resolver = alice; +// _setMaxNetworkResolverLimit(bob, alice, type(uint256).max); +// _optInNetworkVault(bob, alice); - _optInOperatorVault(bob); +// _optInOperatorVault(bob); - _setNetworkResolverLimit(alice, bob, alice, networkResolverLimit); +// _setNetworkResolverLimit(alice, bob, alice, networkResolverLimit); - _setOperatorNetworkLimit(alice, bob, bob, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, bob, bob, operatorNetworkLimit); - _optInOperatorNetwork(bob, bob); - - blockTimestamp = blockTimestamp + 3; - vm.warp(blockTimestamp); - - uint256 slashIndex = _requestSlash(bob, bob, alice, bob, toSlash); +// _optInOperatorNetwork(bob, bob); + +// blockTimestamp = blockTimestamp + 3; +// vm.warp(blockTimestamp); + +// uint256 slashIndex = _requestSlash(bob, bob, alice, bob, toSlash); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - assertEq(_executeSlash(address(1), slashIndex), 0); - assertEq(1, vault.activeSupply()); +// assertEq(_executeSlash(address(1), slashIndex), 0); +// assertEq(1, vault.activeSupply()); - (,,,,,, bool completed__) = vault.slashRequests(slashIndex); - - assertEq(completed__, true); - - assertEq(vault.totalSupply(), 2); - assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), shares - burnedShares); - assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares - burnedShares); - assertEq(vault.activeShares(), shares - burnedShares); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), 1); - assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), 1); - assertEq(vault.activeSupply(), 1); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), shares - burnedShares); - assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares - burnedShares); - assertEq(vault.activeSharesOf(alice), shares - burnedShares); - assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), 1); - assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), 1); - assertEq(vault.activeBalanceOf(alice), 1); - } - - function test_ExecuteSlashRevertSlashRequestNotExist( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); +// (,,,,,, bool completed__) = vault.slashRequests(slashIndex); + +// assertEq(completed__, true); + +// assertEq(vault.totalSupply(), 2); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp - 1)), shares - burnedShares); +// assertEq(vault.activeSharesAt(uint48(blockTimestamp)), shares - burnedShares); +// assertEq(vault.activeShares(), shares - burnedShares); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp - 1)), 1); +// assertEq(vault.activeSupplyAt(uint48(blockTimestamp)), 1); +// assertEq(vault.activeSupply(), 1); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp - 1)), shares - burnedShares); +// assertEq(vault.activeSharesOfAt(alice, uint48(blockTimestamp)), shares - burnedShares); +// assertEq(vault.activeSharesOf(alice), shares - burnedShares); +// assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp - 1)), 1); +// assertEq(vault.activeBalanceOfAt(alice, uint48(blockTimestamp)), 1); +// assertEq(vault.activeBalanceOf(alice), 1); +// } + +// function test_ExecuteSlashRevertSlashRequestNotExist( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - _deposit(alice, amount1); +// _deposit(alice, amount1); - _deposit(bob, amount2); +// _deposit(bob, amount2); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - address operator = bob; - _registerOperator(operator); +// address operator = bob; +// _registerOperator(operator); - address resolver = alice; - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); +// address resolver = alice; +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); - _optInOperatorVault(operator); +// _optInOperatorVault(operator); - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); - _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); - _optInOperatorNetwork(operator, network); +// _optInOperatorNetwork(operator, network); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); +// uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - vm.expectRevert(IVault.SlashRequestNotExist.selector); - _executeSlash(address(1), slashIndex + 1); - } +// vm.expectRevert(IVault.SlashRequestNotExist.selector); +// _executeSlash(address(1), slashIndex + 1); +// } - function test_ExecuteSlashRevertVetoPeriodNotEnded( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); +// function test_ExecuteSlashRevertVetoPeriodNotEnded( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - _deposit(alice, amount1); +// _deposit(alice, amount1); - _deposit(bob, amount2); +// _deposit(bob, amount2); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - address operator = bob; - _registerOperator(operator); +// address operator = bob; +// _registerOperator(operator); - address resolver = alice; - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); +// address resolver = alice; +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); - _optInOperatorVault(operator); +// _optInOperatorVault(operator); - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); - _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); - _optInOperatorNetwork(operator, network); +// _optInOperatorNetwork(operator, network); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); +// uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); - vm.expectRevert(IVault.VetoPeriodNotEnded.selector); - _executeSlash(address(1), slashIndex); - } +// vm.expectRevert(IVault.VetoPeriodNotEnded.selector); +// _executeSlash(address(1), slashIndex); +// } - function test_ExecuteSlashRevertSlashPeriodEnded( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); +// function test_ExecuteSlashRevertSlashPeriodEnded( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - _deposit(alice, amount1); +// _deposit(alice, amount1); - _deposit(bob, amount2); +// _deposit(bob, amount2); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - address operator = bob; - _registerOperator(operator); +// address operator = bob; +// _registerOperator(operator); - address resolver = alice; - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); +// address resolver = alice; +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); - _optInOperatorVault(operator); +// _optInOperatorVault(operator); - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); - _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); - _optInOperatorNetwork(operator, network); +// _optInOperatorNetwork(operator, network); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); +// uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); - blockTimestamp = blockTimestamp + 2; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 2; +// vm.warp(blockTimestamp); - vm.expectRevert(IVault.SlashPeriodEnded.selector); - _executeSlash(address(1), slashIndex); - } +// vm.expectRevert(IVault.SlashPeriodEnded.selector); +// _executeSlash(address(1), slashIndex); +// } - function test_ExecuteSlashRevertSlashCompleted( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); +// function test_ExecuteSlashRevertSlashCompleted( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - _deposit(alice, amount1); +// _deposit(alice, amount1); - _deposit(bob, amount2); +// _deposit(bob, amount2); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - address operator = bob; - _registerOperator(operator); +// address operator = bob; +// _registerOperator(operator); - address resolver = alice; - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); +// address resolver = alice; +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); - _optInOperatorVault(operator); +// _optInOperatorVault(operator); - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); - _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); - _optInOperatorNetwork(operator, network); +// _optInOperatorNetwork(operator, network); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); +// uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); - _vetoSlash(resolver, slashIndex); +// _vetoSlash(resolver, slashIndex); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - vm.expectRevert(IVault.SlashCompleted.selector); - _executeSlash(address(1), slashIndex); - } +// vm.expectRevert(IVault.SlashCompleted.selector); +// _executeSlash(address(1), slashIndex); +// } - function test_VetoSlash( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); +// function test_VetoSlash( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - uint256 shares = _deposit(alice, amount1); +// uint256 shares = _deposit(alice, amount1); - shares += _deposit(bob, amount2); +// shares += _deposit(bob, amount2); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - address operator = bob; - _registerOperator(operator); +// address operator = bob; +// _registerOperator(operator); - address resolver = alice; - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); +// address resolver = alice; +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); - _optInOperatorVault(operator); +// _optInOperatorVault(operator); - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); - _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); - _optInOperatorNetwork(operator, network); +// _optInOperatorNetwork(operator, network); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); +// uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); - ( - address network_, - address resolver_, - address operator_, - uint256 amount_, - uint48 vetoDeadline_, - uint48 executeDeadline_, - ) = vault.slashRequests(slashIndex); +// ( +// address network_, +// address resolver_, +// address operator_, +// uint256 amount_, +// uint48 vetoDeadline_, +// uint48 executeDeadline_, +// ) = vault.slashRequests(slashIndex); - _vetoSlash(resolver, slashIndex); +// _vetoSlash(resolver, slashIndex); - ( - address network__, - address resolver__, - address operator__, - uint256 amount__, - uint48 vetoDeadline__, - uint48 executeDeadline__, - bool completed__ - ) = vault.slashRequests(slashIndex); +// ( +// address network__, +// address resolver__, +// address operator__, +// uint256 amount__, +// uint48 vetoDeadline__, +// uint48 executeDeadline__, +// bool completed__ +// ) = vault.slashRequests(slashIndex); - assertEq(network__, network_); - assertEq(resolver__, resolver_); - assertEq(operator__, operator_); - assertEq(amount__, amount_); - assertEq(vetoDeadline__, vetoDeadline_); - assertEq(executeDeadline__, executeDeadline_); - assertEq(completed__, true); - } +// assertEq(network__, network_); +// assertEq(resolver__, resolver_); +// assertEq(operator__, operator_); +// assertEq(amount__, amount_); +// assertEq(vetoDeadline__, vetoDeadline_); +// assertEq(executeDeadline__, executeDeadline_); +// assertEq(completed__, true); +// } - function test_VetoSlashRevertSlashRequestNotExist( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); +// function test_VetoSlashRevertSlashRequestNotExist( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - uint256 shares = _deposit(alice, amount1); +// uint256 shares = _deposit(alice, amount1); - shares += _deposit(bob, amount2); +// shares += _deposit(bob, amount2); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - address operator = bob; - _registerOperator(operator); +// address operator = bob; +// _registerOperator(operator); - address resolver = alice; - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); +// address resolver = alice; +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); - _optInOperatorVault(operator); +// _optInOperatorVault(operator); - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); - _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); - _optInOperatorNetwork(operator, network); +// _optInOperatorNetwork(operator, network); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); +// uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); - vm.expectRevert(IVault.SlashRequestNotExist.selector); - _vetoSlash(resolver, slashIndex + 1); - } +// vm.expectRevert(IVault.SlashRequestNotExist.selector); +// _vetoSlash(resolver, slashIndex + 1); +// } - function test_VetoSlashRevertNotResolver( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); +// function test_VetoSlashRevertNotResolver( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - uint256 shares = _deposit(alice, amount1); +// uint256 shares = _deposit(alice, amount1); - shares += _deposit(bob, amount2); +// shares += _deposit(bob, amount2); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - address operator = bob; - _registerOperator(operator); +// address operator = bob; +// _registerOperator(operator); - address resolver = alice; - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); +// address resolver = alice; +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); - _optInOperatorVault(operator); +// _optInOperatorVault(operator); - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); - _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); - _optInOperatorNetwork(operator, network); +// _optInOperatorNetwork(operator, network); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); +// uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); - vm.expectRevert(IVault.NotResolver.selector); - _vetoSlash(address(1), slashIndex); - } +// vm.expectRevert(IVault.NotResolver.selector); +// _vetoSlash(address(1), slashIndex); +// } - function test_VetoSlashRevertVetoPeriodEnded( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); +// function test_VetoSlashRevertVetoPeriodEnded( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - uint256 shares = _deposit(alice, amount1); +// uint256 shares = _deposit(alice, amount1); - shares += _deposit(bob, amount2); +// shares += _deposit(bob, amount2); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - address operator = bob; - _registerOperator(operator); +// address operator = bob; +// _registerOperator(operator); - address resolver = alice; - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); +// address resolver = alice; +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); - _optInOperatorVault(operator); +// _optInOperatorVault(operator); - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); - _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); +// _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); - _optInOperatorNetwork(operator, network); +// _optInOperatorNetwork(operator, network); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); +// uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); - vm.expectRevert(IVault.VetoPeriodEnded.selector); - _vetoSlash(resolver, slashIndex); - } +// vm.expectRevert(IVault.VetoPeriodEnded.selector); +// _vetoSlash(resolver, slashIndex); +// } - function test_VetoSlashRevertSlashCompleted( - uint256 amount1, - uint256 amount2, - uint256 networkResolverLimit, - uint256 operatorNetworkLimit, - uint256 toSlash - ) public { - amount1 = bound(amount1, 1, 100 * 10 ** 18); - amount2 = bound(amount2, 1, 100 * 10 ** 18); - networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); - operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); - toSlash = bound(toSlash, 1, type(uint256).max); +// function test_VetoSlashRevertSlashCompleted( +// uint256 amount1, +// uint256 amount2, +// uint256 networkResolverLimit, +// uint256 operatorNetworkLimit, +// uint256 toSlash +// ) public { +// amount1 = bound(amount1, 1, 100 * 10 ** 18); +// amount2 = bound(amount2, 1, 100 * 10 ** 18); +// networkResolverLimit = bound(networkResolverLimit, 1, type(uint256).max); +// operatorNetworkLimit = bound(operatorNetworkLimit, 1, type(uint256).max); +// toSlash = bound(toSlash, 1, type(uint256).max); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - - uint256 shares = _deposit(alice, amount1); - - shares += _deposit(bob, amount2); - - address network = bob; - _registerNetwork(network, bob); - - address operator = bob; - _registerOperator(operator); - - address resolver = alice; - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); - - _optInOperatorVault(operator); - - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); - - _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); - - _optInOperatorNetwork(operator, network); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); - - _vetoSlash(resolver, slashIndex); - - vm.expectRevert(IVault.SlashCompleted.selector); - _vetoSlash(resolver, slashIndex); - } - - function test_CreateRevertInvalidEpochDuration() public { - uint48 epochDuration = 0; - uint48 executeDuration = 0; - uint48 vetoDuration = 0; - - uint64 lastVersion = vaultFactory.lastVersion(); - vm.expectRevert(IVault.InvalidEpochDuration.selector); - vault = IVault( - vaultFactory.create( - lastVersion, - alice, - abi.encode( - IVault.InitParams({ - collateral: address(collateral), - epochDuration: epochDuration, - vetoDuration: vetoDuration, - executeDuration: executeDuration, - rewardsDistributor: address(0), - adminFee: 0, - depositWhitelist: false - }) - ) - ) - ); - } - - function test_CreateRevertInvalidSlashDuration( - uint48 epochDuration, - uint48 vetoDuration, - uint48 executeDuration - ) public { - epochDuration = uint48(bound(epochDuration, 1, type(uint48).max)); - vetoDuration = uint48(bound(vetoDuration, 0, type(uint48).max / 2)); - executeDuration = uint48(bound(executeDuration, 0, type(uint48).max / 2)); - vm.assume(vetoDuration + executeDuration > epochDuration); - - uint64 lastVersion = vaultFactory.lastVersion(); - vm.expectRevert(IVault.InvalidSlashDuration.selector); - vault = IVault( - vaultFactory.create( - lastVersion, - alice, - abi.encode( - IVault.InitParams({ - collateral: address(collateral), - epochDuration: epochDuration, - vetoDuration: vetoDuration, - executeDuration: executeDuration, - rewardsDistributor: address(0), - adminFee: 0, - depositWhitelist: false - }) - ) - ) - ); - } - - function test_CreateRevertInvalidAdminFee(uint256 adminFee) public { - vm.assume(adminFee > 10_000); - - uint48 epochDuration = 1; - uint48 executeDuration = 0; - uint48 vetoDuration = 0; - - uint64 lastVersion = vaultFactory.lastVersion(); - vm.expectRevert(IVault.InvalidAdminFee.selector); - vault = IVault( - vaultFactory.create( - lastVersion, - alice, - abi.encode( - IVault.InitParams({ - collateral: address(collateral), - epochDuration: epochDuration, - vetoDuration: vetoDuration, - executeDuration: executeDuration, - rewardsDistributor: address(0), - adminFee: adminFee, - depositWhitelist: false - }) - ) - ) - ); - } - - function test_SetNetworkResolverLimit( - uint48 epochDuration, - uint256 amount1, - uint256 amount2, - uint256 amount3 - ) public { - epochDuration = uint48(bound(uint256(epochDuration), 1, 100 days)); - vm.assume(amount3 < amount2); - - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - - address network = bob; - _registerNetwork(network, bob); - - address resolver = address(1); - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); - - _setNetworkResolverLimit(alice, network, resolver, amount1); - - assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount1); - assertEq(vault.networkResolverLimit(network, resolver), amount1); - (uint256 nextNetworkResolverLimitAmount, uint256 nextNetworkResolverLimitTimestamp) = - vault.nextNetworkResolverLimit(network, resolver); - assertEq(nextNetworkResolverLimitAmount, 0); - assertEq(nextNetworkResolverLimitTimestamp, 0); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount1); - assertEq(vault.networkResolverLimit(network, resolver), amount1); - (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = - vault.nextNetworkResolverLimit(network, resolver); - assertEq(nextNetworkResolverLimitAmount, 0); - assertEq(nextNetworkResolverLimitTimestamp, 0); - - _setNetworkResolverLimit(alice, network, resolver, amount2); - - if (amount1 > amount2) { - assertEq( - vault.networkResolverLimitIn( - network, - resolver, - uint48(vault.currentEpochStart() + 2 * vault.epochDuration() - 1 - blockTimestamp) - ), - amount1 - ); - assertEq(vault.networkResolverLimit(network, resolver), amount1); - (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = - vault.nextNetworkResolverLimit(network, resolver); - assertEq(nextNetworkResolverLimitAmount, amount2); - assertEq(nextNetworkResolverLimitTimestamp, vault.currentEpochStart() + 2 * vault.epochDuration()); - - blockTimestamp = vault.currentEpochStart() + 2 * vault.epochDuration() - 1; - vm.warp(blockTimestamp); - - assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount2); - assertEq(vault.networkResolverLimit(network, resolver), amount1); - (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = - vault.nextNetworkResolverLimit(network, resolver); - assertEq(nextNetworkResolverLimitAmount, amount2); - assertEq(nextNetworkResolverLimitTimestamp, vault.currentEpochStart() + vault.epochDuration()); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount2); - assertEq(vault.networkResolverLimit(network, resolver), amount2); - (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = - vault.nextNetworkResolverLimit(network, resolver); - assertEq(nextNetworkResolverLimitAmount, amount2); - assertEq(nextNetworkResolverLimitTimestamp, vault.currentEpochStart()); - - _setNetworkResolverLimit(alice, network, resolver, amount2); - - assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount2); - assertEq(vault.networkResolverLimit(network, resolver), amount2); - (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = - vault.nextNetworkResolverLimit(network, resolver); - assertEq(nextNetworkResolverLimitAmount, 0); - assertEq(nextNetworkResolverLimitTimestamp, 0); - } else { - assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount2); - assertEq(vault.networkResolverLimit(network, resolver), amount2); - (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = - vault.nextNetworkResolverLimit(network, resolver); - assertEq(nextNetworkResolverLimitAmount, 0); - assertEq(nextNetworkResolverLimitTimestamp, 0); - } - - _setNetworkResolverLimit(alice, network, resolver, amount3); - - assertEq( - vault.networkResolverLimitIn( - network, resolver, uint48(vault.currentEpochStart() + 2 * vault.epochDuration() - blockTimestamp) - ), - amount3 - ); - assertEq(vault.networkResolverLimit(network, resolver), amount2); - (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = - vault.nextNetworkResolverLimit(network, resolver); - assertEq(nextNetworkResolverLimitAmount, amount3); - assertEq(nextNetworkResolverLimitTimestamp, vault.currentEpochStart() + 2 * vault.epochDuration()); - - _setNetworkResolverLimit(alice, network, resolver, amount2); - - assertEq( - vault.networkResolverLimitIn( - network, resolver, uint48(vault.currentEpochStart() + 2 * vault.epochDuration() - blockTimestamp) - ), - amount2 - ); - assertEq(vault.networkResolverLimit(network, resolver), amount2); - (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = - vault.nextNetworkResolverLimit(network, resolver); - assertEq(nextNetworkResolverLimitAmount, 0); - assertEq(nextNetworkResolverLimitTimestamp, 0); - - _optOutNetworkVault(network, resolver); - - assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount2); - assertEq(vault.networkResolverLimit(network, resolver), amount2); - (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = - vault.nextNetworkResolverLimit(network, resolver); - assertEq(nextNetworkResolverLimitAmount, 0); - assertEq(nextNetworkResolverLimitTimestamp, 0); - - blockTimestamp = vault.currentEpochStart() + 2 * vault.epochDuration() - 1; - vm.warp(blockTimestamp); - - assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount2); - assertEq(vault.networkResolverLimit(network, resolver), amount2); - (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = - vault.nextNetworkResolverLimit(network, resolver); - assertEq(nextNetworkResolverLimitAmount, 0); - assertEq(nextNetworkResolverLimitTimestamp, 0); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount2); - assertEq(vault.networkResolverLimit(network, resolver), amount2); - (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = - vault.nextNetworkResolverLimit(network, resolver); - assertEq(nextNetworkResolverLimitAmount, 0); - assertEq(nextNetworkResolverLimitTimestamp, 0); - } - - function test_SetNetworkResolverLimitRevertOnlyRole(uint48 epochDuration, uint256 amount1) public { - epochDuration = uint48(bound(uint256(epochDuration), 1, 100 days)); - - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - address network = bob; - _registerNetwork(network, bob); - - address resolver = address(1); - _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); - _optInNetworkVault(network, resolver); - - vm.expectRevert(); - _setNetworkResolverLimit(bob, network, resolver, amount1); - } - - function test_SetNetworkResolverLimitRevertExceedsMaxNetworkResolverLimit( - uint48 epochDuration, - uint256 amount1, - uint256 maxNetworkResolverLimit - ) public { - epochDuration = uint48(bound(uint256(epochDuration), 1, 100 days)); - maxNetworkResolverLimit = bound(maxNetworkResolverLimit, 1, type(uint256).max); - vm.assume(amount1 > maxNetworkResolverLimit); - - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - address network = bob; - _registerNetwork(network, bob); - - address resolver = address(1); - _setMaxNetworkResolverLimit(network, resolver, maxNetworkResolverLimit); - _optInNetworkVault(network, resolver); - - vm.expectRevert(IVault.ExceedsMaxNetworkResolverLimit.selector); - _setNetworkResolverLimit(alice, network, resolver, amount1); - } - - function test_SetOperatorNetworkLimit( - uint48 epochDuration, - uint256 amount1, - uint256 amount2, - uint256 amount3 - ) public { - epochDuration = uint48(bound(uint256(epochDuration), 1, 100 days)); - vm.assume(amount3 < amount2); - - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - - address operator = bob; - _registerOperator(operator); - - address network = address(1); - _optInOperatorVault(operator); - - _setOperatorNetworkLimit(alice, operator, network, amount1); - - assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount1); - assertEq(vault.operatorNetworkLimit(operator, network), amount1); - (uint256 nextOperatorNetworkLimitAmount, uint256 nextOperatorNetworkLimitTimestamp) = - vault.nextOperatorNetworkLimit(operator, network); - assertEq(nextOperatorNetworkLimitAmount, 0); - assertEq(nextOperatorNetworkLimitTimestamp, 0); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount1); - assertEq(vault.operatorNetworkLimit(operator, network), amount1); - (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = - vault.nextOperatorNetworkLimit(operator, network); - assertEq(nextOperatorNetworkLimitAmount, 0); - assertEq(nextOperatorNetworkLimitTimestamp, 0); - - _setOperatorNetworkLimit(alice, operator, network, amount2); - - if (amount1 > amount2) { - assertEq( - vault.operatorNetworkLimitIn( - operator, - network, - uint48(vault.currentEpochStart() + 2 * vault.epochDuration() - 1 - blockTimestamp) - ), - amount1 - ); - assertEq(vault.operatorNetworkLimit(operator, network), amount1); - (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = - vault.nextOperatorNetworkLimit(operator, network); - assertEq(nextOperatorNetworkLimitAmount, amount2); - assertEq(nextOperatorNetworkLimitTimestamp, vault.currentEpochStart() + 2 * vault.epochDuration()); - - blockTimestamp = vault.currentEpochStart() + 2 * vault.epochDuration() - 1; - vm.warp(blockTimestamp); - - assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount2); - assertEq(vault.operatorNetworkLimit(operator, network), amount1); - (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = - vault.nextOperatorNetworkLimit(operator, network); - assertEq(nextOperatorNetworkLimitAmount, amount2); - assertEq(nextOperatorNetworkLimitTimestamp, vault.currentEpochStart() + vault.epochDuration()); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount2); - assertEq(vault.operatorNetworkLimit(operator, network), amount2); - (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = - vault.nextOperatorNetworkLimit(operator, network); - assertEq(nextOperatorNetworkLimitAmount, amount2); - assertEq(nextOperatorNetworkLimitTimestamp, vault.currentEpochStart()); - - _setOperatorNetworkLimit(alice, operator, network, amount2); - - assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount2); - assertEq(vault.operatorNetworkLimit(operator, network), amount2); - (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = - vault.nextOperatorNetworkLimit(operator, network); - assertEq(nextOperatorNetworkLimitAmount, 0); - assertEq(nextOperatorNetworkLimitTimestamp, 0); - } else { - assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount2); - assertEq(vault.operatorNetworkLimit(operator, network), amount2); - (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = - vault.nextOperatorNetworkLimit(operator, network); - assertEq(nextOperatorNetworkLimitAmount, 0); - assertEq(nextOperatorNetworkLimitTimestamp, 0); - } - - _setOperatorNetworkLimit(alice, operator, network, amount3); - - assertEq( - vault.operatorNetworkLimitIn( - operator, network, uint48(vault.currentEpochStart() + 2 * vault.epochDuration() - blockTimestamp) - ), - amount3 - ); - assertEq(vault.operatorNetworkLimit(operator, network), amount2); - (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = - vault.nextOperatorNetworkLimit(operator, network); - assertEq(nextOperatorNetworkLimitAmount, amount3); - assertEq(nextOperatorNetworkLimitTimestamp, vault.currentEpochStart() + 2 * vault.epochDuration()); - - _setOperatorNetworkLimit(alice, operator, network, amount2); - - assertEq( - vault.operatorNetworkLimitIn( - operator, network, uint48(vault.currentEpochStart() + 2 * vault.epochDuration() - blockTimestamp) - ), - amount2 - ); - assertEq(vault.operatorNetworkLimit(operator, network), amount2); - (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = - vault.nextOperatorNetworkLimit(operator, network); - assertEq(nextOperatorNetworkLimitAmount, 0); - assertEq(nextOperatorNetworkLimitTimestamp, 0); - - _optOutOperatorVault(operator); - - assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount2); - assertEq(vault.operatorNetworkLimit(operator, network), amount2); - (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = - vault.nextOperatorNetworkLimit(operator, network); - assertEq(nextOperatorNetworkLimitAmount, 0); - assertEq(nextOperatorNetworkLimitTimestamp, 0); - - blockTimestamp = vault.currentEpochStart() + 2 * vault.epochDuration() - 1; - vm.warp(blockTimestamp); - - assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount2); - assertEq(vault.operatorNetworkLimit(operator, network), amount2); - (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = - vault.nextOperatorNetworkLimit(operator, network); - assertEq(nextOperatorNetworkLimitAmount, 0); - assertEq(nextOperatorNetworkLimitTimestamp, 0); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - - assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount2); - assertEq(vault.operatorNetworkLimit(operator, network), amount2); - (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = - vault.nextOperatorNetworkLimit(operator, network); - assertEq(nextOperatorNetworkLimitAmount, 0); - assertEq(nextOperatorNetworkLimitTimestamp, 0); - } - - function test_SetOperatorNetworkLimitRevertOnlyRole(uint48 epochDuration, uint256 amount1) public { - epochDuration = uint48(bound(uint256(epochDuration), 1, 100 days)); - - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - address operator = bob; - _registerOperator(operator); - - address network = address(1); - _optInOperatorVault(operator); - - vm.expectRevert(); - _setOperatorNetworkLimit(bob, operator, network, amount1); - } - - function test_SetMaxNetworkResolverLimit(uint256 amount1, uint256 amount2, uint256 networkResolverLimit) public { - amount1 = bound(amount1, 1, type(uint256).max); - vm.assume(amount1 != amount2); - networkResolverLimit = bound(networkResolverLimit, 1, amount1); - - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - address network = bob; - _registerNetwork(network, bob); - - address resolver = alice; - - _setMaxNetworkResolverLimit(network, resolver, amount1); - assertEq(vault.maxNetworkResolverLimit(network, resolver), amount1); - - _optInNetworkVault(network, resolver); - - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); - _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit - 1); - - _setMaxNetworkResolverLimit(network, resolver, amount2); - - assertEq(vault.maxNetworkResolverLimit(network, resolver), amount2); - assertEq(vault.networkResolverLimit(network, resolver), Math.min(networkResolverLimit, amount2)); - (uint256 nextNetworkResolverLimitAmount, uint256 nextNetworkResolverLimitTimestamp) = - vault.nextNetworkResolverLimit(network, resolver); - assertEq(nextNetworkResolverLimitAmount, Math.min(networkResolverLimit - 1, amount2)); - assertEq(nextNetworkResolverLimitTimestamp, vault.currentEpochStart() + 2 * vault.epochDuration()); - } - - function test_SetMaxNetworkResolverLimitRevertAlreadySet(uint256 amount) public { - amount = bound(amount, 1, type(uint256).max); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; + +// uint256 shares = _deposit(alice, amount1); + +// shares += _deposit(bob, amount2); + +// address network = bob; +// _registerNetwork(network, bob); + +// address operator = bob; +// _registerOperator(operator); + +// address resolver = alice; +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); + +// _optInOperatorVault(operator); + +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); + +// _setOperatorNetworkLimit(alice, operator, network, operatorNetworkLimit); + +// _optInOperatorNetwork(operator, network); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// uint256 slashIndex = _requestSlash(bob, network, resolver, operator, toSlash); + +// _vetoSlash(resolver, slashIndex); + +// vm.expectRevert(IVault.SlashCompleted.selector); +// _vetoSlash(resolver, slashIndex); +// } + +// function test_CreateRevertInvalidEpochDuration() public { +// uint48 epochDuration = 0; +// uint48 executeDuration = 0; +// uint48 vetoDuration = 0; + +// uint64 lastVersion = vaultFactory.lastVersion(); +// vm.expectRevert(IVault.InvalidEpochDuration.selector); +// vault = IVault( +// vaultFactory.create( +// lastVersion, +// alice, +// abi.encode( +// IVault.InitParams({ +// collateral: address(collateral), +// epochDuration: epochDuration, +// vetoDuration: vetoDuration, +// executeDuration: executeDuration, +// rewardsDistributor: address(0), +// adminFee: 0, +// depositWhitelist: false +// }) +// ) +// ) +// ); +// } + +// function test_CreateRevertInvalidSlashDuration( +// uint48 epochDuration, +// uint48 vetoDuration, +// uint48 executeDuration +// ) public { +// epochDuration = uint48(bound(epochDuration, 1, type(uint48).max)); +// vetoDuration = uint48(bound(vetoDuration, 0, type(uint48).max / 2)); +// executeDuration = uint48(bound(executeDuration, 0, type(uint48).max / 2)); +// vm.assume(vetoDuration + executeDuration > epochDuration); + +// uint64 lastVersion = vaultFactory.lastVersion(); +// vm.expectRevert(IVault.InvalidSlashDuration.selector); +// vault = IVault( +// vaultFactory.create( +// lastVersion, +// alice, +// abi.encode( +// IVault.InitParams({ +// collateral: address(collateral), +// epochDuration: epochDuration, +// vetoDuration: vetoDuration, +// executeDuration: executeDuration, +// rewardsDistributor: address(0), +// adminFee: 0, +// depositWhitelist: false +// }) +// ) +// ) +// ); +// } + +// function test_CreateRevertInvalidAdminFee(uint256 adminFee) public { +// vm.assume(adminFee > 10_000); + +// uint48 epochDuration = 1; +// uint48 executeDuration = 0; +// uint48 vetoDuration = 0; + +// uint64 lastVersion = vaultFactory.lastVersion(); +// vm.expectRevert(IVault.InvalidAdminFee.selector); +// vault = IVault( +// vaultFactory.create( +// lastVersion, +// alice, +// abi.encode( +// IVault.InitParams({ +// collateral: address(collateral), +// epochDuration: epochDuration, +// vetoDuration: vetoDuration, +// executeDuration: executeDuration, +// rewardsDistributor: address(0), +// adminFee: adminFee, +// depositWhitelist: false +// }) +// ) +// ) +// ); +// } + +// function test_SetNetworkResolverLimit( +// uint48 epochDuration, +// uint256 amount1, +// uint256 amount2, +// uint256 amount3 +// ) public { +// epochDuration = uint48(bound(uint256(epochDuration), 1, 100 days)); +// vm.assume(amount3 < amount2); + +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; + +// address network = bob; +// _registerNetwork(network, bob); + +// address resolver = address(1); +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); + +// _setNetworkResolverLimit(alice, network, resolver, amount1); + +// assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount1); +// assertEq(vault.networkResolverLimit(network, resolver), amount1); +// (uint256 nextNetworkResolverLimitAmount, uint256 nextNetworkResolverLimitTimestamp) = +// vault.nextNetworkResolverLimit(network, resolver); +// assertEq(nextNetworkResolverLimitAmount, 0); +// assertEq(nextNetworkResolverLimitTimestamp, 0); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount1); +// assertEq(vault.networkResolverLimit(network, resolver), amount1); +// (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = +// vault.nextNetworkResolverLimit(network, resolver); +// assertEq(nextNetworkResolverLimitAmount, 0); +// assertEq(nextNetworkResolverLimitTimestamp, 0); + +// _setNetworkResolverLimit(alice, network, resolver, amount2); + +// if (amount1 > amount2) { +// assertEq( +// vault.networkResolverLimitIn( +// network, +// resolver, +// uint48(vault.currentEpochStart() + 2 * vault.epochDuration() - 1 - blockTimestamp) +// ), +// amount1 +// ); +// assertEq(vault.networkResolverLimit(network, resolver), amount1); +// (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = +// vault.nextNetworkResolverLimit(network, resolver); +// assertEq(nextNetworkResolverLimitAmount, amount2); +// assertEq(nextNetworkResolverLimitTimestamp, vault.currentEpochStart() + 2 * vault.epochDuration()); + +// blockTimestamp = vault.currentEpochStart() + 2 * vault.epochDuration() - 1; +// vm.warp(blockTimestamp); + +// assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount2); +// assertEq(vault.networkResolverLimit(network, resolver), amount1); +// (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = +// vault.nextNetworkResolverLimit(network, resolver); +// assertEq(nextNetworkResolverLimitAmount, amount2); +// assertEq(nextNetworkResolverLimitTimestamp, vault.currentEpochStart() + vault.epochDuration()); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount2); +// assertEq(vault.networkResolverLimit(network, resolver), amount2); +// (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = +// vault.nextNetworkResolverLimit(network, resolver); +// assertEq(nextNetworkResolverLimitAmount, amount2); +// assertEq(nextNetworkResolverLimitTimestamp, vault.currentEpochStart()); + +// _setNetworkResolverLimit(alice, network, resolver, amount2); + +// assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount2); +// assertEq(vault.networkResolverLimit(network, resolver), amount2); +// (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = +// vault.nextNetworkResolverLimit(network, resolver); +// assertEq(nextNetworkResolverLimitAmount, 0); +// assertEq(nextNetworkResolverLimitTimestamp, 0); +// } else { +// assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount2); +// assertEq(vault.networkResolverLimit(network, resolver), amount2); +// (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = +// vault.nextNetworkResolverLimit(network, resolver); +// assertEq(nextNetworkResolverLimitAmount, 0); +// assertEq(nextNetworkResolverLimitTimestamp, 0); +// } + +// _setNetworkResolverLimit(alice, network, resolver, amount3); + +// assertEq( +// vault.networkResolverLimitIn( +// network, resolver, uint48(vault.currentEpochStart() + 2 * vault.epochDuration() - blockTimestamp) +// ), +// amount3 +// ); +// assertEq(vault.networkResolverLimit(network, resolver), amount2); +// (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = +// vault.nextNetworkResolverLimit(network, resolver); +// assertEq(nextNetworkResolverLimitAmount, amount3); +// assertEq(nextNetworkResolverLimitTimestamp, vault.currentEpochStart() + 2 * vault.epochDuration()); + +// _setNetworkResolverLimit(alice, network, resolver, amount2); + +// assertEq( +// vault.networkResolverLimitIn( +// network, resolver, uint48(vault.currentEpochStart() + 2 * vault.epochDuration() - blockTimestamp) +// ), +// amount2 +// ); +// assertEq(vault.networkResolverLimit(network, resolver), amount2); +// (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = +// vault.nextNetworkResolverLimit(network, resolver); +// assertEq(nextNetworkResolverLimitAmount, 0); +// assertEq(nextNetworkResolverLimitTimestamp, 0); + +// _optOutNetworkVault(network, resolver); + +// assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount2); +// assertEq(vault.networkResolverLimit(network, resolver), amount2); +// (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = +// vault.nextNetworkResolverLimit(network, resolver); +// assertEq(nextNetworkResolverLimitAmount, 0); +// assertEq(nextNetworkResolverLimitTimestamp, 0); + +// blockTimestamp = vault.currentEpochStart() + 2 * vault.epochDuration() - 1; +// vm.warp(blockTimestamp); + +// assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount2); +// assertEq(vault.networkResolverLimit(network, resolver), amount2); +// (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = +// vault.nextNetworkResolverLimit(network, resolver); +// assertEq(nextNetworkResolverLimitAmount, 0); +// assertEq(nextNetworkResolverLimitTimestamp, 0); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// assertEq(vault.networkResolverLimitIn(network, resolver, 1), amount2); +// assertEq(vault.networkResolverLimit(network, resolver), amount2); +// (nextNetworkResolverLimitAmount, nextNetworkResolverLimitTimestamp) = +// vault.nextNetworkResolverLimit(network, resolver); +// assertEq(nextNetworkResolverLimitAmount, 0); +// assertEq(nextNetworkResolverLimitTimestamp, 0); +// } + +// function test_SetNetworkResolverLimitRevertOnlyRole(uint48 epochDuration, uint256 amount1) public { +// epochDuration = uint48(bound(uint256(epochDuration), 1, 100 days)); + +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// address network = bob; +// _registerNetwork(network, bob); + +// address resolver = address(1); +// _setMaxNetworkResolverLimit(network, resolver, type(uint256).max); +// _optInNetworkVault(network, resolver); + +// vm.expectRevert(); +// _setNetworkResolverLimit(bob, network, resolver, amount1); +// } + +// function test_SetNetworkResolverLimitRevertExceedsMaxNetworkResolverLimit( +// uint48 epochDuration, +// uint256 amount1, +// uint256 maxNetworkResolverLimit +// ) public { +// epochDuration = uint48(bound(uint256(epochDuration), 1, 100 days)); +// maxNetworkResolverLimit = bound(maxNetworkResolverLimit, 1, type(uint256).max); +// vm.assume(amount1 > maxNetworkResolverLimit); + +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// address network = bob; +// _registerNetwork(network, bob); + +// address resolver = address(1); +// _setMaxNetworkResolverLimit(network, resolver, maxNetworkResolverLimit); +// _optInNetworkVault(network, resolver); + +// vm.expectRevert(IVault.ExceedsMaxNetworkResolverLimit.selector); +// _setNetworkResolverLimit(alice, network, resolver, amount1); +// } + +// function test_SetOperatorNetworkLimit( +// uint48 epochDuration, +// uint256 amount1, +// uint256 amount2, +// uint256 amount3 +// ) public { +// epochDuration = uint48(bound(uint256(epochDuration), 1, 100 days)); +// vm.assume(amount3 < amount2); + +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; + +// address operator = bob; +// _registerOperator(operator); + +// address network = address(1); +// _optInOperatorVault(operator); + +// _setOperatorNetworkLimit(alice, operator, network, amount1); + +// assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount1); +// assertEq(vault.operatorNetworkLimit(operator, network), amount1); +// (uint256 nextOperatorNetworkLimitAmount, uint256 nextOperatorNetworkLimitTimestamp) = +// vault.nextOperatorNetworkLimit(operator, network); +// assertEq(nextOperatorNetworkLimitAmount, 0); +// assertEq(nextOperatorNetworkLimitTimestamp, 0); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount1); +// assertEq(vault.operatorNetworkLimit(operator, network), amount1); +// (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = +// vault.nextOperatorNetworkLimit(operator, network); +// assertEq(nextOperatorNetworkLimitAmount, 0); +// assertEq(nextOperatorNetworkLimitTimestamp, 0); + +// _setOperatorNetworkLimit(alice, operator, network, amount2); + +// if (amount1 > amount2) { +// assertEq( +// vault.operatorNetworkLimitIn( +// operator, +// network, +// uint48(vault.currentEpochStart() + 2 * vault.epochDuration() - 1 - blockTimestamp) +// ), +// amount1 +// ); +// assertEq(vault.operatorNetworkLimit(operator, network), amount1); +// (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = +// vault.nextOperatorNetworkLimit(operator, network); +// assertEq(nextOperatorNetworkLimitAmount, amount2); +// assertEq(nextOperatorNetworkLimitTimestamp, vault.currentEpochStart() + 2 * vault.epochDuration()); + +// blockTimestamp = vault.currentEpochStart() + 2 * vault.epochDuration() - 1; +// vm.warp(blockTimestamp); + +// assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount2); +// assertEq(vault.operatorNetworkLimit(operator, network), amount1); +// (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = +// vault.nextOperatorNetworkLimit(operator, network); +// assertEq(nextOperatorNetworkLimitAmount, amount2); +// assertEq(nextOperatorNetworkLimitTimestamp, vault.currentEpochStart() + vault.epochDuration()); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount2); +// assertEq(vault.operatorNetworkLimit(operator, network), amount2); +// (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = +// vault.nextOperatorNetworkLimit(operator, network); +// assertEq(nextOperatorNetworkLimitAmount, amount2); +// assertEq(nextOperatorNetworkLimitTimestamp, vault.currentEpochStart()); + +// _setOperatorNetworkLimit(alice, operator, network, amount2); + +// assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount2); +// assertEq(vault.operatorNetworkLimit(operator, network), amount2); +// (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = +// vault.nextOperatorNetworkLimit(operator, network); +// assertEq(nextOperatorNetworkLimitAmount, 0); +// assertEq(nextOperatorNetworkLimitTimestamp, 0); +// } else { +// assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount2); +// assertEq(vault.operatorNetworkLimit(operator, network), amount2); +// (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = +// vault.nextOperatorNetworkLimit(operator, network); +// assertEq(nextOperatorNetworkLimitAmount, 0); +// assertEq(nextOperatorNetworkLimitTimestamp, 0); +// } + +// _setOperatorNetworkLimit(alice, operator, network, amount3); + +// assertEq( +// vault.operatorNetworkLimitIn( +// operator, network, uint48(vault.currentEpochStart() + 2 * vault.epochDuration() - blockTimestamp) +// ), +// amount3 +// ); +// assertEq(vault.operatorNetworkLimit(operator, network), amount2); +// (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = +// vault.nextOperatorNetworkLimit(operator, network); +// assertEq(nextOperatorNetworkLimitAmount, amount3); +// assertEq(nextOperatorNetworkLimitTimestamp, vault.currentEpochStart() + 2 * vault.epochDuration()); + +// _setOperatorNetworkLimit(alice, operator, network, amount2); + +// assertEq( +// vault.operatorNetworkLimitIn( +// operator, network, uint48(vault.currentEpochStart() + 2 * vault.epochDuration() - blockTimestamp) +// ), +// amount2 +// ); +// assertEq(vault.operatorNetworkLimit(operator, network), amount2); +// (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = +// vault.nextOperatorNetworkLimit(operator, network); +// assertEq(nextOperatorNetworkLimitAmount, 0); +// assertEq(nextOperatorNetworkLimitTimestamp, 0); + +// _optOutOperatorVault(operator); + +// assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount2); +// assertEq(vault.operatorNetworkLimit(operator, network), amount2); +// (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = +// vault.nextOperatorNetworkLimit(operator, network); +// assertEq(nextOperatorNetworkLimitAmount, 0); +// assertEq(nextOperatorNetworkLimitTimestamp, 0); + +// blockTimestamp = vault.currentEpochStart() + 2 * vault.epochDuration() - 1; +// vm.warp(blockTimestamp); + +// assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount2); +// assertEq(vault.operatorNetworkLimit(operator, network), amount2); +// (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = +// vault.nextOperatorNetworkLimit(operator, network); +// assertEq(nextOperatorNetworkLimitAmount, 0); +// assertEq(nextOperatorNetworkLimitTimestamp, 0); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); + +// assertEq(vault.operatorNetworkLimitIn(operator, network, 1), amount2); +// assertEq(vault.operatorNetworkLimit(operator, network), amount2); +// (nextOperatorNetworkLimitAmount, nextOperatorNetworkLimitTimestamp) = +// vault.nextOperatorNetworkLimit(operator, network); +// assertEq(nextOperatorNetworkLimitAmount, 0); +// assertEq(nextOperatorNetworkLimitTimestamp, 0); +// } + +// function test_SetOperatorNetworkLimitRevertOnlyRole(uint48 epochDuration, uint256 amount1) public { +// epochDuration = uint48(bound(uint256(epochDuration), 1, 100 days)); + +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// address operator = bob; +// _registerOperator(operator); + +// address network = address(1); +// _optInOperatorVault(operator); + +// vm.expectRevert(); +// _setOperatorNetworkLimit(bob, operator, network, amount1); +// } + +// function test_SetMaxNetworkResolverLimit(uint256 amount1, uint256 amount2, uint256 networkResolverLimit) public { +// amount1 = bound(amount1, 1, type(uint256).max); +// vm.assume(amount1 != amount2); +// networkResolverLimit = bound(networkResolverLimit, 1, amount1); + +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// address network = bob; +// _registerNetwork(network, bob); + +// address resolver = alice; + +// _setMaxNetworkResolverLimit(network, resolver, amount1); +// assertEq(vault.maxNetworkResolverLimit(network, resolver), amount1); + +// _optInNetworkVault(network, resolver); + +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit); +// _setNetworkResolverLimit(alice, network, resolver, networkResolverLimit - 1); + +// _setMaxNetworkResolverLimit(network, resolver, amount2); + +// assertEq(vault.maxNetworkResolverLimit(network, resolver), amount2); +// assertEq(vault.networkResolverLimit(network, resolver), Math.min(networkResolverLimit, amount2)); +// (uint256 nextNetworkResolverLimitAmount, uint256 nextNetworkResolverLimitTimestamp) = +// vault.nextNetworkResolverLimit(network, resolver); +// assertEq(nextNetworkResolverLimitAmount, Math.min(networkResolverLimit - 1, amount2)); +// assertEq(nextNetworkResolverLimitTimestamp, vault.currentEpochStart() + 2 * vault.epochDuration()); +// } + +// function test_SetMaxNetworkResolverLimitRevertAlreadySet(uint256 amount) public { +// amount = bound(amount, 1, type(uint256).max); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - address resolver = alice; +// address resolver = alice; - _setMaxNetworkResolverLimit(network, resolver, amount); +// _setMaxNetworkResolverLimit(network, resolver, amount); - vm.expectRevert(IVault.AlreadySet.selector); - _setMaxNetworkResolverLimit(network, resolver, amount); - } +// vm.expectRevert(IVault.AlreadySet.selector); +// _setMaxNetworkResolverLimit(network, resolver, amount); +// } - function test_SetMaxNetworkResolverLimitRevertNotNetwork(uint256 amount) public { - amount = bound(amount, 1, type(uint256).max); +// function test_SetMaxNetworkResolverLimitRevertNotNetwork(uint256 amount) public { +// amount = bound(amount, 1, type(uint256).max); - uint48 epochDuration = 3; - uint48 executeDuration = 1; - uint48 vetoDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 3; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - address network = bob; +// address network = bob; - address resolver = alice; +// address resolver = alice; - vm.expectRevert(IVault.NotNetwork.selector); - _setMaxNetworkResolverLimit(network, resolver, amount); - } +// vm.expectRevert(IVault.NotNetwork.selector); +// _setMaxNetworkResolverLimit(network, resolver, amount); +// } - function test_SetRewardsDistributor(address rewardsDistributor1, address rewardsDistributor2) public { - uint48 epochDuration = 1; - uint48 executeDuration = 0; - uint48 vetoDuration = 0; +// function test_SetRewardsDistributor(address rewardsDistributor1, address rewardsDistributor2) public { +// uint48 epochDuration = 1; +// uint48 executeDuration = 0; +// uint48 vetoDuration = 0; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - vm.assume(rewardsDistributor1 != address(0)); - vm.assume(rewardsDistributor1 != rewardsDistributor2); +// vault = _getVault(epochDuration, vetoDuration, executeDuration); +// vm.assume(rewardsDistributor1 != address(0)); +// vm.assume(rewardsDistributor1 != rewardsDistributor2); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, rewardsDistributor1); - assertEq(vault.rewardsDistributor(), rewardsDistributor1); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, rewardsDistributor1); +// assertEq(vault.rewardsDistributor(), rewardsDistributor1); - _setRewardsDistributor(alice, rewardsDistributor2); - assertEq(vault.rewardsDistributor(), rewardsDistributor2); - } +// _setRewardsDistributor(alice, rewardsDistributor2); +// assertEq(vault.rewardsDistributor(), rewardsDistributor2); +// } - function test_SetRewardsDistributorRevertUnauthorized(address rewardsDistributor) public { - uint48 epochDuration = 1; - uint48 executeDuration = 0; - uint48 vetoDuration = 0; +// function test_SetRewardsDistributorRevertUnauthorized(address rewardsDistributor) public { +// uint48 epochDuration = 1; +// uint48 executeDuration = 0; +// uint48 vetoDuration = 0; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - vm.assume(rewardsDistributor != address(0)); +// vault = _getVault(epochDuration, vetoDuration, executeDuration); +// vm.assume(rewardsDistributor != address(0)); - vm.expectRevert(); - _setRewardsDistributor(alice, rewardsDistributor); - } +// vm.expectRevert(); +// _setRewardsDistributor(alice, rewardsDistributor); +// } - function test_SetRewardsDistributorRevertAlreadySet(address rewardsDistributor) public { - uint48 epochDuration = 1; - uint48 executeDuration = 0; - uint48 vetoDuration = 0; +// function test_SetRewardsDistributorRevertAlreadySet(address rewardsDistributor) public { +// uint48 epochDuration = 1; +// uint48 executeDuration = 0; +// uint48 vetoDuration = 0; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - vm.assume(rewardsDistributor != address(0)); +// vault = _getVault(epochDuration, vetoDuration, executeDuration); +// vm.assume(rewardsDistributor != address(0)); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, rewardsDistributor); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, rewardsDistributor); - vm.expectRevert(IVault.AlreadySet.selector); - _setRewardsDistributor(alice, rewardsDistributor); - } +// vm.expectRevert(IVault.AlreadySet.selector); +// _setRewardsDistributor(alice, rewardsDistributor); +// } - function test_SetAdminFee(uint256 adminFee1, uint256 adminFee2) public { - uint48 epochDuration = 1; - uint48 executeDuration = 0; - uint48 vetoDuration = 0; +// function test_SetAdminFee(uint256 adminFee1, uint256 adminFee2) public { +// uint48 epochDuration = 1; +// uint48 executeDuration = 0; +// uint48 vetoDuration = 0; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - adminFee1 = bound(adminFee1, 1, vault.ADMIN_FEE_BASE()); - adminFee2 = bound(adminFee2, 0, vault.ADMIN_FEE_BASE()); - vm.assume(adminFee1 != adminFee2); +// vault = _getVault(epochDuration, vetoDuration, executeDuration); +// adminFee1 = bound(adminFee1, 1, vault.ADMIN_FEE_BASE()); +// adminFee2 = bound(adminFee2, 0, vault.ADMIN_FEE_BASE()); +// vm.assume(adminFee1 != adminFee2); - _grantAdminFeeSetRole(alice, alice); - _setAdminFee(alice, adminFee1); - assertEq(vault.adminFee(), adminFee1); +// _grantAdminFeeSetRole(alice, alice); +// _setAdminFee(alice, adminFee1); +// assertEq(vault.adminFee(), adminFee1); - _setAdminFee(alice, adminFee2); - assertEq(vault.adminFee(), adminFee2); - } +// _setAdminFee(alice, adminFee2); +// assertEq(vault.adminFee(), adminFee2); +// } - function test_SetAdminFeeRevertUnauthorized(uint256 adminFee) public { - uint48 epochDuration = 1; - uint48 executeDuration = 0; - uint48 vetoDuration = 0; +// function test_SetAdminFeeRevertUnauthorized(uint256 adminFee) public { +// uint48 epochDuration = 1; +// uint48 executeDuration = 0; +// uint48 vetoDuration = 0; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - adminFee = bound(adminFee, 1, vault.ADMIN_FEE_BASE()); +// vault = _getVault(epochDuration, vetoDuration, executeDuration); +// adminFee = bound(adminFee, 1, vault.ADMIN_FEE_BASE()); - vm.expectRevert(); - _setAdminFee(bob, adminFee); - } +// vm.expectRevert(); +// _setAdminFee(bob, adminFee); +// } - function test_SetAdminFeeRevertAlreadySet(uint256 adminFee) public { - uint48 epochDuration = 1; - uint48 executeDuration = 0; - uint48 vetoDuration = 0; +// function test_SetAdminFeeRevertAlreadySet(uint256 adminFee) public { +// uint48 epochDuration = 1; +// uint48 executeDuration = 0; +// uint48 vetoDuration = 0; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - adminFee = bound(adminFee, 1, vault.ADMIN_FEE_BASE()); +// vault = _getVault(epochDuration, vetoDuration, executeDuration); +// adminFee = bound(adminFee, 1, vault.ADMIN_FEE_BASE()); - _grantAdminFeeSetRole(alice, alice); - _setAdminFee(alice, adminFee); +// _grantAdminFeeSetRole(alice, alice); +// _setAdminFee(alice, adminFee); - vm.expectRevert(IVault.AlreadySet.selector); - _setAdminFee(alice, adminFee); - } +// vm.expectRevert(IVault.AlreadySet.selector); +// _setAdminFee(alice, adminFee); +// } - function test_SetAdminFeeRevertInvalidAdminFee(uint256 adminFee) public { - uint48 epochDuration = 1; - uint48 executeDuration = 0; - uint48 vetoDuration = 0; +// function test_SetAdminFeeRevertInvalidAdminFee(uint256 adminFee) public { +// uint48 epochDuration = 1; +// uint48 executeDuration = 0; +// uint48 vetoDuration = 0; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - vm.assume(adminFee > vault.ADMIN_FEE_BASE()); +// vault = _getVault(epochDuration, vetoDuration, executeDuration); +// vm.assume(adminFee > vault.ADMIN_FEE_BASE()); - _grantAdminFeeSetRole(alice, alice); - vm.expectRevert(IVault.InvalidAdminFee.selector); - _setAdminFee(alice, adminFee); - } +// _grantAdminFeeSetRole(alice, alice); +// vm.expectRevert(IVault.InvalidAdminFee.selector); +// _setAdminFee(alice, adminFee); +// } - function test_SetDepositWhitelist() public { - uint48 epochDuration = 1; - uint48 executeDuration = 0; - uint48 vetoDuration = 0; +// function test_SetDepositWhitelist() public { +// uint48 epochDuration = 1; +// uint48 executeDuration = 0; +// uint48 vetoDuration = 0; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - _grantDepositWhitelistSetRole(alice, alice); - _setDepositWhitelist(alice, true); - assertEq(vault.depositWhitelist(), true); +// _grantDepositWhitelistSetRole(alice, alice); +// _setDepositWhitelist(alice, true); +// assertEq(vault.depositWhitelist(), true); - _setDepositWhitelist(alice, false); - assertEq(vault.depositWhitelist(), false); - } +// _setDepositWhitelist(alice, false); +// assertEq(vault.depositWhitelist(), false); +// } - function test_SetDepositWhitelistRevertNotWhitelistedDepositor() public { - uint48 epochDuration = 1; - uint48 executeDuration = 0; - uint48 vetoDuration = 0; +// function test_SetDepositWhitelistRevertNotWhitelistedDepositor() public { +// uint48 epochDuration = 1; +// uint48 executeDuration = 0; +// uint48 vetoDuration = 0; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - _deposit(alice, 1); +// _deposit(alice, 1); - _grantDepositWhitelistSetRole(alice, alice); - _setDepositWhitelist(alice, true); +// _grantDepositWhitelistSetRole(alice, alice); +// _setDepositWhitelist(alice, true); - vm.startPrank(alice); - vm.expectRevert(IVault.NotWhitelistedDepositor.selector); - vault.deposit(alice, 1); - vm.stopPrank(); - } +// vm.startPrank(alice); +// vm.expectRevert(IVault.NotWhitelistedDepositor.selector); +// vault.deposit(alice, 1); +// vm.stopPrank(); +// } - function test_SetDepositWhitelistRevertAlreadySet() public { - uint48 epochDuration = 1; - uint48 executeDuration = 0; - uint48 vetoDuration = 0; +// function test_SetDepositWhitelistRevertAlreadySet() public { +// uint48 epochDuration = 1; +// uint48 executeDuration = 0; +// uint48 vetoDuration = 0; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - _grantDepositWhitelistSetRole(alice, alice); - _setDepositWhitelist(alice, true); - - vm.expectRevert(IVault.AlreadySet.selector); - _setDepositWhitelist(alice, true); - } +// _grantDepositWhitelistSetRole(alice, alice); +// _setDepositWhitelist(alice, true); + +// vm.expectRevert(IVault.AlreadySet.selector); +// _setDepositWhitelist(alice, true); +// } - function test_SetDepositorWhitelistStatus() public { - uint48 epochDuration = 1; - uint48 executeDuration = 0; - uint48 vetoDuration = 0; +// function test_SetDepositorWhitelistStatus() public { +// uint48 epochDuration = 1; +// uint48 executeDuration = 0; +// uint48 vetoDuration = 0; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - _grantDepositWhitelistSetRole(alice, alice); - _setDepositWhitelist(alice, true); - - _grantDepositorWhitelistRole(alice, alice); - - _setDepositorWhitelistStatus(alice, bob, true); - assertEq(vault.isDepositorWhitelisted(bob), true); - - _deposit(bob, 1); - - _setDepositWhitelist(alice, false); - - _deposit(bob, 1); - } - - function test_SetDepositorWhitelistStatusRevertNoDepositWhitelist() public { - uint48 epochDuration = 1; - uint48 executeDuration = 0; - uint48 vetoDuration = 0; - - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - _grantDepositorWhitelistRole(alice, alice); - - vm.expectRevert(IVault.NoDepositWhitelist.selector); - _setDepositorWhitelistStatus(alice, bob, true); - } - - function test_SetDepositorWhitelistStatusRevertAlreadySet() public { - uint48 epochDuration = 1; - uint48 executeDuration = 0; - uint48 vetoDuration = 0; - - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - _grantDepositWhitelistSetRole(alice, alice); - _setDepositWhitelist(alice, true); - - _grantDepositorWhitelistRole(alice, alice); - - _setDepositorWhitelistStatus(alice, bob, true); - - vm.expectRevert(IVault.AlreadySet.selector); - _setDepositorWhitelistStatus(alice, bob, true); - } - - function _getVault(uint48 epochDuration, uint48 vetoDuration, uint48 executeDuration) internal returns (IVault) { - return IVault( - vaultFactory.create( - vaultFactory.lastVersion(), - alice, - abi.encode( - IVault.InitParams({ - collateral: address(collateral), - epochDuration: epochDuration, - vetoDuration: vetoDuration, - executeDuration: executeDuration, - rewardsDistributor: address(0), - adminFee: 0, - depositWhitelist: false - }) - ) - ) - ); - } - - function _registerOperator(address user) internal { - vm.startPrank(user); - operatorRegistry.registerOperator(); - vm.stopPrank(); - } - - function _registerNetwork(address user, address middleware) internal { - vm.startPrank(user); - networkRegistry.registerNetwork(); - networkMiddlewareService.setMiddleware(middleware); - vm.stopPrank(); - } - - function _grantDepositorWhitelistRole(address user, address account) internal { - vm.startPrank(user); - Vault(address(vault)).grantRole(vault.DEPOSITOR_WHITELIST_ROLE(), account); - vm.stopPrank(); - } - - function _grantRewardsDistributorSetRole(address user, address account) internal { - vm.startPrank(user); - Vault(address(vault)).grantRole(vault.REWARDS_DISTRIBUTOR_SET_ROLE(), account); - vm.stopPrank(); - } - - function _grantAdminFeeSetRole(address user, address account) internal { - vm.startPrank(user); - Vault(address(vault)).grantRole(vault.ADMIN_FEE_SET_ROLE(), account); - vm.stopPrank(); - } - - function _grantDepositWhitelistSetRole(address user, address account) internal { - vm.startPrank(user); - Vault(address(vault)).grantRole(vault.DEPOSIT_WHITELIST_SET_ROLE(), account); - vm.stopPrank(); - } - - function _deposit(address user, uint256 amount) internal returns (uint256 shares) { - collateral.transfer(user, amount); - vm.startPrank(user); - collateral.approve(address(vault), amount); - shares = vault.deposit(user, amount); - vm.stopPrank(); - } - - function _withdraw(address user, uint256 amount) internal returns (uint256 burnedShares, uint256 mintedShares) { - vm.startPrank(user); - (burnedShares, mintedShares) = vault.withdraw(user, amount); - vm.stopPrank(); - } - - function _claim(address user, uint256 epoch) internal returns (uint256 amount) { - vm.startPrank(user); - amount = vault.claim(user, epoch); - vm.stopPrank(); - } - - function _requestSlash( - address user, - address network, - address resolver, - address operator, - uint256 amount - ) internal returns (uint256 slashIndex) { - vm.startPrank(user); - slashIndex = vault.requestSlash(network, resolver, operator, amount); - vm.stopPrank(); - } - - function _executeSlash(address user, uint256 slashIndex) internal returns (uint256 slashedAmount) { - vm.startPrank(user); - slashedAmount = vault.executeSlash(slashIndex); - vm.stopPrank(); - } - - function _vetoSlash(address user, uint256 slashIndex) internal { - vm.startPrank(user); - vault.vetoSlash(slashIndex); - vm.stopPrank(); - } - - function _setMaxNetworkResolverLimit(address user, address resolver, uint256 maxNetworkResolverLimit) internal { - vm.startPrank(user); - vault.setMaxNetworkResolverLimit(resolver, maxNetworkResolverLimit); - vm.stopPrank(); - } - - function _optInNetworkVault(address user, address resolver) internal { - vm.startPrank(user); - networkVaultOptInService.optIn(resolver, address(vault)); - vm.stopPrank(); - } - - function _optOutNetworkVault(address user, address resolver) internal { - vm.startPrank(user); - networkVaultOptInService.optOut(resolver, address(vault)); - vm.stopPrank(); - } - - function _optInOperatorVault(address user) internal { - vm.startPrank(user); - operatorVaultOptInService.optIn(address(vault)); - vm.stopPrank(); - } - - function _optOutOperatorVault(address user) internal { - vm.startPrank(user); - operatorVaultOptInService.optOut(address(vault)); - vm.stopPrank(); - } - - function _optInOperatorNetwork(address user, address network) internal { - vm.startPrank(user); - operatorNetworkOptInService.optIn(network); - vm.stopPrank(); - } - - function _optOutOperatorNetwork(address user, address network) internal { - vm.startPrank(user); - operatorNetworkOptInService.optOut(network); - vm.stopPrank(); - } - - function _setNetworkResolverLimit(address user, address network, address resolver, uint256 amount) internal { - vm.startPrank(user); - vault.setNetworkResolverLimit(network, resolver, amount); - vm.stopPrank(); - } - - function _setOperatorNetworkLimit(address user, address operator, address network, uint256 amount) internal { - vm.startPrank(user); - vault.setOperatorNetworkLimit(operator, network, amount); - vm.stopPrank(); - } - - function _setRewardsDistributor(address user, address rewardsDistributor) internal { - vm.startPrank(user); - vault.setRewardsDistributor(rewardsDistributor); - vm.stopPrank(); - } - - function _setAdminFee(address user, uint256 adminFee) internal { - vm.startPrank(user); - vault.setAdminFee(adminFee); - vm.stopPrank(); - } - - function _setDepositWhitelist(address user, bool depositWhitelist) internal { - vm.startPrank(user); - vault.setDepositWhitelist(depositWhitelist); - vm.stopPrank(); - } - - function _setDepositorWhitelistStatus(address user, address depositor, bool status) internal { - vm.startPrank(user); - vault.setDepositorWhitelistStatus(depositor, status); - vm.stopPrank(); - } -} +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// _grantDepositWhitelistSetRole(alice, alice); +// _setDepositWhitelist(alice, true); + +// _grantDepositorWhitelistRole(alice, alice); + +// _setDepositorWhitelistStatus(alice, bob, true); +// assertEq(vault.isDepositorWhitelisted(bob), true); + +// _deposit(bob, 1); + +// _setDepositWhitelist(alice, false); + +// _deposit(bob, 1); +// } + +// function test_SetDepositorWhitelistStatusRevertNoDepositWhitelist() public { +// uint48 epochDuration = 1; +// uint48 executeDuration = 0; +// uint48 vetoDuration = 0; + +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// _grantDepositorWhitelistRole(alice, alice); + +// vm.expectRevert(IVault.NoDepositWhitelist.selector); +// _setDepositorWhitelistStatus(alice, bob, true); +// } + +// function test_SetDepositorWhitelistStatusRevertAlreadySet() public { +// uint48 epochDuration = 1; +// uint48 executeDuration = 0; +// uint48 vetoDuration = 0; + +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// _grantDepositWhitelistSetRole(alice, alice); +// _setDepositWhitelist(alice, true); + +// _grantDepositorWhitelistRole(alice, alice); + +// _setDepositorWhitelistStatus(alice, bob, true); + +// vm.expectRevert(IVault.AlreadySet.selector); +// _setDepositorWhitelistStatus(alice, bob, true); +// } + +// function _getVault(uint48 epochDuration, uint48 vetoDuration, uint48 executeDuration) internal returns (IVault) { +// return IVault( +// vaultFactory.create( +// vaultFactory.lastVersion(), +// alice, +// abi.encode( +// IVault.InitParams({ +// collateral: address(collateral), +// epochDuration: epochDuration, +// vetoDuration: vetoDuration, +// executeDuration: executeDuration, +// rewardsDistributor: address(0), +// adminFee: 0, +// depositWhitelist: false +// }) +// ) +// ) +// ); +// } + +// function _registerOperator(address user) internal { +// vm.startPrank(user); +// operatorRegistry.registerOperator(); +// vm.stopPrank(); +// } + +// function _registerNetwork(address user, address middleware) internal { +// vm.startPrank(user); +// networkRegistry.registerNetwork(); +// networkMiddlewareService.setMiddleware(middleware); +// vm.stopPrank(); +// } + +// function _grantDepositorWhitelistRole(address user, address account) internal { +// vm.startPrank(user); +// Vault(address(vault)).grantRole(vault.DEPOSITOR_WHITELIST_ROLE(), account); +// vm.stopPrank(); +// } + +// function _grantRewardsDistributorSetRole(address user, address account) internal { +// vm.startPrank(user); +// Vault(address(vault)).grantRole(vault.REWARDS_DISTRIBUTOR_SET_ROLE(), account); +// vm.stopPrank(); +// } + +// function _grantAdminFeeSetRole(address user, address account) internal { +// vm.startPrank(user); +// Vault(address(vault)).grantRole(vault.ADMIN_FEE_SET_ROLE(), account); +// vm.stopPrank(); +// } + +// function _grantDepositWhitelistSetRole(address user, address account) internal { +// vm.startPrank(user); +// Vault(address(vault)).grantRole(vault.DEPOSIT_WHITELIST_SET_ROLE(), account); +// vm.stopPrank(); +// } + +// function _deposit(address user, uint256 amount) internal returns (uint256 shares) { +// collateral.transfer(user, amount); +// vm.startPrank(user); +// collateral.approve(address(vault), amount); +// shares = vault.deposit(user, amount); +// vm.stopPrank(); +// } + +// function _withdraw(address user, uint256 amount) internal returns (uint256 burnedShares, uint256 mintedShares) { +// vm.startPrank(user); +// (burnedShares, mintedShares) = vault.withdraw(user, amount); +// vm.stopPrank(); +// } + +// function _claim(address user, uint256 epoch) internal returns (uint256 amount) { +// vm.startPrank(user); +// amount = vault.claim(user, epoch); +// vm.stopPrank(); +// } + +// function _requestSlash( +// address user, +// address network, +// address resolver, +// address operator, +// uint256 amount +// ) internal returns (uint256 slashIndex) { +// vm.startPrank(user); +// slashIndex = vault.requestSlash(network, resolver, operator, amount); +// vm.stopPrank(); +// } + +// function _executeSlash(address user, uint256 slashIndex) internal returns (uint256 slashedAmount) { +// vm.startPrank(user); +// slashedAmount = vault.executeSlash(slashIndex); +// vm.stopPrank(); +// } + +// function _vetoSlash(address user, uint256 slashIndex) internal { +// vm.startPrank(user); +// vault.vetoSlash(slashIndex); +// vm.stopPrank(); +// } + +// function _setMaxNetworkResolverLimit(address user, address resolver, uint256 maxNetworkResolverLimit) internal { +// vm.startPrank(user); +// vault.setMaxNetworkResolverLimit(resolver, maxNetworkResolverLimit); +// vm.stopPrank(); +// } + +// function _optInNetworkVault(address user, address resolver) internal { +// vm.startPrank(user); +// networkVaultOptInService.optIn(resolver, address(vault)); +// vm.stopPrank(); +// } + +// function _optOutNetworkVault(address user, address resolver) internal { +// vm.startPrank(user); +// networkVaultOptInService.optOut(resolver, address(vault)); +// vm.stopPrank(); +// } + +// function _optInOperatorVault(address user) internal { +// vm.startPrank(user); +// operatorVaultOptInService.optIn(address(vault)); +// vm.stopPrank(); +// } + +// function _optOutOperatorVault(address user) internal { +// vm.startPrank(user); +// operatorVaultOptInService.optOut(address(vault)); +// vm.stopPrank(); +// } + +// function _optInOperatorNetwork(address user, address network) internal { +// vm.startPrank(user); +// operatorNetworkOptInService.optIn(network); +// vm.stopPrank(); +// } + +// function _optOutOperatorNetwork(address user, address network) internal { +// vm.startPrank(user); +// operatorNetworkOptInService.optOut(network); +// vm.stopPrank(); +// } + +// function _setNetworkResolverLimit(address user, address network, address resolver, uint256 amount) internal { +// vm.startPrank(user); +// vault.setNetworkResolverLimit(network, resolver, amount); +// vm.stopPrank(); +// } + +// function _setOperatorNetworkLimit(address user, address operator, address network, uint256 amount) internal { +// vm.startPrank(user); +// vault.setOperatorNetworkLimit(operator, network, amount); +// vm.stopPrank(); +// } + +// function _setRewardsDistributor(address user, address rewardsDistributor) internal { +// vm.startPrank(user); +// vault.setRewardsDistributor(rewardsDistributor); +// vm.stopPrank(); +// } + +// function _setAdminFee(address user, uint256 adminFee) internal { +// vm.startPrank(user); +// vault.setAdminFee(adminFee); +// vm.stopPrank(); +// } + +// function _setDepositWhitelist(address user, bool depositWhitelist) internal { +// vm.startPrank(user); +// vault.setDepositWhitelist(depositWhitelist); +// vm.stopPrank(); +// } + +// function _setDepositorWhitelistStatus(address user, address depositor, bool status) internal { +// vm.startPrank(user); +// vault.setDepositorWhitelistStatus(depositor, status); +// vm.stopPrank(); +// } +// } diff --git a/test/defaultRewardsDistributor/DefaultRewardsDistributor.t.sol b/test/defaultRewardsDistributor/DefaultRewardsDistributor.t.sol index 0c2c6cb3..7daf89c5 100644 --- a/test/defaultRewardsDistributor/DefaultRewardsDistributor.t.sol +++ b/test/defaultRewardsDistributor/DefaultRewardsDistributor.t.sol @@ -1,906 +1,906 @@ -// SPDX-License-Identifier: MIT -pragma solidity 0.8.25; - -import {Test, console2} from "forge-std/Test.sol"; - -import {VaultFactory} from "src/contracts/VaultFactory.sol"; -import {NetworkRegistry} from "src/contracts/NetworkRegistry.sol"; -import {OperatorRegistry} from "src/contracts/OperatorRegistry.sol"; -import {MetadataService} from "src/contracts/MetadataService.sol"; -import {NetworkMiddlewareService} from "src/contracts/NetworkMiddlewareService.sol"; -import {NetworkOptInService} from "src/contracts/NetworkOptInService.sol"; -import {OperatorOptInService} from "src/contracts/OperatorOptInService.sol"; - -import {Vault} from "src/contracts/vault/v1/Vault.sol"; -import {IVault} from "src/interfaces/vault/v1/IVault.sol"; - -import {DefaultRewardsDistributorFactory} from - "src/contracts/defaultRewardsDistributor/DefaultRewardsDistributorFactory.sol"; -import {IDefaultRewardsDistributor} from "src/interfaces/defaultRewardsDistributor/IDefaultRewardsDistributor.sol"; - -import {DefaultRewardsDistributor} from "src/contracts/defaultRewardsDistributor/DefaultRewardsDistributor.sol"; - -import {Token} from "test/mocks/Token.sol"; -import {FeeOnTransferToken} from "test/mocks/FeeOnTransferToken.sol"; -import {SimpleCollateral} from "test/mocks/SimpleCollateral.sol"; -import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import {Math} from "@openzeppelin/contracts/utils/math/Math.sol"; - -contract RewardsDistributorTest is Test { - using Math for uint256; - - address owner; - address alice; - uint256 alicePrivateKey; - address bob; - uint256 bobPrivateKey; - - VaultFactory vaultFactory; - NetworkRegistry networkRegistry; - OperatorRegistry operatorRegistry; - MetadataService operatorMetadataService; - MetadataService networkMetadataService; - NetworkMiddlewareService networkMiddlewareService; - NetworkOptInService networkVaultOptInService; - OperatorOptInService operatorVaultOptInService; - OperatorOptInService operatorNetworkOptInService; - - IVault vault; - - DefaultRewardsDistributorFactory defaultRewardsDistributorFactory; - IDefaultRewardsDistributor defaultRewardsDistributor; - - SimpleCollateral collateral; - - function setUp() public { - owner = address(this); - (alice, alicePrivateKey) = makeAddrAndKey("alice"); - (bob, bobPrivateKey) = makeAddrAndKey("bob"); - - vaultFactory = new VaultFactory(owner); - networkRegistry = new NetworkRegistry(); - operatorRegistry = new OperatorRegistry(); - operatorMetadataService = new MetadataService(address(operatorRegistry)); - networkMetadataService = new MetadataService(address(networkRegistry)); - networkMiddlewareService = new NetworkMiddlewareService(address(networkRegistry)); - networkVaultOptInService = new NetworkOptInService(address(networkRegistry), address(vaultFactory)); - operatorVaultOptInService = new OperatorOptInService(address(operatorRegistry), address(vaultFactory)); - operatorNetworkOptInService = new OperatorOptInService(address(operatorRegistry), address(networkRegistry)); - - vaultFactory.whitelist( - address( - new Vault( - address(vaultFactory), - address(networkRegistry), - address(networkMiddlewareService), - address(networkVaultOptInService), - address(operatorVaultOptInService), - address(operatorNetworkOptInService) - ) - ) - ); - - defaultRewardsDistributorFactory = new DefaultRewardsDistributorFactory( - address(networkRegistry), address(vaultFactory), address(networkMiddlewareService) - ); - - Token token = new Token("Token"); - collateral = new SimpleCollateral(address(token)); - - collateral.mint(token.totalSupply()); - } - - function test_Create() public { - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - } - - function test_ReinitRevert() public { - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - - vm.expectRevert(); - DefaultRewardsDistributor(address(defaultRewardsDistributor)).initialize(address(vault)); - } - - function test_SetNetworkWhitelistStatus() public { - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - - address network = bob; - _registerNetwork(network, bob); - - _setNetworkWhitelistStatus(alice, network, true); - assertEq(defaultRewardsDistributor.isNetworkWhitelisted(network), true); - } - - function test_SetNetworkWhitelistStatusRevertNotVaultOwner() public { - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - - address network = bob; - _registerNetwork(network, bob); - - vm.expectRevert(IDefaultRewardsDistributor.NotVaultOwner.selector); - _setNetworkWhitelistStatus(bob, network, true); - } - - function test_SetNetworkWhitelistStatusRevertAlreadySet() public { - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - - address network = bob; - _registerNetwork(network, bob); - - _setNetworkWhitelistStatus(alice, network, true); - - vm.expectRevert(IDefaultRewardsDistributor.AlreadySet.selector); - _setNetworkWhitelistStatus(alice, network, true); - } - - function test_DistributeReward(uint256 amount, uint256 ditributeAmount, uint256 adminFee) public { - amount = bound(amount, 1, 100 * 10 ** 18); - ditributeAmount = bound(ditributeAmount, 2, 100 * 10 ** 18); - - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - adminFee = bound(adminFee, 1, vault.ADMIN_FEE_BASE()); - - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - - _grantAdminFeeSetRole(alice, alice); - _setAdminFee(alice, adminFee); - - address network = bob; - _registerNetwork(network, bob); - - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - - for (uint256 i; i < 10; ++i) { - _deposit(alice, amount); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } - - IERC20 feeOnTransferToken = IERC20(new FeeOnTransferToken("FeeOnTransferToken")); - feeOnTransferToken.transfer(bob, 100_000 * 1e18); - vm.startPrank(bob); - feeOnTransferToken.approve(address(defaultRewardsDistributor), type(uint256).max); - vm.stopPrank(); - - uint256 balanceBefore = feeOnTransferToken.balanceOf(address(defaultRewardsDistributor)); - uint256 balanceBeforeBob = feeOnTransferToken.balanceOf(bob); - _setNetworkWhitelistStatus(alice, network, true); - uint48 timestamp = 3; - _distributeReward(bob, network, address(feeOnTransferToken), ditributeAmount, timestamp); - assertEq(feeOnTransferToken.balanceOf(address(defaultRewardsDistributor)) - balanceBefore, ditributeAmount - 1); - assertEq(balanceBeforeBob - feeOnTransferToken.balanceOf(bob), ditributeAmount); - - assertEq(defaultRewardsDistributor.rewardsLength(address(feeOnTransferToken)), 1); - (address network_, uint256 amount_, uint48 timestamp_, uint48 creation) = - defaultRewardsDistributor.rewards(address(feeOnTransferToken), 0); - assertEq(network_, network); - uint256 amount__ = ditributeAmount - 1; - uint256 adminFeeAmount = amount__.mulDiv(adminFee, vault.ADMIN_FEE_BASE()); - amount__ -= adminFeeAmount; - assertEq(amount_, amount__); - assertEq(timestamp_, timestamp); - assertEq(creation, blockTimestamp); - assertEq(defaultRewardsDistributor.claimableAdminFee(address(feeOnTransferToken)), adminFeeAmount); - } - - function test_DistributeRewardRevertNotNetworkMiddleware(uint256 amount, uint256 ditributeAmount) public { - amount = bound(amount, 1, 100 * 10 ** 18); - ditributeAmount = bound(ditributeAmount, 2, 100 * 10 ** 18); - - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - - address network = bob; - _registerNetwork(network, bob); - - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - - for (uint256 i; i < 10; ++i) { - _deposit(alice, amount); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } - - IERC20 feeOnTransferToken = IERC20(new FeeOnTransferToken("FeeOnTransferToken")); - feeOnTransferToken.transfer(bob, 100_000 * 1e18); - vm.startPrank(bob); - feeOnTransferToken.approve(address(defaultRewardsDistributor), type(uint256).max); - vm.stopPrank(); - - _setNetworkWhitelistStatus(alice, network, true); - uint48 timestamp = 3; - vm.expectRevert(IDefaultRewardsDistributor.NotNetworkMiddleware.selector); - _distributeReward(alice, network, address(feeOnTransferToken), ditributeAmount, timestamp); - } - - function test_DistributeRewardRevertNotWhitelistedNetwork(uint256 amount, uint256 ditributeAmount) public { - amount = bound(amount, 1, 100 * 10 ** 18); - ditributeAmount = bound(ditributeAmount, 2, 100 * 10 ** 18); - - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - - address network = bob; - _registerNetwork(network, bob); - - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - - for (uint256 i; i < 10; ++i) { - _deposit(alice, amount); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } - - IERC20 feeOnTransferToken = IERC20(new FeeOnTransferToken("FeeOnTransferToken")); - feeOnTransferToken.transfer(bob, 100_000 * 1e18); - vm.startPrank(bob); - feeOnTransferToken.approve(address(defaultRewardsDistributor), type(uint256).max); - vm.stopPrank(); - - uint48 timestamp = 3; - vm.expectRevert(IDefaultRewardsDistributor.NotWhitelistedNetwork.selector); - _distributeReward(bob, network, address(feeOnTransferToken), ditributeAmount, timestamp); - } - - function test_DistributeRewardRevertInvalidRewardTimestamp(uint256 amount, uint256 ditributeAmount) public { - amount = bound(amount, 1, 100 * 10 ** 18); - ditributeAmount = bound(ditributeAmount, 2, 100 * 10 ** 18); - - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - - address network = bob; - _registerNetwork(network, bob); - - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - - for (uint256 i; i < 10; ++i) { - _deposit(alice, amount); +// // SPDX-License-Identifier: MIT +// pragma solidity 0.8.25; + +// import {Test, console2} from "forge-std/Test.sol"; + +// import {VaultFactory} from "src/contracts/VaultFactory.sol"; +// import {NetworkRegistry} from "src/contracts/NetworkRegistry.sol"; +// import {OperatorRegistry} from "src/contracts/OperatorRegistry.sol"; +// import {MetadataService} from "src/contracts/MetadataService.sol"; +// import {NetworkMiddlewareService} from "src/contracts/NetworkMiddlewareService.sol"; +// import {NetworkOptInService} from "src/contracts/NetworkOptInService.sol"; +// import {OperatorOptInService} from "src/contracts/OperatorOptInService.sol"; + +// import {Vault} from "src/contracts/vault/v1/Vault.sol"; +// import {IVault} from "src/interfaces/vault/v1/IVault.sol"; + +// import {DefaultRewardsDistributorFactory} from +// "src/contracts/defaultRewardsDistributor/DefaultRewardsDistributorFactory.sol"; +// import {IDefaultRewardsDistributor} from "src/interfaces/defaultRewardsDistributor/IDefaultRewardsDistributor.sol"; + +// import {DefaultRewardsDistributor} from "src/contracts/defaultRewardsDistributor/DefaultRewardsDistributor.sol"; + +// import {Token} from "test/mocks/Token.sol"; +// import {FeeOnTransferToken} from "test/mocks/FeeOnTransferToken.sol"; +// import {SimpleCollateral} from "test/mocks/SimpleCollateral.sol"; +// import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +// import {Math} from "@openzeppelin/contracts/utils/math/Math.sol"; + +// contract RewardsDistributorTest is Test { +// using Math for uint256; + +// address owner; +// address alice; +// uint256 alicePrivateKey; +// address bob; +// uint256 bobPrivateKey; + +// VaultFactory vaultFactory; +// NetworkRegistry networkRegistry; +// OperatorRegistry operatorRegistry; +// MetadataService operatorMetadataService; +// MetadataService networkMetadataService; +// NetworkMiddlewareService networkMiddlewareService; +// NetworkOptInService networkVaultOptInService; +// OperatorOptInService operatorVaultOptInService; +// OperatorOptInService operatorNetworkOptInService; + +// IVault vault; + +// DefaultRewardsDistributorFactory defaultRewardsDistributorFactory; +// IDefaultRewardsDistributor defaultRewardsDistributor; + +// SimpleCollateral collateral; + +// function setUp() public { +// owner = address(this); +// (alice, alicePrivateKey) = makeAddrAndKey("alice"); +// (bob, bobPrivateKey) = makeAddrAndKey("bob"); + +// vaultFactory = new VaultFactory(owner); +// networkRegistry = new NetworkRegistry(); +// operatorRegistry = new OperatorRegistry(); +// operatorMetadataService = new MetadataService(address(operatorRegistry)); +// networkMetadataService = new MetadataService(address(networkRegistry)); +// networkMiddlewareService = new NetworkMiddlewareService(address(networkRegistry)); +// networkVaultOptInService = new NetworkOptInService(address(networkRegistry), address(vaultFactory)); +// operatorVaultOptInService = new OperatorOptInService(address(operatorRegistry), address(vaultFactory)); +// operatorNetworkOptInService = new OperatorOptInService(address(operatorRegistry), address(networkRegistry)); + +// vaultFactory.whitelist( +// address( +// new Vault( +// address(vaultFactory), +// address(networkRegistry), +// address(networkMiddlewareService), +// address(networkVaultOptInService), +// address(operatorVaultOptInService), +// address(operatorNetworkOptInService) +// ) +// ) +// ); + +// defaultRewardsDistributorFactory = new DefaultRewardsDistributorFactory( +// address(networkRegistry), address(vaultFactory), address(networkMiddlewareService) +// ); + +// Token token = new Token("Token"); +// collateral = new SimpleCollateral(address(token)); + +// collateral.mint(token.totalSupply()); +// } + +// function test_Create() public { +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); +// } + +// function test_ReinitRevert() public { +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); + +// vm.expectRevert(); +// DefaultRewardsDistributor(address(defaultRewardsDistributor)).initialize(address(vault)); +// } + +// function test_SetNetworkWhitelistStatus() public { +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); + +// address network = bob; +// _registerNetwork(network, bob); + +// _setNetworkWhitelistStatus(alice, network, true); +// assertEq(defaultRewardsDistributor.isNetworkWhitelisted(network), true); +// } + +// function test_SetNetworkWhitelistStatusRevertNotVaultOwner() public { +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); + +// address network = bob; +// _registerNetwork(network, bob); + +// vm.expectRevert(IDefaultRewardsDistributor.NotVaultOwner.selector); +// _setNetworkWhitelistStatus(bob, network, true); +// } + +// function test_SetNetworkWhitelistStatusRevertAlreadySet() public { +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); + +// address network = bob; +// _registerNetwork(network, bob); + +// _setNetworkWhitelistStatus(alice, network, true); + +// vm.expectRevert(IDefaultRewardsDistributor.AlreadySet.selector); +// _setNetworkWhitelistStatus(alice, network, true); +// } + +// function test_DistributeReward(uint256 amount, uint256 ditributeAmount, uint256 adminFee) public { +// amount = bound(amount, 1, 100 * 10 ** 18); +// ditributeAmount = bound(ditributeAmount, 2, 100 * 10 ** 18); + +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); +// adminFee = bound(adminFee, 1, vault.ADMIN_FEE_BASE()); + +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); + +// _grantAdminFeeSetRole(alice, alice); +// _setAdminFee(alice, adminFee); + +// address network = bob; +// _registerNetwork(network, bob); + +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; + +// for (uint256 i; i < 10; ++i) { +// _deposit(alice, amount); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } + +// IERC20 feeOnTransferToken = IERC20(new FeeOnTransferToken("FeeOnTransferToken")); +// feeOnTransferToken.transfer(bob, 100_000 * 1e18); +// vm.startPrank(bob); +// feeOnTransferToken.approve(address(defaultRewardsDistributor), type(uint256).max); +// vm.stopPrank(); + +// uint256 balanceBefore = feeOnTransferToken.balanceOf(address(defaultRewardsDistributor)); +// uint256 balanceBeforeBob = feeOnTransferToken.balanceOf(bob); +// _setNetworkWhitelistStatus(alice, network, true); +// uint48 timestamp = 3; +// _distributeReward(bob, network, address(feeOnTransferToken), ditributeAmount, timestamp); +// assertEq(feeOnTransferToken.balanceOf(address(defaultRewardsDistributor)) - balanceBefore, ditributeAmount - 1); +// assertEq(balanceBeforeBob - feeOnTransferToken.balanceOf(bob), ditributeAmount); + +// assertEq(defaultRewardsDistributor.rewardsLength(address(feeOnTransferToken)), 1); +// (address network_, uint256 amount_, uint48 timestamp_, uint48 creation) = +// defaultRewardsDistributor.rewards(address(feeOnTransferToken), 0); +// assertEq(network_, network); +// uint256 amount__ = ditributeAmount - 1; +// uint256 adminFeeAmount = amount__.mulDiv(adminFee, vault.ADMIN_FEE_BASE()); +// amount__ -= adminFeeAmount; +// assertEq(amount_, amount__); +// assertEq(timestamp_, timestamp); +// assertEq(creation, blockTimestamp); +// assertEq(defaultRewardsDistributor.claimableAdminFee(address(feeOnTransferToken)), adminFeeAmount); +// } + +// function test_DistributeRewardRevertNotNetworkMiddleware(uint256 amount, uint256 ditributeAmount) public { +// amount = bound(amount, 1, 100 * 10 ** 18); +// ditributeAmount = bound(ditributeAmount, 2, 100 * 10 ** 18); + +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); + +// address network = bob; +// _registerNetwork(network, bob); + +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; + +// for (uint256 i; i < 10; ++i) { +// _deposit(alice, amount); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } + +// IERC20 feeOnTransferToken = IERC20(new FeeOnTransferToken("FeeOnTransferToken")); +// feeOnTransferToken.transfer(bob, 100_000 * 1e18); +// vm.startPrank(bob); +// feeOnTransferToken.approve(address(defaultRewardsDistributor), type(uint256).max); +// vm.stopPrank(); + +// _setNetworkWhitelistStatus(alice, network, true); +// uint48 timestamp = 3; +// vm.expectRevert(IDefaultRewardsDistributor.NotNetworkMiddleware.selector); +// _distributeReward(alice, network, address(feeOnTransferToken), ditributeAmount, timestamp); +// } + +// function test_DistributeRewardRevertNotWhitelistedNetwork(uint256 amount, uint256 ditributeAmount) public { +// amount = bound(amount, 1, 100 * 10 ** 18); +// ditributeAmount = bound(ditributeAmount, 2, 100 * 10 ** 18); + +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); + +// address network = bob; +// _registerNetwork(network, bob); + +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; + +// for (uint256 i; i < 10; ++i) { +// _deposit(alice, amount); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } + +// IERC20 feeOnTransferToken = IERC20(new FeeOnTransferToken("FeeOnTransferToken")); +// feeOnTransferToken.transfer(bob, 100_000 * 1e18); +// vm.startPrank(bob); +// feeOnTransferToken.approve(address(defaultRewardsDistributor), type(uint256).max); +// vm.stopPrank(); + +// uint48 timestamp = 3; +// vm.expectRevert(IDefaultRewardsDistributor.NotWhitelistedNetwork.selector); +// _distributeReward(bob, network, address(feeOnTransferToken), ditributeAmount, timestamp); +// } + +// function test_DistributeRewardRevertInvalidRewardTimestamp(uint256 amount, uint256 ditributeAmount) public { +// amount = bound(amount, 1, 100 * 10 ** 18); +// ditributeAmount = bound(ditributeAmount, 2, 100 * 10 ** 18); + +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); + +// address network = bob; +// _registerNetwork(network, bob); + +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; + +// for (uint256 i; i < 10; ++i) { +// _deposit(alice, amount); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } - IERC20 feeOnTransferToken = IERC20(new FeeOnTransferToken("FeeOnTransferToken")); - feeOnTransferToken.transfer(bob, 100_000 * 1e18); - vm.startPrank(bob); - feeOnTransferToken.approve(address(defaultRewardsDistributor), type(uint256).max); - vm.stopPrank(); +// IERC20 feeOnTransferToken = IERC20(new FeeOnTransferToken("FeeOnTransferToken")); +// feeOnTransferToken.transfer(bob, 100_000 * 1e18); +// vm.startPrank(bob); +// feeOnTransferToken.approve(address(defaultRewardsDistributor), type(uint256).max); +// vm.stopPrank(); - _setNetworkWhitelistStatus(alice, network, true); - vm.expectRevert(IDefaultRewardsDistributor.InvalidRewardTimestamp.selector); - _distributeReward(bob, network, address(feeOnTransferToken), ditributeAmount, uint48(blockTimestamp)); - } +// _setNetworkWhitelistStatus(alice, network, true); +// vm.expectRevert(IDefaultRewardsDistributor.InvalidRewardTimestamp.selector); +// _distributeReward(bob, network, address(feeOnTransferToken), ditributeAmount, uint48(blockTimestamp)); +// } - function test_DistributeRewardRevertInsufficientReward(uint256 amount) public { - amount = bound(amount, 1, 100 * 10 ** 18); +// function test_DistributeRewardRevertInsufficientReward(uint256 amount) public { +// amount = bound(amount, 1, 100 * 10 ** 18); - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - for (uint256 i; i < 10; ++i) { - _deposit(alice, amount); +// for (uint256 i; i < 10; ++i) { +// _deposit(alice, amount); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } - IERC20 feeOnTransferToken = IERC20(new FeeOnTransferToken("FeeOnTransferToken")); - feeOnTransferToken.transfer(bob, 100_000 * 1e18); - vm.startPrank(bob); - feeOnTransferToken.approve(address(defaultRewardsDistributor), type(uint256).max); - vm.stopPrank(); +// IERC20 feeOnTransferToken = IERC20(new FeeOnTransferToken("FeeOnTransferToken")); +// feeOnTransferToken.transfer(bob, 100_000 * 1e18); +// vm.startPrank(bob); +// feeOnTransferToken.approve(address(defaultRewardsDistributor), type(uint256).max); +// vm.stopPrank(); - _setNetworkWhitelistStatus(alice, network, true); - uint48 timestamp = 3; - vm.expectRevert(IDefaultRewardsDistributor.InsufficientReward.selector); - _distributeReward(bob, network, address(feeOnTransferToken), 1, timestamp); - } +// _setNetworkWhitelistStatus(alice, network, true); +// uint48 timestamp = 3; +// vm.expectRevert(IDefaultRewardsDistributor.InsufficientReward.selector); +// _distributeReward(bob, network, address(feeOnTransferToken), 1, timestamp); +// } - function test_ClaimRewards(uint256 amount, uint256 ditributeAmount1, uint256 ditributeAmount2) public { - amount = bound(amount, 1, 100 * 10 ** 18); - ditributeAmount1 = bound(ditributeAmount1, 1, 100 * 10 ** 18); - ditributeAmount2 = bound(ditributeAmount2, 1, 100 * 10 ** 18); +// function test_ClaimRewards(uint256 amount, uint256 ditributeAmount1, uint256 ditributeAmount2) public { +// amount = bound(amount, 1, 100 * 10 ** 18); +// ditributeAmount1 = bound(ditributeAmount1, 1, 100 * 10 ** 18); +// ditributeAmount2 = bound(ditributeAmount2, 1, 100 * 10 ** 18); - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - for (uint256 i; i < 10; ++i) { - _deposit(alice, amount); +// for (uint256 i; i < 10; ++i) { +// _deposit(alice, amount); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } - IERC20 token = IERC20(new Token("Token")); - token.transfer(bob, 100_000 * 1e18); - vm.startPrank(bob); - token.approve(address(defaultRewardsDistributor), type(uint256).max); - vm.stopPrank(); +// IERC20 token = IERC20(new Token("Token")); +// token.transfer(bob, 100_000 * 1e18); +// vm.startPrank(bob); +// token.approve(address(defaultRewardsDistributor), type(uint256).max); +// vm.stopPrank(); - _setNetworkWhitelistStatus(alice, network, true); +// _setNetworkWhitelistStatus(alice, network, true); - _distributeReward(bob, network, address(token), ditributeAmount1, uint48(blockTimestamp - 1)); +// _distributeReward(bob, network, address(token), ditributeAmount1, uint48(blockTimestamp - 1)); - uint48 timestamp = 3; - _distributeReward(bob, network, address(token), ditributeAmount2, timestamp); +// uint48 timestamp = 3; +// _distributeReward(bob, network, address(token), ditributeAmount2, timestamp); - uint256 balanceBefore = token.balanceOf(alice); - uint32[] memory activeSharesOfHints = new uint32[](2); - _claimRewards(alice, address(token), 2, activeSharesOfHints); - assertEq(token.balanceOf(alice) - balanceBefore, ditributeAmount1 + ditributeAmount2); +// uint256 balanceBefore = token.balanceOf(alice); +// uint32[] memory activeSharesOfHints = new uint32[](2); +// _claimRewards(alice, address(token), 2, activeSharesOfHints); +// assertEq(token.balanceOf(alice) - balanceBefore, ditributeAmount1 + ditributeAmount2); - assertEq(defaultRewardsDistributor.lastUnclaimedReward(alice, address(token)), 2); - } +// assertEq(defaultRewardsDistributor.lastUnclaimedReward(alice, address(token)), 2); +// } - function test_ClaimRewardsBoth(uint256 amount, uint256 ditributeAmount1, uint256 ditributeAmount2) public { - amount = bound(amount, 1, 100 * 10 ** 18); - ditributeAmount1 = bound(ditributeAmount1, 1, 100 * 10 ** 18); - ditributeAmount2 = bound(ditributeAmount2, 1, 100 * 10 ** 18); +// function test_ClaimRewardsBoth(uint256 amount, uint256 ditributeAmount1, uint256 ditributeAmount2) public { +// amount = bound(amount, 1, 100 * 10 ** 18); +// ditributeAmount1 = bound(ditributeAmount1, 1, 100 * 10 ** 18); +// ditributeAmount2 = bound(ditributeAmount2, 1, 100 * 10 ** 18); - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - uint256 aliceN = 10; - for (uint256 i; i < aliceN; ++i) { - _deposit(alice, amount); +// uint256 aliceN = 10; +// for (uint256 i; i < aliceN; ++i) { +// _deposit(alice, amount); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } - uint256 bobN = 3; - for (uint256 i; i < bobN; ++i) { - _deposit(bob, amount); +// uint256 bobN = 3; +// for (uint256 i; i < bobN; ++i) { +// _deposit(bob, amount); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } - IERC20 token = IERC20(new Token("Token")); - token.transfer(bob, 100_000 * 1e18); - vm.startPrank(bob); - token.approve(address(defaultRewardsDistributor), type(uint256).max); - vm.stopPrank(); +// IERC20 token = IERC20(new Token("Token")); +// token.transfer(bob, 100_000 * 1e18); +// vm.startPrank(bob); +// token.approve(address(defaultRewardsDistributor), type(uint256).max); +// vm.stopPrank(); - _setNetworkWhitelistStatus(alice, network, true); +// _setNetworkWhitelistStatus(alice, network, true); - _distributeReward(bob, network, address(token), ditributeAmount1, uint48(blockTimestamp - 1)); +// _distributeReward(bob, network, address(token), ditributeAmount1, uint48(blockTimestamp - 1)); - uint48 timestamp = 3; - _distributeReward(bob, network, address(token), ditributeAmount2, timestamp); +// uint48 timestamp = 3; +// _distributeReward(bob, network, address(token), ditributeAmount2, timestamp); - uint256 balanceBefore = token.balanceOf(alice); - uint32[] memory activeSharesOfHints = new uint32[](2); - _claimRewards(alice, address(token), 2, activeSharesOfHints); - assertEq( - token.balanceOf(alice) - balanceBefore, ditributeAmount1.mulDiv(aliceN, aliceN + bobN) + ditributeAmount2 - ); +// uint256 balanceBefore = token.balanceOf(alice); +// uint32[] memory activeSharesOfHints = new uint32[](2); +// _claimRewards(alice, address(token), 2, activeSharesOfHints); +// assertEq( +// token.balanceOf(alice) - balanceBefore, ditributeAmount1.mulDiv(aliceN, aliceN + bobN) + ditributeAmount2 +// ); - balanceBefore = token.balanceOf(bob); - _claimRewards(bob, address(token), 2, activeSharesOfHints); - assertEq(token.balanceOf(bob) - balanceBefore, ditributeAmount1.mulDiv(bobN, aliceN + bobN)); +// balanceBefore = token.balanceOf(bob); +// _claimRewards(bob, address(token), 2, activeSharesOfHints); +// assertEq(token.balanceOf(bob) - balanceBefore, ditributeAmount1.mulDiv(bobN, aliceN + bobN)); - assertEq(defaultRewardsDistributor.lastUnclaimedReward(alice, address(token)), 2); - } +// assertEq(defaultRewardsDistributor.lastUnclaimedReward(alice, address(token)), 2); +// } - function test_ClaimRewardsManyWithoutHints(uint256 amount, uint256 ditributeAmount) public { - amount = bound(amount, 1, 100 * 10 ** 18); - ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); +// function test_ClaimRewardsManyWithoutHints(uint256 amount, uint256 ditributeAmount) public { +// amount = bound(amount, 1, 100 * 10 ** 18); +// ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); - uint48 epochDuration = 1; - uint48 executeDuration = 1; - uint48 vetoDuration = 0; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 1; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 0; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - for (uint256 i; i < 105; ++i) { - _deposit(alice, amount); +// for (uint256 i; i < 105; ++i) { +// _deposit(alice, amount); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } - IERC20 token = IERC20(new Token("Token")); - token.transfer(bob, 100_000 * 1e18); - vm.startPrank(bob); - token.approve(address(defaultRewardsDistributor), type(uint256).max); - vm.stopPrank(); +// IERC20 token = IERC20(new Token("Token")); +// token.transfer(bob, 100_000 * 1e18); +// vm.startPrank(bob); +// token.approve(address(defaultRewardsDistributor), type(uint256).max); +// vm.stopPrank(); - _setNetworkWhitelistStatus(alice, network, true); - uint256 numRewards = 50; - for (uint48 i = 1; i < numRewards + 1; ++i) { - _distributeReward(bob, network, address(token), ditributeAmount, i); - } +// _setNetworkWhitelistStatus(alice, network, true); +// uint256 numRewards = 50; +// for (uint48 i = 1; i < numRewards + 1; ++i) { +// _distributeReward(bob, network, address(token), ditributeAmount, i); +// } - uint32[] memory activeSharesOfHints = new uint32[](0); +// uint32[] memory activeSharesOfHints = new uint32[](0); - uint256 gasLeft = gasleft(); - _claimRewards(alice, address(token), type(uint256).max, activeSharesOfHints); - uint256 gasLeft2 = gasleft(); - console2.log("Gas1", gasLeft - gasLeft2 - 100); - } +// uint256 gasLeft = gasleft(); +// _claimRewards(alice, address(token), type(uint256).max, activeSharesOfHints); +// uint256 gasLeft2 = gasleft(); +// console2.log("Gas1", gasLeft - gasLeft2 - 100); +// } - function test_ClaimRewardsManyWithHints(uint256 amount, uint256 ditributeAmount) public { - amount = bound(amount, 1, 100 * 10 ** 18); - ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); +// function test_ClaimRewardsManyWithHints(uint256 amount, uint256 ditributeAmount) public { +// amount = bound(amount, 1, 100 * 10 ** 18); +// ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); - uint48 epochDuration = 1; - uint48 executeDuration = 1; - uint48 vetoDuration = 0; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 1; +// uint48 executeDuration = 1; +// uint48 vetoDuration = 0; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - for (uint256 i; i < 105; ++i) { - _deposit(alice, amount); +// for (uint256 i; i < 105; ++i) { +// _deposit(alice, amount); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } - IERC20 token = IERC20(new Token("Token")); - token.transfer(bob, 100_000 * 1e18); - vm.startPrank(bob); - token.approve(address(defaultRewardsDistributor), type(uint256).max); - vm.stopPrank(); +// IERC20 token = IERC20(new Token("Token")); +// token.transfer(bob, 100_000 * 1e18); +// vm.startPrank(bob); +// token.approve(address(defaultRewardsDistributor), type(uint256).max); +// vm.stopPrank(); - _setNetworkWhitelistStatus(alice, network, true); - uint256 numRewards = 50; - for (uint48 i = 1; i < numRewards + 1; ++i) { - _distributeReward(bob, network, address(token), ditributeAmount, i); - } +// _setNetworkWhitelistStatus(alice, network, true); +// uint256 numRewards = 50; +// for (uint48 i = 1; i < numRewards + 1; ++i) { +// _distributeReward(bob, network, address(token), ditributeAmount, i); +// } - uint32[] memory activeSharesOfHints = new uint32[](numRewards); - for (uint32 i; i < numRewards; ++i) { - activeSharesOfHints[i] = i; - } +// uint32[] memory activeSharesOfHints = new uint32[](numRewards); +// for (uint32 i; i < numRewards; ++i) { +// activeSharesOfHints[i] = i; +// } - uint256 gasLeft = gasleft(); - _claimRewards(alice, address(token), type(uint256).max, activeSharesOfHints); - uint256 gasLeft2 = gasleft(); - console2.log("Gas2", gasLeft - gasLeft2 - 100); - } +// uint256 gasLeft = gasleft(); +// _claimRewards(alice, address(token), type(uint256).max, activeSharesOfHints); +// uint256 gasLeft2 = gasleft(); +// console2.log("Gas2", gasLeft - gasLeft2 - 100); +// } - function test_ClaimRewardsRevertNoRewardsToClaim1(uint256 amount, uint256 ditributeAmount) public { - amount = bound(amount, 1, 100 * 10 ** 18); - ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); +// function test_ClaimRewardsRevertNoRewardsToClaim1(uint256 amount, uint256 ditributeAmount) public { +// amount = bound(amount, 1, 100 * 10 ** 18); +// ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - for (uint256 i; i < 10; ++i) { - _deposit(alice, amount); +// for (uint256 i; i < 10; ++i) { +// _deposit(alice, amount); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } - IERC20 token = IERC20(new Token("Token")); +// IERC20 token = IERC20(new Token("Token")); - uint32[] memory activeSharesOfHints = new uint32[](1); - vm.expectRevert(IDefaultRewardsDistributor.NoRewardsToClaim.selector); - _claimRewards(alice, address(token), type(uint256).max, activeSharesOfHints); - } +// uint32[] memory activeSharesOfHints = new uint32[](1); +// vm.expectRevert(IDefaultRewardsDistributor.NoRewardsToClaim.selector); +// _claimRewards(alice, address(token), type(uint256).max, activeSharesOfHints); +// } - function test_ClaimRewardsRevertNoRewardsToClaim2(uint256 amount, uint256 ditributeAmount) public { - amount = bound(amount, 1, 100 * 10 ** 18); - ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); +// function test_ClaimRewardsRevertNoRewardsToClaim2(uint256 amount, uint256 ditributeAmount) public { +// amount = bound(amount, 1, 100 * 10 ** 18); +// ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - for (uint256 i; i < 10; ++i) { - _deposit(alice, amount); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } +// for (uint256 i; i < 10; ++i) { +// _deposit(alice, amount); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } - IERC20 token = IERC20(new Token("Token")); +// IERC20 token = IERC20(new Token("Token")); - uint32[] memory activeSharesOfHints = new uint32[](1); - vm.expectRevert(IDefaultRewardsDistributor.NoRewardsToClaim.selector); - _claimRewards(alice, address(token), 0, activeSharesOfHints); - } +// uint32[] memory activeSharesOfHints = new uint32[](1); +// vm.expectRevert(IDefaultRewardsDistributor.NoRewardsToClaim.selector); +// _claimRewards(alice, address(token), 0, activeSharesOfHints); +// } - function test_ClaimRewardsRevertNoDeposits(uint256 amount, uint256 ditributeAmount) public { - amount = bound(amount, 1, 100 * 10 ** 18); - ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); +// function test_ClaimRewardsRevertNoDeposits(uint256 amount, uint256 ditributeAmount) public { +// amount = bound(amount, 1, 100 * 10 ** 18); +// ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - for (uint256 i; i < 10; ++i) { - _deposit(bob, amount); +// for (uint256 i; i < 10; ++i) { +// _deposit(bob, amount); - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } - IERC20 token = IERC20(new Token("Token")); - token.transfer(bob, 100_000 * 1e18); - vm.startPrank(bob); - token.approve(address(defaultRewardsDistributor), type(uint256).max); - vm.stopPrank(); +// IERC20 token = IERC20(new Token("Token")); +// token.transfer(bob, 100_000 * 1e18); +// vm.startPrank(bob); +// token.approve(address(defaultRewardsDistributor), type(uint256).max); +// vm.stopPrank(); - _setNetworkWhitelistStatus(alice, network, true); - uint48 timestamp = 3; - _distributeReward(bob, network, address(token), ditributeAmount, timestamp); - - uint32[] memory activeSharesOfHints = new uint32[](1); - vm.expectRevert(IDefaultRewardsDistributor.NoDeposits.selector); - _claimRewards(alice, address(token), type(uint256).max, activeSharesOfHints); - } - - function test_ClaimRewardsRevertInvalidHintsLength(uint256 amount, uint256 ditributeAmount) public { - amount = bound(amount, 1, 100 * 10 ** 18); - ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); - - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); +// _setNetworkWhitelistStatus(alice, network, true); +// uint48 timestamp = 3; +// _distributeReward(bob, network, address(token), ditributeAmount, timestamp); + +// uint32[] memory activeSharesOfHints = new uint32[](1); +// vm.expectRevert(IDefaultRewardsDistributor.NoDeposits.selector); +// _claimRewards(alice, address(token), type(uint256).max, activeSharesOfHints); +// } + +// function test_ClaimRewardsRevertInvalidHintsLength(uint256 amount, uint256 ditributeAmount) public { +// amount = bound(amount, 1, 100 * 10 ** 18); +// ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); + +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); + +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - address network = bob; - _registerNetwork(network, bob); +// address network = bob; +// _registerNetwork(network, bob); - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - for (uint256 i; i < 10; ++i) { - _deposit(alice, amount); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } - - IERC20 token = IERC20(new Token("Token")); - token.transfer(bob, 100_000 * 1e18); - vm.startPrank(bob); - token.approve(address(defaultRewardsDistributor), type(uint256).max); - vm.stopPrank(); - - _setNetworkWhitelistStatus(alice, network, true); - uint48 timestamp = 3; - _distributeReward(bob, network, address(token), ditributeAmount, timestamp); +// for (uint256 i; i < 10; ++i) { +// _deposit(alice, amount); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } + +// IERC20 token = IERC20(new Token("Token")); +// token.transfer(bob, 100_000 * 1e18); +// vm.startPrank(bob); +// token.approve(address(defaultRewardsDistributor), type(uint256).max); +// vm.stopPrank(); + +// _setNetworkWhitelistStatus(alice, network, true); +// uint48 timestamp = 3; +// _distributeReward(bob, network, address(token), ditributeAmount, timestamp); - uint32[] memory activeSharesOfHints = new uint32[](2); - vm.expectRevert(IDefaultRewardsDistributor.InvalidHintsLength.selector); - _claimRewards(alice, address(token), type(uint256).max, activeSharesOfHints); - } +// uint32[] memory activeSharesOfHints = new uint32[](2); +// vm.expectRevert(IDefaultRewardsDistributor.InvalidHintsLength.selector); +// _claimRewards(alice, address(token), type(uint256).max, activeSharesOfHints); +// } - function test_ClaimAdminFee(uint256 amount, uint256 ditributeAmount, uint256 adminFee) public { - amount = bound(amount, 1, 100 * 10 ** 18); - ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); - - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - adminFee = bound(adminFee, 1, vault.ADMIN_FEE_BASE()); - - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - - _grantAdminFeeSetRole(alice, alice); - _setAdminFee(alice, adminFee); - - address network = bob; - _registerNetwork(network, bob); - - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - - for (uint256 i; i < 10; ++i) { - _deposit(alice, amount); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } - - IERC20 token = IERC20(new Token("Token")); - token.transfer(bob, 100_000 * 1e18); - vm.startPrank(bob); - token.approve(address(defaultRewardsDistributor), type(uint256).max); - vm.stopPrank(); - - _setNetworkWhitelistStatus(alice, network, true); - uint48 timestamp = 3; - _distributeReward(bob, network, address(token), ditributeAmount, timestamp); - - uint256 adminFeeAmount = ditributeAmount.mulDiv(adminFee, vault.ADMIN_FEE_BASE()); - vm.assume(adminFeeAmount != 0); - uint256 balanceBefore = token.balanceOf(address(defaultRewardsDistributor)); - uint256 balanceBeforeAlice = token.balanceOf(alice); - _claimAdminFee(alice, address(token)); - assertEq(balanceBefore - token.balanceOf(address(defaultRewardsDistributor)), adminFeeAmount); - assertEq(token.balanceOf(alice) - balanceBeforeAlice, adminFeeAmount); - assertEq(defaultRewardsDistributor.claimableAdminFee(address(token)), 0); - } - - function test_ClaimAdminFeeRevertInsufficientAdminFee( - uint256 amount, - uint256 ditributeAmount, - uint256 adminFee - ) public { - amount = bound(amount, 1, 100 * 10 ** 18); - ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); - - uint48 epochDuration = 1; - uint48 vetoDuration = 0; - uint48 executeDuration = 1; - vault = _getVault(epochDuration, vetoDuration, executeDuration); - adminFee = bound(adminFee, 1, vault.ADMIN_FEE_BASE()); - - defaultRewardsDistributor = _getDefaultRewardsDistributor(); - _grantRewardsDistributorSetRole(alice, alice); - _setRewardsDistributor(alice, address(defaultRewardsDistributor)); - - _grantAdminFeeSetRole(alice, alice); - _setAdminFee(alice, adminFee); - - address network = bob; - _registerNetwork(network, bob); - - uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; - - for (uint256 i; i < 10; ++i) { - _deposit(alice, amount); - - blockTimestamp = blockTimestamp + 1; - vm.warp(blockTimestamp); - } - - IERC20 token = IERC20(new Token("Token")); - token.transfer(bob, 100_000 * 1e18); - vm.startPrank(bob); - token.approve(address(defaultRewardsDistributor), type(uint256).max); - vm.stopPrank(); - - _setNetworkWhitelistStatus(alice, network, true); - uint48 timestamp = 3; - _distributeReward(bob, network, address(token), ditributeAmount, timestamp); - - vm.assume(defaultRewardsDistributor.claimableAdminFee(address(token)) != 0); - _claimAdminFee(alice, address(token)); - - vm.expectRevert(IDefaultRewardsDistributor.InsufficientAdminFee.selector); - _claimAdminFee(alice, address(token)); - } - - function _getVault(uint48 epochDuration, uint48 vetoDuration, uint48 executeDuration) internal returns (IVault) { - return IVault( - vaultFactory.create( - vaultFactory.lastVersion(), - alice, - abi.encode( - IVault.InitParams({ - collateral: address(collateral), - epochDuration: epochDuration, - vetoDuration: vetoDuration, - executeDuration: executeDuration, - rewardsDistributor: address(0), - adminFee: 0, - depositWhitelist: false - }) - ) - ) - ); - } - - function _getDefaultRewardsDistributor() internal returns (IDefaultRewardsDistributor) { - return IDefaultRewardsDistributor(defaultRewardsDistributorFactory.create(address(vault))); - } - - function _registerNetwork(address user, address middleware) internal { - vm.startPrank(user); - networkRegistry.registerNetwork(); - networkMiddlewareService.setMiddleware(middleware); - vm.stopPrank(); - } - - function _grantRewardsDistributorSetRole(address user, address account) internal { - vm.startPrank(user); - Vault(address(vault)).grantRole(vault.REWARDS_DISTRIBUTOR_SET_ROLE(), account); - vm.stopPrank(); - } - - function _grantAdminFeeSetRole(address user, address account) internal { - vm.startPrank(user); - Vault(address(vault)).grantRole(vault.ADMIN_FEE_SET_ROLE(), account); - vm.stopPrank(); - } - - function _deposit(address user, uint256 amount) internal returns (uint256 shares) { - collateral.transfer(user, amount); - vm.startPrank(user); - collateral.approve(address(vault), amount); - shares = vault.deposit(user, amount); - vm.stopPrank(); - } - - function _setNetworkWhitelistStatus(address user, address network, bool status) internal { - vm.startPrank(user); - defaultRewardsDistributor.setNetworkWhitelistStatus(network, status); - vm.stopPrank(); - } - - function _distributeReward( - address user, - address network, - address token, - uint256 amount, - uint48 timestamp - ) internal { - vm.startPrank(user); - defaultRewardsDistributor.distributeReward(network, token, amount, timestamp); - vm.stopPrank(); - } - - function _claimRewards( - address user, - address token, - uint256 maxRewards, - uint32[] memory activeSharesOfHints - ) internal { - vm.startPrank(user); - defaultRewardsDistributor.claimRewards(user, token, maxRewards, activeSharesOfHints); - vm.stopPrank(); - } - - function _setRewardsDistributor(address user, address rewardsDistributor) internal { - vm.startPrank(user); - vault.setRewardsDistributor(rewardsDistributor); - vm.stopPrank(); - } - - function _setAdminFee(address user, uint256 adminFee) internal { - vm.startPrank(user); - vault.setAdminFee(adminFee); - vm.stopPrank(); - } - - function _claimAdminFee(address user, address token) internal { - vm.startPrank(user); - defaultRewardsDistributor.claimAdminFee(user, token); - vm.stopPrank(); - } -} +// function test_ClaimAdminFee(uint256 amount, uint256 ditributeAmount, uint256 adminFee) public { +// amount = bound(amount, 1, 100 * 10 ** 18); +// ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); + +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); +// adminFee = bound(adminFee, 1, vault.ADMIN_FEE_BASE()); + +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); + +// _grantAdminFeeSetRole(alice, alice); +// _setAdminFee(alice, adminFee); + +// address network = bob; +// _registerNetwork(network, bob); + +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; + +// for (uint256 i; i < 10; ++i) { +// _deposit(alice, amount); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } + +// IERC20 token = IERC20(new Token("Token")); +// token.transfer(bob, 100_000 * 1e18); +// vm.startPrank(bob); +// token.approve(address(defaultRewardsDistributor), type(uint256).max); +// vm.stopPrank(); + +// _setNetworkWhitelistStatus(alice, network, true); +// uint48 timestamp = 3; +// _distributeReward(bob, network, address(token), ditributeAmount, timestamp); + +// uint256 adminFeeAmount = ditributeAmount.mulDiv(adminFee, vault.ADMIN_FEE_BASE()); +// vm.assume(adminFeeAmount != 0); +// uint256 balanceBefore = token.balanceOf(address(defaultRewardsDistributor)); +// uint256 balanceBeforeAlice = token.balanceOf(alice); +// _claimAdminFee(alice, address(token)); +// assertEq(balanceBefore - token.balanceOf(address(defaultRewardsDistributor)), adminFeeAmount); +// assertEq(token.balanceOf(alice) - balanceBeforeAlice, adminFeeAmount); +// assertEq(defaultRewardsDistributor.claimableAdminFee(address(token)), 0); +// } + +// function test_ClaimAdminFeeRevertInsufficientAdminFee( +// uint256 amount, +// uint256 ditributeAmount, +// uint256 adminFee +// ) public { +// amount = bound(amount, 1, 100 * 10 ** 18); +// ditributeAmount = bound(ditributeAmount, 1, 100 * 10 ** 18); + +// uint48 epochDuration = 1; +// uint48 vetoDuration = 0; +// uint48 executeDuration = 1; +// vault = _getVault(epochDuration, vetoDuration, executeDuration); +// adminFee = bound(adminFee, 1, vault.ADMIN_FEE_BASE()); + +// defaultRewardsDistributor = _getDefaultRewardsDistributor(); +// _grantRewardsDistributorSetRole(alice, alice); +// _setRewardsDistributor(alice, address(defaultRewardsDistributor)); + +// _grantAdminFeeSetRole(alice, alice); +// _setAdminFee(alice, adminFee); + +// address network = bob; +// _registerNetwork(network, bob); + +// uint256 blockTimestamp = block.timestamp * block.timestamp / block.timestamp * block.timestamp / block.timestamp; + +// for (uint256 i; i < 10; ++i) { +// _deposit(alice, amount); + +// blockTimestamp = blockTimestamp + 1; +// vm.warp(blockTimestamp); +// } + +// IERC20 token = IERC20(new Token("Token")); +// token.transfer(bob, 100_000 * 1e18); +// vm.startPrank(bob); +// token.approve(address(defaultRewardsDistributor), type(uint256).max); +// vm.stopPrank(); + +// _setNetworkWhitelistStatus(alice, network, true); +// uint48 timestamp = 3; +// _distributeReward(bob, network, address(token), ditributeAmount, timestamp); + +// vm.assume(defaultRewardsDistributor.claimableAdminFee(address(token)) != 0); +// _claimAdminFee(alice, address(token)); + +// vm.expectRevert(IDefaultRewardsDistributor.InsufficientAdminFee.selector); +// _claimAdminFee(alice, address(token)); +// } + +// function _getVault(uint48 epochDuration, uint48 vetoDuration, uint48 executeDuration) internal returns (IVault) { +// return IVault( +// vaultFactory.create( +// vaultFactory.lastVersion(), +// alice, +// abi.encode( +// IVault.InitParams({ +// collateral: address(collateral), +// epochDuration: epochDuration, +// vetoDuration: vetoDuration, +// executeDuration: executeDuration, +// rewardsDistributor: address(0), +// adminFee: 0, +// depositWhitelist: false +// }) +// ) +// ) +// ); +// } + +// function _getDefaultRewardsDistributor() internal returns (IDefaultRewardsDistributor) { +// return IDefaultRewardsDistributor(defaultRewardsDistributorFactory.create(address(vault))); +// } + +// function _registerNetwork(address user, address middleware) internal { +// vm.startPrank(user); +// networkRegistry.registerNetwork(); +// networkMiddlewareService.setMiddleware(middleware); +// vm.stopPrank(); +// } + +// function _grantRewardsDistributorSetRole(address user, address account) internal { +// vm.startPrank(user); +// Vault(address(vault)).grantRole(vault.REWARDS_DISTRIBUTOR_SET_ROLE(), account); +// vm.stopPrank(); +// } + +// function _grantAdminFeeSetRole(address user, address account) internal { +// vm.startPrank(user); +// Vault(address(vault)).grantRole(vault.ADMIN_FEE_SET_ROLE(), account); +// vm.stopPrank(); +// } + +// function _deposit(address user, uint256 amount) internal returns (uint256 shares) { +// collateral.transfer(user, amount); +// vm.startPrank(user); +// collateral.approve(address(vault), amount); +// shares = vault.deposit(user, amount); +// vm.stopPrank(); +// } + +// function _setNetworkWhitelistStatus(address user, address network, bool status) internal { +// vm.startPrank(user); +// defaultRewardsDistributor.setNetworkWhitelistStatus(network, status); +// vm.stopPrank(); +// } + +// function _distributeReward( +// address user, +// address network, +// address token, +// uint256 amount, +// uint48 timestamp +// ) internal { +// vm.startPrank(user); +// defaultRewardsDistributor.distributeReward(network, token, amount, timestamp); +// vm.stopPrank(); +// } + +// function _claimRewards( +// address user, +// address token, +// uint256 maxRewards, +// uint32[] memory activeSharesOfHints +// ) internal { +// vm.startPrank(user); +// defaultRewardsDistributor.claimRewards(user, token, maxRewards, activeSharesOfHints); +// vm.stopPrank(); +// } + +// function _setRewardsDistributor(address user, address rewardsDistributor) internal { +// vm.startPrank(user); +// vault.setRewardsDistributor(rewardsDistributor); +// vm.stopPrank(); +// } + +// function _setAdminFee(address user, uint256 adminFee) internal { +// vm.startPrank(user); +// vault.setAdminFee(adminFee); +// vm.stopPrank(); +// } + +// function _claimAdminFee(address user, address token) internal { +// vm.startPrank(user); +// defaultRewardsDistributor.claimAdminFee(user, token); +// vm.stopPrank(); +// } +// } diff --git a/test/defaultRewardsDistributor/DefaultRewardsDistributorFactory.t.sol b/test/defaultRewardsDistributor/DefaultRewardsDistributorFactory.t.sol index ba4b536b..c12631b9 100644 --- a/test/defaultRewardsDistributor/DefaultRewardsDistributorFactory.t.sol +++ b/test/defaultRewardsDistributor/DefaultRewardsDistributorFactory.t.sol @@ -1,121 +1,121 @@ -// SPDX-License-Identifier: MIT -pragma solidity 0.8.25; - -import {Test, console2} from "forge-std/Test.sol"; - -import {VaultFactory} from "src/contracts/VaultFactory.sol"; -import {NetworkRegistry} from "src/contracts/NetworkRegistry.sol"; -import {OperatorRegistry} from "src/contracts/OperatorRegistry.sol"; -import {MetadataService} from "src/contracts/MetadataService.sol"; -import {NetworkMiddlewareService} from "src/contracts/NetworkMiddlewareService.sol"; -import {NetworkOptInService} from "src/contracts/NetworkOptInService.sol"; -import {OperatorOptInService} from "src/contracts/OperatorOptInService.sol"; - -import {DefaultRewardsDistributorFactory} from - "src/contracts/defaultRewardsDistributor/DefaultRewardsDistributorFactory.sol"; -import {DefaultRewardsDistributor} from "src/contracts/defaultRewardsDistributor/DefaultRewardsDistributor.sol"; -import {IDefaultRewardsDistributor} from "src/interfaces/defaultRewardsDistributor/IDefaultRewardsDistributor.sol"; - -import {Vault} from "src/contracts/vault/v1/Vault.sol"; -import {IVault} from "src/interfaces/vault/v1/IVault.sol"; - -contract DefaultRewardsDistributorFactoryTest is Test { - address owner; - address alice; - uint256 alicePrivateKey; - address bob; - uint256 bobPrivateKey; - - DefaultRewardsDistributorFactory defaultRewardsDistributorFactory; - DefaultRewardsDistributor defaultRewardsDistributor; - - VaultFactory vaultFactory; - NetworkRegistry networkRegistry; - OperatorRegistry operatorRegistry; - MetadataService operatorMetadataService; - MetadataService networkMetadataService; - NetworkMiddlewareService networkMiddlewareService; - NetworkOptInService networkVaultOptInService; - OperatorOptInService operatorVaultOptInService; - OperatorOptInService operatorNetworkOptInService; - - IVault vault; - - function setUp() public { - owner = address(this); - (alice, alicePrivateKey) = makeAddrAndKey("alice"); - (bob, bobPrivateKey) = makeAddrAndKey("bob"); - - vaultFactory = new VaultFactory(owner); - networkRegistry = new NetworkRegistry(); - operatorRegistry = new OperatorRegistry(); - operatorMetadataService = new MetadataService(address(operatorRegistry)); - networkMetadataService = new MetadataService(address(networkRegistry)); - networkMiddlewareService = new NetworkMiddlewareService(address(networkRegistry)); - networkVaultOptInService = new NetworkOptInService(address(networkRegistry), address(vaultFactory)); - operatorVaultOptInService = new OperatorOptInService(address(operatorRegistry), address(vaultFactory)); - operatorNetworkOptInService = new OperatorOptInService(address(operatorRegistry), address(networkRegistry)); - - vaultFactory.whitelist( - address( - new Vault( - address(vaultFactory), - address(networkRegistry), - address(networkMiddlewareService), - address(networkVaultOptInService), - address(operatorVaultOptInService), - address(operatorNetworkOptInService) - ) - ) - ); - - vault = IVault( - vaultFactory.create( - vaultFactory.lastVersion(), - alice, - abi.encode( - IVault.InitParams({ - collateral: address(0), - epochDuration: 1, - vetoDuration: 0, - executeDuration: 0, - rewardsDistributor: address(0), - adminFee: 0, - depositWhitelist: false - }) - ) - ) - ); - } - - function test_Create() public { - defaultRewardsDistributorFactory = new DefaultRewardsDistributorFactory( - address(networkRegistry), address(vaultFactory), address(networkMiddlewareService) - ); - - address defaultRewardsDistributorAddress = defaultRewardsDistributorFactory.create(address(vault)); - defaultRewardsDistributor = DefaultRewardsDistributor(defaultRewardsDistributorAddress); - assertEq(defaultRewardsDistributorFactory.isEntity(defaultRewardsDistributorAddress), true); - - assertEq(defaultRewardsDistributor.NETWORK_REGISTRY(), address(networkRegistry)); - assertEq(defaultRewardsDistributor.VAULT_FACTORY(), address(vaultFactory)); - assertEq(defaultRewardsDistributor.NETWORK_MIDDLEWARE_SERVICE(), address(networkMiddlewareService)); - assertEq(defaultRewardsDistributor.VAULT(), address(vault)); - assertEq(defaultRewardsDistributor.version(), 1); - assertEq(defaultRewardsDistributor.isNetworkWhitelisted(alice), false); - assertEq(defaultRewardsDistributor.rewardsLength(alice), 0); - vm.expectRevert(); - defaultRewardsDistributor.rewards(alice, 0); - assertEq(defaultRewardsDistributor.lastUnclaimedReward(alice, alice), 0); - assertEq(defaultRewardsDistributor.claimableAdminFee(alice), 0); - } - - function test_CreateRevertNotVault() public { - defaultRewardsDistributorFactory = new DefaultRewardsDistributorFactory( - address(networkRegistry), address(vaultFactory), address(networkMiddlewareService) - ); - - vm.expectRevert(IDefaultRewardsDistributor.NotVault.selector); - defaultRewardsDistributorFactory.create(address(0)); - } -} +// // SPDX-License-Identifier: MIT +// pragma solidity 0.8.25; + +// import {Test, console2} from "forge-std/Test.sol"; + +// import {VaultFactory} from "src/contracts/VaultFactory.sol"; +// import {NetworkRegistry} from "src/contracts/NetworkRegistry.sol"; +// import {OperatorRegistry} from "src/contracts/OperatorRegistry.sol"; +// import {MetadataService} from "src/contracts/MetadataService.sol"; +// import {NetworkMiddlewareService} from "src/contracts/NetworkMiddlewareService.sol"; +// import {NetworkOptInService} from "src/contracts/NetworkOptInService.sol"; +// import {OperatorOptInService} from "src/contracts/OperatorOptInService.sol"; + +// import {DefaultRewardsDistributorFactory} from +// "src/contracts/defaultRewardsDistributor/DefaultRewardsDistributorFactory.sol"; +// import {DefaultRewardsDistributor} from "src/contracts/defaultRewardsDistributor/DefaultRewardsDistributor.sol"; +// import {IDefaultRewardsDistributor} from "src/interfaces/defaultRewardsDistributor/IDefaultRewardsDistributor.sol"; + +// import {Vault} from "src/contracts/vault/v1/Vault.sol"; +// import {IVault} from "src/interfaces/vault/v1/IVault.sol"; + +// contract DefaultRewardsDistributorFactoryTest is Test { +// address owner; +// address alice; +// uint256 alicePrivateKey; +// address bob; +// uint256 bobPrivateKey; + +// DefaultRewardsDistributorFactory defaultRewardsDistributorFactory; +// DefaultRewardsDistributor defaultRewardsDistributor; + +// VaultFactory vaultFactory; +// NetworkRegistry networkRegistry; +// OperatorRegistry operatorRegistry; +// MetadataService operatorMetadataService; +// MetadataService networkMetadataService; +// NetworkMiddlewareService networkMiddlewareService; +// NetworkOptInService networkVaultOptInService; +// OperatorOptInService operatorVaultOptInService; +// OperatorOptInService operatorNetworkOptInService; + +// IVault vault; + +// function setUp() public { +// owner = address(this); +// (alice, alicePrivateKey) = makeAddrAndKey("alice"); +// (bob, bobPrivateKey) = makeAddrAndKey("bob"); + +// vaultFactory = new VaultFactory(owner); +// networkRegistry = new NetworkRegistry(); +// operatorRegistry = new OperatorRegistry(); +// operatorMetadataService = new MetadataService(address(operatorRegistry)); +// networkMetadataService = new MetadataService(address(networkRegistry)); +// networkMiddlewareService = new NetworkMiddlewareService(address(networkRegistry)); +// networkVaultOptInService = new NetworkOptInService(address(networkRegistry), address(vaultFactory)); +// operatorVaultOptInService = new OperatorOptInService(address(operatorRegistry), address(vaultFactory)); +// operatorNetworkOptInService = new OperatorOptInService(address(operatorRegistry), address(networkRegistry)); + +// vaultFactory.whitelist( +// address( +// new Vault( +// address(vaultFactory), +// address(networkRegistry), +// address(networkMiddlewareService), +// address(networkVaultOptInService), +// address(operatorVaultOptInService), +// address(operatorNetworkOptInService) +// ) +// ) +// ); + +// vault = IVault( +// vaultFactory.create( +// vaultFactory.lastVersion(), +// alice, +// abi.encode( +// IVault.InitParams({ +// collateral: address(0), +// epochDuration: 1, +// vetoDuration: 0, +// executeDuration: 0, +// rewardsDistributor: address(0), +// adminFee: 0, +// depositWhitelist: false +// }) +// ) +// ) +// ); +// } + +// function test_Create() public { +// defaultRewardsDistributorFactory = new DefaultRewardsDistributorFactory( +// address(networkRegistry), address(vaultFactory), address(networkMiddlewareService) +// ); + +// address defaultRewardsDistributorAddress = defaultRewardsDistributorFactory.create(address(vault)); +// defaultRewardsDistributor = DefaultRewardsDistributor(defaultRewardsDistributorAddress); +// assertEq(defaultRewardsDistributorFactory.isEntity(defaultRewardsDistributorAddress), true); + +// assertEq(defaultRewardsDistributor.NETWORK_REGISTRY(), address(networkRegistry)); +// assertEq(defaultRewardsDistributor.VAULT_FACTORY(), address(vaultFactory)); +// assertEq(defaultRewardsDistributor.NETWORK_MIDDLEWARE_SERVICE(), address(networkMiddlewareService)); +// assertEq(defaultRewardsDistributor.VAULT(), address(vault)); +// assertEq(defaultRewardsDistributor.version(), 1); +// assertEq(defaultRewardsDistributor.isNetworkWhitelisted(alice), false); +// assertEq(defaultRewardsDistributor.rewardsLength(alice), 0); +// vm.expectRevert(); +// defaultRewardsDistributor.rewards(alice, 0); +// assertEq(defaultRewardsDistributor.lastUnclaimedReward(alice, alice), 0); +// assertEq(defaultRewardsDistributor.claimableAdminFee(alice), 0); +// } + +// function test_CreateRevertNotVault() public { +// defaultRewardsDistributorFactory = new DefaultRewardsDistributorFactory( +// address(networkRegistry), address(vaultFactory), address(networkMiddlewareService) +// ); + +// vm.expectRevert(IDefaultRewardsDistributor.NotVault.selector); +// defaultRewardsDistributorFactory.create(address(0)); +// } +// }