feat: factory skeleton

.github/codecov.yaml

@@ -9,3 +9,6 @@ coverage:
   status:
     project: off
     patch: off
+ignore: # exclude these folders from the report
+    - "script"
+    - "test"

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

@@ -13,39 +13,14 @@ import "@balancer-v2/interfaces/contracts/pool-stable/StablePoolUserData.sol";
 
 import {KeeperCompatibleInterface} from "@chainlink/automation/interfaces/KeeperCompatibleInterface.sol";
 
+import {VirtualModule} from "./types/DataTypes.sol";
+
 /// @title RoboSaver: turn your Gnosis Pay card into an automated savings account!
 /// @author onchainification.xyz
 /// @notice Deposit and withdraw $EURe from your Gnosis Pay card to a liquidity pool
 contract RoboSaverVirtualModule is
     KeeperCompatibleInterface // 1 inherited component
 {
-    /*//////////////////////////////////////////////////////////////////////////
-                                     DATA TYPES
-    //////////////////////////////////////////////////////////////////////////*/
-
-    /// @notice Enum representing the different types of pool actions
-    /// @custom:value0 WITHDRAW Withdraw $EURe from the pool to the card
-    /// @custom:value1 DEPOSIT Deposit $EURe from the card into the pool
-    /// @custom:value2 CLOSE Close the pool position by withdrawing all to $EURe
-    /// @custom:value3 EXEC_QUEUE_POOL_ACTION Execute the queued pool action
-    enum PoolAction {
-        WITHDRAW,
-        DEPOSIT,
-        CLOSE,
-        EXEC_QUEUE_POOL_ACTION
-    }
-
-    /// @notice Struct representing the data needed to execute a queued transaction
-    /// @dev Nonce allows us to determine if the transaction queued originated from this virtual module
-    /// @param nonce The nonce of the queued transaction
-    /// @param target The address of the target contract
-    /// @param payload The payload of the transaction to be executed on the target contract
-    struct QueuedTx {
-        uint256 nonce;
-        address target;
-        bytes payload;
-    }
-
     /*//////////////////////////////////////////////////////////////////////////
                                    CONSTANTS
     //////////////////////////////////////////////////////////////////////////*/
@@ -68,10 +43,11 @@ contract RoboSaverVirtualModule is
 
     IComposableStablePool immutable BPT_STEUR_EURE;
 
+    address public immutable FACTORY;
+
     /*//////////////////////////////////////////////////////////////////////////
                                    PUBLIC STORAGE
     //////////////////////////////////////////////////////////////////////////*/
-
     IDelayModifier public delayModule;
     IRolesModifier public rolesModule;
 
@@ -80,7 +56,7 @@ contract RoboSaverVirtualModule is
     uint16 public slippage;
 
     /// @dev Keeps track of the transaction queued up by the virtual module and allows internally to call `executeNextTx`
-    QueuedTx public queuedTx;
+    VirtualModule.QueuedTx public queuedTx;
 
     /*//////////////////////////////////////////////////////////////////////////
                                   PRIVATE STORAGE
@@ -149,6 +125,7 @@ contract RoboSaverVirtualModule is
 
     error NotKeeper(address agent);
     error NotAdmin(address agent);
+    error NeitherAdminNorFactory(address agent);
 
     error ZeroAddressValue();
     error ZeroUintValue();
@@ -174,15 +151,24 @@ contract RoboSaverVirtualModule is
         _;
     }
 
+    /// @notice Enforce that the function is called by the admin or the factory only
+    modifier onlyAdminOrFactory() {
+        if (msg.sender != CARD && msg.sender != FACTORY) revert NeitherAdminNorFactory(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;
-        slippage = _slippage;
+
+        _setBuffer(_buffer);
+        _setSlippage(_slippage);
 
         CARD = delayModule.avatar();
 
@@ -223,7 +209,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 onlyAdminOrFactory {
         if (_keeper == address(0)) revert ZeroAddressValue();
 
         address oldKeeper = keeper;
@@ -235,23 +221,13 @@ contract RoboSaverVirtualModule is
     /// @notice Assigns a new value for the buffer responsible for deciding when there is a surplus
     /// @param _buffer The value of the new buffer
     function setBuffer(uint256 _buffer) external onlyAdmin {
-        if (_buffer == 0) revert ZeroUintValue();
-
-        uint256 oldBuffer = buffer;
-        buffer = _buffer;
-
-        emit SetBuffer(msg.sender, oldBuffer, buffer);
+        _setBuffer(_buffer);
     }
 
     /// @notice Adjust the maximum slippage the user is comfortable with
     /// @param _slippage The value of the new slippage in bps (so 10_000 is 100%)
     function setSlippage(uint16 _slippage) external onlyAdmin {
-        if (_slippage >= MAX_BPS) revert TooHighBps();
-
-        uint16 oldSlippage = slippage;
-        slippage = _slippage;
-
-        emit SetSlippage(msg.sender, oldSlippage, slippage);
+        _setSlippage(_slippage);
     }
 
     /// @notice Check if there is a surplus or deficit of $EURe on the card
@@ -275,7 +251,7 @@ contract RoboSaverVirtualModule is
         if (queuedTx.nonce != 0) {
             /// @notice check if the transaction is still in cooldown or ready to exec
             if (_isInCoolDown(queuedTx.nonce)) return (false, bytes("Internal transaction in cooldown status"));
-            return (true, abi.encode(PoolAction.EXEC_QUEUE_POOL_ACTION, 0));
+            return (true, abi.encode(VirtualModule.PoolAction.EXEC_QUEUE_POOL_ACTION, 0));
         }
 
         uint256 balance = EURE.balanceOf(CARD);
@@ -290,14 +266,14 @@ contract RoboSaverVirtualModule is
             uint256 deficit = dailyAllowance - balance + buffer;
             uint256 withdrawableEure = bptBalance * BPT_STEUR_EURE.getRate() * (MAX_BPS - slippage) / 1e18 / MAX_BPS;
             if (withdrawableEure < deficit) {
-                return (true, abi.encode(PoolAction.CLOSE, withdrawableEure));
+                return (true, abi.encode(VirtualModule.PoolAction.CLOSE, withdrawableEure));
             } else {
-                return (true, abi.encode(PoolAction.WITHDRAW, deficit));
+                return (true, abi.encode(VirtualModule.PoolAction.WITHDRAW, deficit));
             }
         } else if (balance > dailyAllowance + buffer) {
             /// @notice there is a surplus; we need to deposit into the pool
             uint256 surplus = balance - (dailyAllowance + buffer);
-            return (true, abi.encode(PoolAction.DEPOSIT, surplus));
+            return (true, abi.encode(VirtualModule.PoolAction.DEPOSIT, surplus));
         }
 
         /// @notice neither deficit nor surplus; no action needed
@@ -306,7 +282,8 @@ contract RoboSaverVirtualModule is
 
     function performUpkeep(bytes calldata _performData) external override onlyKeeper {
         // decode `_performData`
-        (PoolAction action, uint256 amount) = abi.decode(_performData, (PoolAction, uint256));
+        (VirtualModule.PoolAction action, uint256 amount) =
+            abi.decode(_performData, (VirtualModule.PoolAction, uint256));
         _adjustPool(action, amount);
     }
 
@@ -317,18 +294,18 @@ contract RoboSaverVirtualModule is
     /// @notice Adjust the pool by depositing or withdrawing $EURe
     /// @param _action The action to take: deposit or withdraw
     /// @param _amount The amount of $EURe to deposit or withdraw
-    function _adjustPool(PoolAction _action, uint256 _amount) internal {
+    function _adjustPool(VirtualModule.PoolAction _action, uint256 _amount) internal {
         if (!delayModule.isModuleEnabled(address(this))) revert VirtualModuleNotEnabled();
         if (_isCleanQueueRequired()) delayModule.skipExpired();
         if (_isExternalTxQueued()) revert ExternalTxIsQueued();
 
-        if (_action == PoolAction.WITHDRAW) {
+        if (_action == VirtualModule.PoolAction.WITHDRAW) {
             _poolWithdrawal(_amount);
-        } else if (_action == PoolAction.DEPOSIT) {
+        } else if (_action == VirtualModule.PoolAction.DEPOSIT) {
             _poolDeposit(_amount);
-        } else if (_action == PoolAction.CLOSE) {
+        } else if (_action == VirtualModule.PoolAction.CLOSE) {
             _poolClose(_amount);
-        } else if (_action == PoolAction.EXEC_QUEUE_POOL_ACTION) {
+        } else if (_action == VirtualModule.PoolAction.EXEC_QUEUE_POOL_ACTION) {
             _executeQueuedTx();
         }
     }
@@ -449,7 +426,7 @@ contract RoboSaverVirtualModule is
             : IDelayModifier.DelayModuleOperation.Call;
         delayModule.execTransactionFromModule(_target, 0, _payload, operation);
         uint256 cachedQueueNonce = delayModule.queueNonce();
-        queuedTx = QueuedTx(cachedQueueNonce, _target, _payload);
+        queuedTx = VirtualModule.QueuedTx(cachedQueueNonce, _target, _payload);
 
         emit AdjustPoolTxDataQueued(_target, _payload, cachedQueueNonce);
     }
@@ -473,4 +450,22 @@ contract RoboSaverVirtualModule is
             anyExpiredTxs_ = true;
         }
     }
+
+    function _setSlippage(uint16 _slippage) internal {
+        if (_slippage >= MAX_BPS) revert TooHighBps();
+
+        uint16 oldSlippage = slippage;
+        slippage = _slippage;
+
+        emit SetSlippage(msg.sender, oldSlippage, slippage);
+    }
+
+    function _setBuffer(uint256 _buffer) internal {
+        if (_buffer == 0) revert ZeroUintValue();
+
+        uint256 oldBuffer = buffer;
+        buffer = _buffer;
+
+        emit SetBuffer(msg.sender, oldBuffer, buffer);
+    }
 }