feat: factory skeleton

.github/workflows/foundry.yml

@@ -47,7 +47,7 @@ jobs:
           forge build
       - name: Run Forge tests
         run: |
-          forge coverage --report lcov -vvv
+          forge test && forge coverage --report lcov -vvv
       - name: Upload coverage report to Codecov
         uses: "codecov/codecov-action@v4"
         with:

script/GnosisPayInfraDeployment.s.sol

@@ -8,13 +8,15 @@ import {Delay} from "@delay-module/Delay.sol";
 import {Roles} from "@roles-module/Roles.sol";
 import {Bouncer} from "@gnosispay-kit/Bouncer.sol";
 
+import {RoboSaverVirtualModuleFactory} from "../src/RoboSaverVirtualModuleFactory.sol";
 import {RoboSaverVirtualModule} from "../src/RoboSaverVirtualModule.sol";
 
 /// @notice Deploys a setup mirroring GnosisPay infrastructure components and RoboSaverVirtualModule, in the following order:
 /// 1. {RolesModule}
 /// 2. {DelayModule}
 /// 3. {Bouncer}
-/// 4. {RoboSaverVirtualModule}
+/// 4. {RoboSaverVirtualModuleFactory}
+/// 5. {RoboSaverVirtualModule}
 contract GnosisPayInfraDeployment is Script {
     // safe target
     address constant GNOSIS_SAFE = 0xa4A4a4879dCD3289312884e9eC74Ed37f9a92a55;
@@ -43,7 +45,8 @@ contract GnosisPayInfraDeployment is Script {
 
     Bouncer bouncerContract;
 
-    // robosaver module
+    // robosaver module & factory
+    RoboSaverVirtualModuleFactory roboModuleFactory;
     RoboSaverVirtualModule roboModule;
 
     function run() public {
@@ -61,10 +64,15 @@ contract GnosisPayInfraDeployment is Script {
         // 3. {Bouncer}
         bouncerContract = new Bouncer(GNOSIS_SAFE, address(rolesModule), SET_ALLOWANCE_SELECTOR);
 
-        // 4. {RoboSaverVirtualModule}
-        roboModule = new RoboSaverVirtualModule(address(delayModule), address(rolesModule), 50e18, 200);
+        // 4. {RoboSaverVirtualModuleFactory}
+        roboModuleFactory = new RoboSaverVirtualModuleFactory();
 
-        // 5. {Allowance config}
+        // 5. {RoboSaverVirtualModule}
+        roboModule = new RoboSaverVirtualModule(
+            address(roboModuleFactory), address(delayModule), address(rolesModule), 50e18, 200
+        );
+
+        // 6. {Allowance config}
         rolesModule.setAllowance(
             SET_ALLOWANCE_KEY,
             MIN_EURE_ALLOWANCE,

src/RoboSaverVirtualModule.sol

@@ -71,6 +71,7 @@ contract RoboSaverVirtualModule is
     /*//////////////////////////////////////////////////////////////////////////
                                    PUBLIC STORAGE
     //////////////////////////////////////////////////////////////////////////*/
+    address factory;
 
     IDelayModifier public delayModule;
     IRolesModifier public rolesModule;
@@ -149,6 +150,7 @@ contract RoboSaverVirtualModule is
 
     error NotKeeper(address agent);
     error NotAdmin(address agent);
+    error NorAdminNeitherFactory(address agent);
 
     error ZeroAddressValue();
     error ZeroUintValue();
@@ -174,11 +176,18 @@ contract RoboSaverVirtualModule is
         _;
     }
 
+    /// @notice Enforce that the function is called by the admin or the factory only
+    modifier onlyAdminAndFactory() {
+        if (msg.sender != CARD && msg.sender != factory) revert NorAdminNeitherFactory(msg.sender);
+        _;
+    }
+
     /*//////////////////////////////////////////////////////////////////////////
                                      CONSTRUCTOR
     //////////////////////////////////////////////////////////////////////////*/
 
-    constructor(address _delayModule, address _rolesModule, uint256 _buffer, uint16 _slippage) {
+    constructor(address _factory, address _delayModule, address _rolesModule, uint256 _buffer, uint16 _slippage) {
+        factory = _factory;
         delayModule = IDelayModifier(_delayModule);
         rolesModule = IRolesModifier(_rolesModule);
         buffer = _buffer;
@@ -223,7 +232,7 @@ contract RoboSaverVirtualModule is
 
     /// @notice Assigns a new keeper address
     /// @param _keeper The address of the new keeper
-    function setKeeper(address _keeper) external onlyAdmin {
+    function setKeeper(address _keeper) external onlyAdminAndFactory {
         if (_keeper == address(0)) revert ZeroAddressValue();
 
         address oldKeeper = keeper;

src/RoboSaverVirtualModuleFactory.sol

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.25;
+
+import {IERC20} from "@chainlink/vendor/openzeppelin-solidity/v4.8.3/contracts/token/ERC20/IERC20.sol";
+import {IKeeperRegistryMaster} from "@chainlink/automation/interfaces/v2_1/IKeeperRegistryMaster.sol";
+import {IKeeperRegistrar} from "./interfaces/chainlink/IKeeperRegistrar.sol";
+
+import {RoboSaverVirtualModule} from "./RoboSaverVirtualModule.sol";
+
+contract RoboSaverVirtualModuleFactory {
+    /*//////////////////////////////////////////////////////////////////////////
+                                     DATA TYPES
+    //////////////////////////////////////////////////////////////////////////*/
+    struct VirtualModuleDetails {
+        address virtualModuleAddress;
+        uint256 upkeepId;
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                   CONSTANTS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    IERC20 constant LINK = IERC20(0xE2e73A1c69ecF83F464EFCE6A5be353a37cA09b2);
+    IKeeperRegistryMaster constant CL_REGISTRY = IKeeperRegistryMaster(0x299c92a219F61a82E91d2062A262f7157F155AC1);
+    IKeeperRegistrar constant CL_REGISTRAR = IKeeperRegistrar(0x0F7E163446AAb41DB5375AbdeE2c3eCC56D9aA32);
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                   PUBLIC STORAGE
+    //////////////////////////////////////////////////////////////////////////*/
+
+    // card -> (module address, upkeep id)
+    mapping(address => VirtualModuleDetails) public virtualModules;
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                       EVENTS
+    //////////////////////////////////////////////////////////////////////////*/
+    event RoboSaverVirtualModuleCreated(address virtualModule, address card, uint256 upkeepId, uint256 timestamp);
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                       ERRORS
+    //////////////////////////////////////////////////////////////////////////*/
+    error UpkeepZero();
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                     CONSTRUCTOR
+    //////////////////////////////////////////////////////////////////////////*/
+
+    constructor() {
+        LINK.approve(address(CL_REGISTRAR), type(uint256).max);
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                  EXTERNAL METHODS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @notice Creates a virtual module for a card
+    /// @param _delayModule The address of the delay module
+    /// @param _roleModule The address of the role module
+    /// @param _buffer The buffer for the virtual module (configurable)
+    /// @param _slippage The slippage for the virtual module (configurable)
+    function createVirtualModule(address _delayModule, address _roleModule, uint256 _buffer, uint16 _slippage)
+        external
+    {
+        // @todo sanity checks on the inputs!
+
+        // uses `CARD` address has to helps pre-determining the address of the virtual module given the salt
+        address virtualModule = address(
+            new RoboSaverVirtualModule{salt: keccak256(abi.encodePacked(msg.sender))}(
+                address(this), _delayModule, _roleModule, _buffer, _slippage
+            )
+        );
+
+        uint256 upkeepId = _registerRoboSaverVirtualModule(virtualModule);
+
+        // extracts forwarder address & sets keeper
+        address keeper = CL_REGISTRY.getForwarder(upkeepId);
+        RoboSaverVirtualModule(virtualModule).setKeeper(keeper);
+
+        emit RoboSaverVirtualModuleCreated(virtualModule, msg.sender, upkeepId, block.timestamp);
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                   INTERNAL METHODS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @notice Registers the virtual module in the Chainlink Keeper Registry
+    /// @param _virtualModule The address of the virtual module to be registered
+    function _registerRoboSaverVirtualModule(address _virtualModule) internal returns (uint256 upkeepId_) {
+        IKeeperRegistrar.RegistrationParams memory registrationParams = IKeeperRegistrar.RegistrationParams({
+            name: string.concat(RoboSaverVirtualModule(_virtualModule).name(), "-", _addressToString(msg.sender)),
+            encryptedEmail: "",
+            upkeepContract: _virtualModule,
+            gasLimit: 2_000_000, // @todo optimise from the gas logs the right value. perhaps we are overshooting
+            adminAddress: address(this), // @note the factory is the admin
+            triggerType: 0,
+            checkData: "",
+            triggerConfig: "",
+            offchainConfig: "",
+            amount: 200e18 // @note dummy value for now
+        });
+
+        upkeepId_ = CL_REGISTRAR.registerUpkeep(registrationParams);
+        if (upkeepId_ == 0) revert UpkeepZero();
+
+        virtualModules[msg.sender] = VirtualModuleDetails({virtualModuleAddress: _virtualModule, upkeepId: upkeepId_});
+    }
+
+    /// @notice Converts an address to a string
+    function _addressToString(address _addr) internal pure returns (string memory) {
+        bytes32 value = bytes32(uint256(uint160(_addr)));
+        bytes memory alphabet = "0123456789abcdef";
+
+        bytes memory str = new bytes(42);
+        str[0] = "0";
+        str[1] = "x";
+
+        for (uint256 i = 0; i < 20; i++) {
+            str[2 + i * 2] = alphabet[uint8(value[i + 12] >> 4)];
+            str[3 + i * 2] = alphabet[uint8(value[i + 12] & 0x0f)];
+        }
+
+        return string(str);
+    }
+}

test/BaseFixture.sol

@@ -16,6 +16,7 @@ import "@balancer-v2/interfaces/contracts/pool-stable/StablePoolUserData.sol";
 import {IKeeperRegistryMaster} from "@chainlink/automation/interfaces/v2_1/IKeeperRegistryMaster.sol";
 import {IKeeperRegistrar} from "../src/interfaces/chainlink/IKeeperRegistrar.sol";
 
+import {RoboSaverVirtualModuleFactory} from "../src/RoboSaverVirtualModuleFactory.sol";
 import {RoboSaverVirtualModule} from "../src/RoboSaverVirtualModule.sol";
 
 import {ISafeProxyFactory} from "@gnosispay-kit/interfaces/ISafeProxyFactory.sol";
@@ -80,7 +81,8 @@ contract BaseFixture is Test {
 
     ISafe safe;
 
-    // robosaver module
+    // robosaver module & factory
+    RoboSaverVirtualModuleFactory roboModuleFactory;
     RoboSaverVirtualModule roboModule;
 
     // Keeper address (forwarder): https://docs.chain.link/chainlink-automation/guides/forwarder#securing-your-upkeep
@@ -113,40 +115,27 @@ contract BaseFixture is Test {
 
         bouncerContract = new Bouncer(address(safe), address(rolesModule), SET_ALLOWANCE_SELECTOR);
 
-        roboModule = new RoboSaverVirtualModule(address(delayModule), address(rolesModule), EURE_BUFFER, SLIPPAGE);
+        roboModuleFactory = new RoboSaverVirtualModuleFactory();
+        // fund the factory with LINK for task top up
+        deal(LINK, address(roboModuleFactory), LINK_FOR_TASK_TOP_UP);
 
         // enable robo module in the delay & gnosis safe for tests flow
         vm.startPrank(address(safe));
 
+        // create from factory new robo virtual module
+        roboModuleFactory.createVirtualModule(address(delayModule), address(delayModule), EURE_BUFFER, SLIPPAGE);
+        (address roboModuleAddress, uint256 upkeepId) = roboModuleFactory.virtualModules(address(safe));
+
+        roboModule = RoboSaverVirtualModule(roboModuleAddress);
+        // deduct keeper from the registry and factory upkeep id rerieved from factory storage
+        keeper = CL_REGISTRY.getForwarder(upkeepId);
+
         delayModule.enableModule(address(roboModule));
         delayModule.enableModule(address(safe));
 
         safe.enableModule(address(delayModule));
         safe.enableModule(address(rolesModule));
 
-        // registering the task in CL automation service
-        deal(LINK, address(safe), LINK_FOR_TASK_TOP_UP);
-        IERC20(LINK).approve(address(CL_REGISTRAR), LINK_FOR_TASK_TOP_UP);
-
-        IKeeperRegistrar.RegistrationParams memory registrationParams = IKeeperRegistrar.RegistrationParams({
-            name: string.concat(roboModule.name(), "-", _addressToString(address(safe))),
-            encryptedEmail: "",
-            upkeepContract: address(roboModule),
-            gasLimit: 2_000_000,
-            adminAddress: address(safe),
-            triggerType: 0,
-            checkData: "",
-            triggerConfig: "",
-            offchainConfig: "",
-            amount: LINK_FOR_TASK_TOP_UP
-        });
-
-        uint256 upkeepID = CL_REGISTRAR.registerUpkeep(registrationParams);
-        assertNotEq(upkeepID, 0);
-
-        keeper = CL_REGISTRY.getForwarder(upkeepID);
-        roboModule.setKeeper(keeper);
-
         vm.stopPrank();
 
         vm.prank(SAFE_EOA_SIGNER);
@@ -171,15 +160,23 @@ contract BaseFixture is Test {
 
         deal(BPT_STEUR_EURE, address(safe), EURE_TO_MINT);
 
+        _labelKeyContracts();
+    }
+
+    /// @dev Labels key contracts for tracing
+    function _labelKeyContracts() internal {
         vm.label(EURE, "EURE");
         vm.label(WETH, "WETH");
+        vm.label(LINK, "LINK");
         vm.label(address(safe), "GNOSIS_SAFE");
         vm.label(address(delayModule), "DELAY_MODULE");
         vm.label(address(bouncerContract), "BOUNCER_CONTRACT");
         vm.label(address(rolesModule), "ROLES_MODULE");
         vm.label(address(roboModule), "ROBO_MODULE");
         vm.label(BPT_STEUR_EURE, "BPT_STEUR_EURE");
         vm.label(address(roboModule.BALANCER_VAULT()), "BALANCER_VAULT");
+        vm.label(address(CL_REGISTRY), "CL_REGISTRY");
+        vm.label(address(CL_REGISTRAR), "CL_REGISTRAR");
     }
 
     function _addressToString(address _addr) internal pure returns (string memory) {