Adding fuzz tests with Wake

.gitignore

@@ -35,3 +35,11 @@ docs/
 # MacOS
 .DS_Store
 artifacts/
+
+# Wake files
+.wake
+pytypes
+__pycache__/
+*.py[cod]
+.hypothesis/
+wake-coverage.cov

README.md

@@ -88,7 +88,6 @@ new Factory(locatorAddress, SubFactories({
     stvStETHPoolFactory,
     withdrawalQueueFactory,
     distributorFactory,
-    ggvStrategyFactory,
     timelockFactory
 }))
 ```
@@ -98,7 +97,6 @@ new Factory(locatorAddress, SubFactories({
 // Simplified wrappers
 createPoolStvStart(vaultConfig, timelockConfig, commonPoolConfig, allowlistEnabled)
 createPoolStvStETHStart(vaultConfig, timelockConfig, commonPoolConfig, allowlistEnabled, reserveRatioGapBP)
-createPoolGGVStart(vaultConfig, timelockConfig, commonPoolConfig, reserveRatioGapBP)
 
 // Generic (used by wrappers above)
 createPoolStart(vaultConfig, timelockConfig, commonPoolConfig, auxiliaryConfig, strategyFactory, strategyDeployBytes)
@@ -218,7 +216,6 @@ just -E .env.xxx deploy-factory          # Deploy factory
 just -E .env.xxx deploy-pool-start ...   # Start pool deployment
 just -E .env.xxx deploy-pool-finish ...  # Finish pool deployment  
 just -E .env.xxx deploy-all <env>        # Deploy factory + all pool types
-just -E .env.xxx deploy-ggv-mocks        # Deploy GGV mock contracts
 
 # Testing
 just test-unit                           # Run unit tests (no env needed)

deployments/pool-factory-latest.json

@@ -1,14 +1,14 @@
 {
   "deployment": {
-    "factory": "0x66eb579EA49573F042d694200f0a4cA667B0D9B9",
+    "factory": "0xE9Fe2017febEcb60F9245d72c9D3F45B44e1Bb8C",
     "network": "560048"
   },
   "factories": {
-    "distributorFactory": "0x1ea2E6B3C3A723042A32A565227D5AbBf2359df7",
-    "ggvStrategyFactory": "0xD2d7eA0baacd77aE117Ab1d9D4317830884F2935",
-    "stvPoolFactory": "0x783DBAA9165E4d78453dAB85c64CD19684c12C71",
-    "stvStETHPoolFactory": "0xe95b68E74747dB78e253331Dd121664779465436",
-    "timelockFactory": "0x08ba7d7Ba6a3B99268e0698ae4746FAC4ed93951",
-    "withdrawalQueueFactory": "0xeeb5356160517fd1ca1148540570469eFF430d19"
+    "distributorFactory": "0xD34AD5a37296316E05a4324cd05A92507d407Ca5",
+    "ggvStrategyFactory": "0xd0c45b07B55B8dF7c9631085817e15A7d2602a9B",
+    "stvPoolFactory": "0x910Ad23fC0281B6cD38e004458582Fe0038a5174",
+    "stvStETHPoolFactory": "0xD65D28B54b9BF09bDD500Beee0DE3127c5CaddF1",
+    "timelockFactory": "0x25bd8A5A5dC0AF788DC52d16Bad4E12c0E460a97",
+    "withdrawalQueueFactory": "0xE6A9dfbe4a9f3003BD459ac614F9458d6C5eaaA9"
   }
 }

justfile

@@ -55,14 +55,8 @@ deploy-all env_file:
   just deploy-pool-start $FACTORY "config/${POOL_CONFIG_NAME}"
   just deploy-pool-finish $FACTORY $INTERMEDIATE_JSON
 
-  export POOL_CONFIG_NAME="hoodi-stv-ggv.json"
-  export INTERMEDIATE_JSON="deployments/intermediate-${NOW}-${POOL_CONFIG_NAME}"
-  just deploy-pool-start $FACTORY "config/${POOL_CONFIG_NAME}"
-  just deploy-pool-finish $FACTORY $INTERMEDIATE_JSON
-
 deploy-ggv-mocks:
   forge script script/DeployGGVMocks.s.sol:DeployGGVMocks $(just _script-flags) --gas-limit {{fusaka_tx_gas_limit}} --sig 'run()'
-
 publish-sources address contract_path constructor_args:
   forge verify-contract {{address}} {{contract_path}} \
     --verifier etherscan \
@@ -113,16 +107,13 @@ verify-all:
   FACTORY_CONFIG="config/hoodi-factory.json"
 
   FACTORY=$(jq -r '.deployment.factory' "$DEPLOYMENT_JSON")
-  GGV_STRATEGY_FACTORY=$(jq -r '.factories.ggvStrategyFactory' "$DEPLOYMENT_JSON")
   STV_POOL_FACTORY=$(jq -r '.factories.stvPoolFactory' "$DEPLOYMENT_JSON")
   STV_STETH_POOL_FACTORY=$(jq -r '.factories.stvStETHPoolFactory' "$DEPLOYMENT_JSON")
   WITHDRAWAL_QUEUE_FACTORY=$(jq -r '.factories.withdrawalQueueFactory' "$DEPLOYMENT_JSON")
   TIMELOCK_FACTORY=$(jq -r '.factories.timelockFactory' "$DEPLOYMENT_JSON")
   DISTRIBUTOR_FACTORY=$(jq -r '.factories.distributorFactory' "$DEPLOYMENT_JSON")
 
   LOCATOR=$(jq -r '.lidoLocator' "$FACTORY_CONFIG")
-  TELLER=$(jq -r '.strategies.ggv.teller' "$FACTORY_CONFIG")
-  BORING_QUEUE=$(jq -r '.strategies.ggv.boringOnChainQueue' "$FACTORY_CONFIG")
 
   echo "Verifying contracts..."
   echo "Factory: $FACTORY"
@@ -153,18 +144,12 @@ verify-all:
     --verifier etherscan --rpc-url {{env('RPC_URL')}} --watch -vvvv || echo "Failed to verify DistributorFactory"
 
   echo ""
-  echo "6. Verifying GGVStrategyFactory..."
-  GGV_ARGS=$(cast abi-encode "constructor(address,address)" "$TELLER" "$BORING_QUEUE")
-  forge verify-contract "$GGV_STRATEGY_FACTORY" src/factories/GGVStrategyFactory.sol:GGVStrategyFactory \
-    --verifier etherscan --rpc-url {{env('RPC_URL')}} --constructor-args "$GGV_ARGS" --watch -vvvv || echo "Failed to verify GGVStrategyFactory"
-
-  echo ""
-  echo "7. Verifying Factory..."
+  echo "6. Verifying Factory..."
 
   FACTORY_ARGS=$(cast abi-encode \
-    "constructor(address,(address,address,address,address,address,address))" \
+    "constructor(address,(address,address,address,address,address))" \
     "$LOCATOR" \
-    "($STV_POOL_FACTORY,$STV_STETH_POOL_FACTORY,$WITHDRAWAL_QUEUE_FACTORY,$DISTRIBUTOR_FACTORY,$GGV_STRATEGY_FACTORY,$TIMELOCK_FACTORY)")
+    "($STV_POOL_FACTORY,$STV_STETH_POOL_FACTORY,$WITHDRAWAL_QUEUE_FACTORY,$DISTRIBUTOR_FACTORY,$TIMELOCK_FACTORY)")
   forge verify-contract "$FACTORY" src/Factory.sol:Factory \
     --verifier etherscan --rpc-url {{env('RPC_URL')}} --constructor-args "$FACTORY_ARGS" --watch -vvvv || echo "Failed to verify Factory"
 

script/DeployFactory.s.sol

@@ -6,22 +6,17 @@ import {console2} from "forge-std/console2.sol";
 
 import {Factory} from "src/Factory.sol";
 import {DistributorFactory} from "src/factories/DistributorFactory.sol";
-import {GGVStrategyFactory} from "src/factories/GGVStrategyFactory.sol";
 import {StvPoolFactory} from "src/factories/StvPoolFactory.sol";
 import {StvStETHPoolFactory} from "src/factories/StvStETHPoolFactory.sol";
 import {TimelockFactory} from "src/factories/TimelockFactory.sol";
 import {WithdrawalQueueFactory} from "src/factories/WithdrawalQueueFactory.sol";
 
 contract DeployFactory is Script {
-    function _deployImplFactories(address _ggvTeller, address _ggvBoringQueue)
-        internal
-        returns (Factory.SubFactories memory f)
-    {
+    function _deployImplFactories() internal returns (Factory.SubFactories memory f) {
         f.stvPoolFactory = address(new StvPoolFactory());
         f.stvStETHPoolFactory = address(new StvStETHPoolFactory());
         f.withdrawalQueueFactory = address(new WithdrawalQueueFactory());
         f.distributorFactory = address(new DistributorFactory());
-        f.ggvStrategyFactory = address(new GGVStrategyFactory(_ggvTeller, _ggvBoringQueue));
         f.timelockFactory = address(new TimelockFactory());
     }
 
@@ -36,7 +31,6 @@ contract DeployFactory is Script {
         factoriesSection =
             vm.serializeAddress("factories", "withdrawalQueueFactory", _subFactories.withdrawalQueueFactory);
         factoriesSection = vm.serializeAddress("factories", "distributorFactory", _subFactories.distributorFactory);
-        factoriesSection = vm.serializeAddress("factories", "ggvStrategyFactory", _subFactories.ggvStrategyFactory);
         factoriesSection = vm.serializeAddress("factories", "timelockFactory", _subFactories.timelockFactory);
 
         string memory out = "";
@@ -50,24 +44,16 @@ contract DeployFactory is Script {
         vm.writeJson(json, "deployments/pool-factory-latest.json");
     }
 
-    function _readFactoryConfig(string memory _paramsPath)
-        internal
-        view
-        returns (address locator, address teller, address boringQueue)
-    {
+    function _readFactoryConfig(string memory _paramsPath) internal view returns (address locator) {
         require(
             vm.isFile(_paramsPath),
             string(abi.encodePacked("FACTORY_PARAMS_JSON file does not exist at: ", _paramsPath))
         );
         string memory json = vm.readFile(_paramsPath);
 
         locator = vm.parseJsonAddress(json, "$.lidoLocator");
-        teller = vm.parseJsonAddress(json, "$.strategies.ggv.teller");
-        boringQueue = vm.parseJsonAddress(json, "$.strategies.ggv.boringOnChainQueue");
 
         require(locator != address(0), "lidoLocator missing");
-        require(teller != address(0), "strategies.ggv.teller missing");
-        require(boringQueue != address(0), "strategies.ggv.boringOnChainQueue missing");
     }
 
     function run() external {
@@ -83,12 +69,12 @@ contract DeployFactory is Script {
         );
 
         // Read all factory configuration from JSON file
-        (address locatorAddress, address ggvTeller, address ggvBoringQueue) = _readFactoryConfig(paramsJsonPath);
+        (address locatorAddress) = _readFactoryConfig(paramsJsonPath);
 
         vm.startBroadcast();
 
         // Deploy implementation factories and proxy stub
-        Factory.SubFactories memory subFactories = _deployImplFactories(ggvTeller, ggvBoringQueue);
+        Factory.SubFactories memory subFactories = _deployImplFactories();
 
         Factory factory = new Factory(locatorAddress, subFactories);
 

script/DeployPool.s.sol

@@ -151,7 +151,7 @@ contract DeployPool is Script {
         json = vm.serializeBytes("_ctorBytecode", "withdrawalQueueProxy", withdrawalCtorBytecode);
     }
 
-    function _readPoolParams(string memory _path, address _ggvFactory) internal view returns (PoolParams memory p) {
+    function _readPoolParams(string memory _path) internal view returns (PoolParams memory p) {
         string memory json = vm.readFile(_path);
         p.vaultConfig = Factory.VaultConfig({
             nodeOperator: vm.parseJsonAddress(json, "$.vaultConfig.nodeOperator"),
@@ -184,14 +184,7 @@ contract DeployPool is Script {
 
         try vm.parseJsonAddress(json, "$.strategyFactory") returns (address addr) {
             p.strategyFactory = addr;
-        } catch {
-            string memory strategyFactoryString = vm.parseJsonString(json, "$.strategyFactory");
-            if (keccak256(bytes(strategyFactoryString)) == keccak256(bytes("GGV"))) {
-                p.strategyFactory = _ggvFactory;
-            } else {
-                revert("Invalid strategy factory: must be either address or 'GGV'");
-            }
-        }
+        } catch {}
     }
 
     function _loadIntermediate(string memory _path) internal view returns (Factory.PoolIntermediate memory) {
@@ -270,7 +263,7 @@ contract DeployPool is Script {
 
         require(msg.sender.balance > 1 ether, "msg.sender balance must be above 1 ether");
 
-        PoolParams memory p = _readPoolParams(paramsJsonPath, address(_factory.GGV_STRATEGY_FACTORY()));
+        PoolParams memory p = _readPoolParams(paramsJsonPath);
 
         require(bytes(p.commonPoolConfig.name).length != 0, "commonPoolConfig.name missing");
         require(bytes(p.commonPoolConfig.symbol).length != 0, "commonPoolConfig.symbol missing");

src/Distributor.sol

@@ -37,6 +37,7 @@ contract Distributor is AccessControlEnumerable {
 
     // ==================== Errors ====================
     error AlreadyProcessed();
+    error AlreadySetInThisBlock();
     error InvalidProof();
     error ClaimableTooLow();
     error RootNotSet();
@@ -50,8 +51,6 @@ contract Distributor is AccessControlEnumerable {
      * @param _manager The address of the manager (MANAGER_ROLE)
      */
     constructor(address _owner, address _manager) {
-        lastProcessedBlock = block.number;
-
         _grantRole(DEFAULT_ADMIN_ROLE, _owner);
         _grantRole(MANAGER_ROLE, _manager);
     }
@@ -86,6 +85,7 @@ contract Distributor is AccessControlEnumerable {
     function setMerkleRoot(bytes32 _root, string calldata _cid) external {
         _checkRole(MANAGER_ROLE, msg.sender);
         if (_root == root && keccak256(bytes(_cid)) == keccak256(bytes(cid))) revert AlreadyProcessed();
+        if (block.number == lastProcessedBlock) revert AlreadySetInThisBlock();
 
         emit MerkleRootUpdated(root, _root, cid, _cid, lastProcessedBlock, block.number);
 

src/Factory.sol

@@ -7,7 +7,6 @@ import {StvPool} from "./StvPool.sol";
 import {StvStETHPool} from "./StvStETHPool.sol";
 import {WithdrawalQueue} from "./WithdrawalQueue.sol";
 import {DistributorFactory} from "./factories/DistributorFactory.sol";
-import {GGVStrategyFactory} from "./factories/GGVStrategyFactory.sol";
 import {StvPoolFactory} from "./factories/StvPoolFactory.sol";
 import {StvStETHPoolFactory} from "./factories/StvStETHPoolFactory.sol";
 import {TimelockFactory} from "./factories/TimelockFactory.sol";
@@ -38,15 +37,13 @@ contract Factory {
      * @param stvStETHPoolFactory Factory for deploying StvStETHPool implementations
      * @param withdrawalQueueFactory Factory for deploying WithdrawalQueue implementations
      * @param distributorFactory Factory for deploying Distributor implementations
-     * @param ggvStrategyFactory Factory for deploying GGV strategy implementations
      * @param timelockFactory Factory for deploying Timelock controllers
      */
     struct SubFactories {
         address stvPoolFactory;
         address stvStETHPoolFactory;
         address withdrawalQueueFactory;
         address distributorFactory;
-        address ggvStrategyFactory;
         address timelockFactory;
     }
 
@@ -81,6 +78,7 @@ contract Factory {
      * @param minWithdrawalDelayTime Minimum delay time for processing withdrawals
      * @param name ERC20 token name for the pool shares
      * @param symbol ERC20 token symbol for the pool shares
+     * @param emergencyCommittee Address of the emergency committee
      */
     struct CommonPoolConfig {
         uint256 minWithdrawalDelayTime;
@@ -117,7 +115,9 @@ contract Factory {
      * @notice Intermediate state returned by deployment start functions
      * @param dashboard Address of the deployed dashboard
      * @param poolProxy Address of the deployed pool proxy (not yet initialized)
+     * @param poolImpl Address of the deployed pool implementation (not yet initialized)
      * @param withdrawalQueueProxy Address of the deployed withdrawal queue proxy (not yet initialized)
+     * @param wqImpl Address of the deployed withdrawal queue implementation (not yet initialized)
      * @param timelock Address of the deployed timelock controller
      */
     struct PoolIntermediate {
@@ -280,11 +280,6 @@ contract Factory {
      */
     DistributorFactory public immutable DISTRIBUTOR_FACTORY;
 
-    /**
-     * @notice Factory for deploying GGV strategy implementations
-     */
-    GGVStrategyFactory public immutable GGV_STRATEGY_FACTORY;
-
     /**
      * @notice Factory for deploying Timelock controllers
      */
@@ -300,11 +295,6 @@ contract Factory {
      */
     bytes32 public immutable DEFAULT_ADMIN_ROLE = 0x00;
 
-    /**
-     * @notice Total basis points constant (100.00%)
-     */
-    uint256 public constant TOTAL_BASIS_POINTS = 100_00;
-
     /**
      * @notice Maximum time allowed between start and finish deployment phases
      */
@@ -342,7 +332,6 @@ contract Factory {
         STV_STETH_POOL_FACTORY = StvStETHPoolFactory(_subFactories.stvStETHPoolFactory);
         WITHDRAWAL_QUEUE_FACTORY = WithdrawalQueueFactory(_subFactories.withdrawalQueueFactory);
         DISTRIBUTOR_FACTORY = DistributorFactory(_subFactories.distributorFactory);
-        GGV_STRATEGY_FACTORY = GGVStrategyFactory(_subFactories.ggvStrategyFactory);
         TIMELOCK_FACTORY = TimelockFactory(_subFactories.timelockFactory);
 
         DUMMY_IMPLEMENTATION = address(new DummyImplementation());
@@ -409,33 +398,6 @@ contract Factory {
             createPoolStart(_vaultConfig, _timelockConfig, _commonPoolConfig, _auxiliaryPoolConfig, address(0), "");
     }
 
-    /**
-     * @notice Initiates deployment of a GGV strategy pool (first phase)
-     * @param _vaultConfig Configuration for the vault
-     * @param _timelockConfig Configuration for the timelock controller
-     * @param _commonPoolConfig Common pool parameters (name, symbol, withdrawal delay)
-     * @param _reserveRatioGapBP Maximum allowed reserve ratio gap in basis points
-     * @return intermediate Deployment state needed for finish phase
-     * @dev ETH for vault connection deposit should be sent in createPoolFinish
-     * @dev Automatically enables allowlist and minting for GGV pools
-     */
-    function createPoolGGVStart(
-        VaultConfig memory _vaultConfig,
-        TimelockConfig memory _timelockConfig,
-        CommonPoolConfig memory _commonPoolConfig,
-        uint256 _reserveRatioGapBP
-    ) external returns (PoolIntermediate memory intermediate) {
-        AuxiliaryPoolConfig memory auxiliaryConfig = AuxiliaryPoolConfig({
-            allowListEnabled: true,
-            allowListManager: address(0),
-            mintingEnabled: true,
-            reserveRatioGapBP: _reserveRatioGapBP
-        });
-        intermediate = createPoolStart(
-            _vaultConfig, _timelockConfig, _commonPoolConfig, auxiliaryConfig, address(GGV_STRATEGY_FACTORY), ""
-        );
-    }
-
     /**
      * @notice Generic pool deployment start function (first phase)
      * @param _vaultConfig Configuration for the vault
@@ -472,6 +434,14 @@ contract Factory {
             }
         }
 
+        // Validate proposer and executor addresses
+        if (_timelockConfig.proposer == address(0)) {
+            revert InvalidConfiguration("proposer must not be zero address");
+        }
+        if (_timelockConfig.executor == address(0)) {
+            revert InvalidConfiguration("executor must not be zero address");
+        }
+
         address timelock = TIMELOCK_FACTORY.deploy(
             _timelockConfig.minDelaySeconds, _timelockConfig.proposer, _timelockConfig.executor
         );
@@ -753,7 +723,7 @@ contract Factory {
         address _strategyFactory,
         bytes memory _strategyDeployBytes,
         PoolIntermediate memory _intermediate
-    ) public pure returns (bytes32 result) {
+    ) internal pure returns (bytes32 result) {
         result = keccak256(
             abi.encode(
                 _sender,