feat: Immutable Vault & Revenue Splitter added to aTokenVaultFactory

remappings.txt

@@ -3,8 +3,9 @@
 ds-test/=lib/solmate/lib/ds-test/src/
 erc4626-tests/=lib/erc4626-tests/
 forge-std/=lib/forge-std/src/
-solmate/=lib/solmate/src/
+@solmate/=lib/solmate/src/
 @openzeppelin-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/
 @openzeppelin-v5/=lib/openzeppelin-contracts-v5.3.0/contracts
 @openzeppelin/=lib/openzeppelin-contracts/contracts
 @pcaversaccio/createx/=lib/createx/src/
+@solady/=lib/createx/lib/solady/src/

script/DeployFactory.s.sol

@@ -73,23 +73,11 @@ contract DeployFactory is Script {
 
         vm.startBroadcast();
 
-
-        /////// Deploy Renounced ProxyAdmin
-
-        console.log("Deploying vault's renounced proxy admin");
-
-        address renouncedProxyAdmin = address(new ProxyAdmin());
-
-        console.log("Renounced proxy admin deployed at: ", renouncedProxyAdmin);
-
-        ProxyAdmin(renouncedProxyAdmin).renounceOwnership();
-
-
         /////// Deploy aTokenVaultFactory Implementation (pass Renounced ProxyAdmin as argument)
 
         console.log("Deploying aTokenVaultFactory implementation...");
 
-        ATokenVaultFactory factoryImplementation = new ATokenVaultFactory({proxyAdmin: renouncedProxyAdmin});
+        ATokenVaultFactory factoryImplementation = new ATokenVaultFactory();
 
         console.log("aTokenVaultFactory implementation deployed at: ", address(factoryImplementation));
 

script/DeployFactoryImplementation.s.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.10;
+
+import "forge-std/Script.sol";
+import {ATokenVaultFactory} from "../src/ATokenVaultFactory.sol";
+
+/**
+ * @title DeployFactoryImplementation
+ * @author Aave Labs
+ * @notice Script to deploy the aTokenVaultFactory contract implementation
+ * @dev Run the script with the following command first:
+ * 
+ *      forge script script/DeployFactoryImplementation.s.sol:DeployFactoryImplementation -vvvv --rpc-url {$RPC_URL} --account ${ACCOUNT} --slow 
+ *  
+ * If succeeds, then add the --broadcast flag in order to send the transaction to the network.
+ */
+contract DeployFactoryImplementation is Script {
+
+    function run() external {
+
+        console.log("BlockNumber: ", block.number);
+
+        console.log("ChainId: ", block.chainid);
+
+        vm.startBroadcast();
+
+        console.log("Deploying aTokenVaultFactory implementation...");
+
+        ATokenVaultFactory factoryImplementation = new ATokenVaultFactory();
+
+        console.log("aTokenVaultFactory implementation deployed at: ", address(factoryImplementation));
+
+        vm.stopBroadcast();
+    }
+}

src/ATokenVaultFactory.sol

@@ -5,30 +5,26 @@ pragma solidity ^0.8.10;
 
 import {IERC20} from "@openzeppelin/interfaces/IERC20.sol";
 import {IPoolAddressesProvider} from "@aave-v3-core/interfaces/IPoolAddressesProvider.sol";
-import {TransparentUpgradeableProxy} from "@openzeppelin/proxy/transparent/TransparentUpgradeableProxy.sol";
-import {ATokenVault} from "./ATokenVault.sol";
 import {SafeERC20} from "@openzeppelin/token/ERC20/utils/SafeERC20.sol";
-import {ProxyAdmin} from "@openzeppelin/proxy/transparent/ProxyAdmin.sol";
+import {ATokenVaultRevenueSplitterOwner} from "./ATokenVaultRevenueSplitterOwner.sol";
+import {ImmutableATokenVault} from "./ImmutableATokenVault.sol";
+import {SSTORE2} from "@solmate/utils/SSTORE2.sol";
+import {Create2} from "@openzeppelin/utils/Create2.sol";
+import {LibZip} from "@solady/utils/LibZip.sol";
 
 /**
- * @title ATokenVaultImplDeploymentLib
- * @author Aave Labs
- * @notice Library that handles the deployment of the ATokenVault implementation contract
- * @dev This library is a helper to avoid holding the ATokenVault bytecode in the factory contract avoiding exceeding
- *      the contract size limit.
+ * @dev Struct containing constructor parameters for vault deployment
  */
-library ATokenVaultImplDeploymentLib {
-    function deployVaultImpl(
-        address underlying,
-        uint16 referralCode,
-        IPoolAddressesProvider poolAddressesProvider
-    ) external returns (address vault) {
-        return address(new ATokenVault(
-            underlying,
-            referralCode,
-            poolAddressesProvider
-        ));
-    }
+struct VaultParams {
+    address underlying;
+    uint16 referralCode;
+    IPoolAddressesProvider poolAddressesProvider;
+    address owner;
+    uint256 initialFee;
+    string shareName;
+    string shareSymbol;
+    uint256 initialLockDeposit;
+    ATokenVaultRevenueSplitterOwner.Recipient[] revenueRecipients;
 }
 
 /**
@@ -39,75 +35,48 @@ library ATokenVaultImplDeploymentLib {
 contract ATokenVaultFactory {
     using SafeERC20 for IERC20;
 
-    /*//////////////////////////////////////////////////////////////
-                                 EVENTS
-    //////////////////////////////////////////////////////////////*/
-
     /**
      * @dev Emitted when a new vault is deployed
-     * @param vault The address of the deployed vault proxy
-     * @param implementation The address of the vault implementation
+     * @param vault The address of the deployed vault
      * @param underlying The underlying asset address
      * @param deployer The address that deployed the vault
      * @param params The parameters used to deploy the vault
      */
     event VaultDeployed(
         address indexed vault,
-        address indexed implementation,
         address indexed underlying,
         address deployer,
         VaultParams params
     );
 
-    /*//////////////////////////////////////////////////////////////
-                               CONSTANTS
-    //////////////////////////////////////////////////////////////*/
-
-    /// @notice Proxy admin address for all deployed vaults, with renounced ownership.
-    /// @dev Future version will deploy a plain immutable vault without proxy.
-    address internal immutable RENOUNCED_PROXY_ADMIN;
-
-    /*//////////////////////////////////////////////////////////////
-                                STRUCTS
-    //////////////////////////////////////////////////////////////*/
-
     /**
-     * @dev Struct containing constructor parameters for vault deployment
+     * @dev Emitted when a new revenue splitter owner is deployed
+     * @param revenueSplitterOwner The address of the deployed revenue splitter owner
+     * @param vault The address of the vault to split the revenue from
+     * @param owner The address of the owner of the revenue splitter, effective owner of the vault
+     * @param revenueRecipients The recipients of the revenue
      */
-    struct VaultParams {
-        address underlying;
-        uint16 referralCode;
-        IPoolAddressesProvider poolAddressesProvider;
-        address owner;
-        uint256 initialFee;
-        string shareName;
-        string shareSymbol;
-        uint256 initialLockDeposit;
-    }
+    event RevenueSplitterOwnerDeployed(
+        address indexed revenueSplitterOwner,
+        address indexed vault,
+        address indexed owner,
+        ATokenVaultRevenueSplitterOwner.Recipient[] revenueRecipients
+    );
 
-    /*//////////////////////////////////////////////////////////////
-                               CONSTRUCTOR
-    //////////////////////////////////////////////////////////////*/
+    address immutable public VAULT_CREATION_CODE_SSTORE2_POINTER;
 
-    /**
-     * @dev Constructor
-     * @param proxyAdmin The address that will be the admin of all deployed proxies. Must have renounced ownership.
-     */
-    constructor(address proxyAdmin) {
-        RENOUNCED_PROXY_ADMIN = proxyAdmin;
-        require(ProxyAdmin(proxyAdmin).owner() == address(0), "PROXY_ADMIN_OWNERSHIP_NOT_RENOUNCED");
-    }
+    uint256 internal _nextSaltNonce;
 
-    /*//////////////////////////////////////////////////////////////
-                            EXTERNAL FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
+    constructor() {
+        VAULT_CREATION_CODE_SSTORE2_POINTER = SSTORE2.write(LibZip.flzCompress(type(ImmutableATokenVault).creationCode));
+    }
 
     /**
-     * @notice Deploy a new ATokenVault with the given parameters
+     * @notice Deploys a new ATokenVault with the given parameters
      * @param params All parameters needed for vault deployment and initialization
      * @return vault The address of the deployed vault proxy
      */
-    function deployVault(VaultParams memory params) public returns (address vault) {
+    function deployVault(VaultParams memory params) public returns (address) {
         require(params.underlying != address(0), "ZERO_ADDRESS_NOT_VALID");
         require(address(params.poolAddressesProvider) != address(0), "ZERO_ADDRESS_NOT_VALID");
         require(params.owner != address(0), "ZERO_ADDRESS_NOT_VALID");
@@ -121,34 +90,84 @@ contract ATokenVaultFactory {
             params.initialLockDeposit
         );
 
-        address implementation = ATokenVaultImplDeploymentLib.deployVaultImpl(
-            params.underlying,
-            params.referralCode,
-            params.poolAddressesProvider
+        bytes32 salt = bytes32(_nextSaltNonce++);
+
+        bytes memory vaultInitCode = abi.encodePacked(
+            LibZip.flzDecompress(SSTORE2.read(VAULT_CREATION_CODE_SSTORE2_POINTER)),
+            abi.encode(
+                params.underlying,
+                params.referralCode,
+                params.poolAddressesProvider,
+                address(this),
+                params.initialFee,
+                params.shareName,
+                params.shareSymbol,
+                params.initialLockDeposit
+            )
         );
 
-        vault = address(new TransparentUpgradeableProxy(
-            implementation,
-            RENOUNCED_PROXY_ADMIN,
-            ""
-        ));
+        address vaultAddress = _computeVaultAddress(vaultInitCode, salt);
 
-        IERC20(params.underlying).safeApprove(vault, params.initialLockDeposit);
+        IERC20(params.underlying).safeApprove(vaultAddress, params.initialLockDeposit);
 
-        ATokenVault(vault).initialize(
-            params.owner,
-            params.initialFee,
-            params.shareName,
-            params.shareSymbol,
-            params.initialLockDeposit
-        );
+        _deployVault(vaultInitCode, salt);
+
+        address owner = params.owner;
+        if (params.revenueRecipients.length > 0) {
+            owner = _deployRevenueSplitterOwner(vaultAddress, params.owner, params.revenueRecipients);
+        }
+        ImmutableATokenVault(vaultAddress).transferOwnership(owner);
 
         emit VaultDeployed(
-            vault,
-            implementation,
+            vaultAddress,
             params.underlying,
             msg.sender,
             params
         );
+
+        return vaultAddress;
+    }
+
+    /**
+     * @notice Deploys a new ATokenVaultRevenueSplitterOwner with the given parameters
+     * @param vaultAddress The address of the vault to split the revenue from
+     * @param owner The address of the owner of the revenue splitter, effective owner of the vault
+     * @param revenueRecipients The recipients of the revenue
+     * @return revenueSplitter The address of the deployed revenue splitter
+     */
+    function deployRevenueSplitterOwner(
+        address vaultAddress,
+        address owner,
+        ATokenVaultRevenueSplitterOwner.Recipient[] memory revenueRecipients
+    ) external returns (address) {
+        return _deployRevenueSplitterOwner(vaultAddress, owner, revenueRecipients);
+    }
+
+    function _deployRevenueSplitterOwner(
+        address vaultAddress,
+        address owner,
+        ATokenVaultRevenueSplitterOwner.Recipient[] memory revenueRecipients
+    ) internal returns (address) {
+        address revenueSplitter = address(new ATokenVaultRevenueSplitterOwner(vaultAddress, owner, revenueRecipients));
+        emit RevenueSplitterOwnerDeployed(revenueSplitter, vaultAddress, owner, revenueRecipients);
+        return revenueSplitter;
+    }
+
+    function _computeVaultAddress(bytes memory vaultInitCode, bytes32 salt) internal view returns (address) {
+        return Create2.computeAddress(salt, keccak256(vaultInitCode));
+    }
+
+    function _deployVault(bytes memory vaultInitCode, bytes32 salt) internal returns (address) {
+        address vaultAddress;
+        assembly {
+            vaultAddress := create2(0, add(vaultInitCode, 32), mload(vaultInitCode), salt)
+            // If the deployment fails, revert bubbling up the error
+            if iszero(vaultAddress) {
+                let returnDataSize := returndatasize()
+                returndatacopy(0, 0, returnDataSize)
+                revert(0, returnDataSize)
+            }
+        }
+        return vaultAddress;
     }
 }