Feat/airlock (WIP)

remappings.txt

@@ -1,15 +1,13 @@
 v4-core/=lib/v4-periphery/lib/v4-core/
 solady/=lib/solady/src/
 @ensdomains/=lib/v4-core/node_modules/@ensdomains/
-@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/
-@openzeppelin/contracts/=lib/v4-core/lib/openzeppelin-contracts/contracts/
+@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/contracts/
 @uniswap/v4-core/=lib/v4-periphery/lib/v4-core/
 ds-test/=lib/v4-core/lib/forge-std/lib/ds-test/src/
 erc4626-tests/=lib/v4-core/lib/openzeppelin-contracts/lib/erc4626-tests/
 forge-gas-snapshot/=lib/v4-core/lib/forge-gas-snapshot/src/
 forge-std/=lib/forge-std/src/
 hardhat/=lib/v4-core/node_modules/hardhat/
-openzeppelin-contracts/=lib/v4-core/lib/openzeppelin-contracts/
 permit2/=lib/v4-periphery/lib/permit2/
 solmate/=lib/v4-core/lib/solmate/
 v4-periphery/=lib/v4-periphery/

src/Airlock.sol

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {IPoolManager, PoolKey, Currency, IHooks, TickMath} from "v4-core/src/PoolManager.sol";
+import {Ownable} from "@openzeppelin/access/Ownable.sol";
+import {ERC20} from "@openzeppelin/token/ERC20/ERC20.sol";
+import {ITokenFactory} from "src/interfaces/ITokenFactory.sol";
+import {IGovernanceFactory} from "src/interfaces/IGovernanceFactory.sol";
+import {IHookFactory} from "src/interfaces/IHookFactory.sol";
+
+enum FactoryState {
+    NotWhitelisted,
+    TokenFactory,
+    GovernanceFactory,
+    HookFactory
+}
+
+error WrongFactoryState();
+
+struct TokenData {
+    address governance;
+    address hook;
+    address[] recipients;
+    uint256[] amounts;
+}
+
+event Create(address asset, address indexed numeraire, address governance, address hook);
+
+contract Airlock is Ownable {
+    IPoolManager public immutable poolManager;
+
+    mapping(address => FactoryState) public getFactoryState;
+    mapping(address token => TokenData) public getTokenData;
+
+    constructor(IPoolManager poolManager_) Ownable(msg.sender) {
+        poolManager = poolManager_;
+    }
+
+    /**
+     * TODO:
+     * - Creating a token should incur fees (platform and frontend fees)
+     *
+     * @param tokenFactory Address of the factory contract deploying the ERC20 token
+     * @param governanceFactory Address of the factory contract deploying the governance
+     * @param hookFactory Address of the factory contract deploying the Uniswap v4 hook
+     */
+    function create(
+        string memory name,
+        string memory symbol,
+        uint256 initialSupply,
+        uint256 minimumProceeds,
+        uint256 maximumProceeds,
+        uint256 startingTime,
+        uint256 endingTime,
+        int24 minTick,
+        int24 maxTick,
+        uint256 epochLength,
+        int24 gamma,
+        address numeraire,
+        address owner,
+        address tokenFactory,
+        bytes memory tokenData,
+        address governanceFactory,
+        bytes memory governanceData,
+        address hookFactory,
+        bytes memory hookData,
+        address[] memory recipients,
+        uint256[] memory amounts
+    ) external returns (address, address, address) {
+        require(getFactoryState[tokenFactory] == FactoryState.TokenFactory, WrongFactoryState());
+        require(getFactoryState[governanceFactory] == FactoryState.GovernanceFactory, WrongFactoryState());
+        require(getFactoryState[hookFactory] == FactoryState.HookFactory, WrongFactoryState());
+
+        address token =
+            ITokenFactory(tokenFactory).create(name, symbol, initialSupply, address(this), address(this), tokenData);
+
+        bool isToken0 = token < numeraire ? true : false;
+
+        // FIXME: We might want to double compare the minted / predicted addresses?
+        (address predictedHook, bytes32 salt) = IHookFactory(hookFactory).predict(
+            poolManager,
+            initialSupply,
+            minimumProceeds,
+            maximumProceeds,
+            startingTime,
+            endingTime,
+            isToken0 ? minTick : maxTick,
+            isToken0 ? maxTick : minTick,
+            epochLength,
+            gamma,
+            isToken0,
+            hookData
+        );
+        address hook = IHookFactory(hookFactory).create(
+            poolManager,
+            initialSupply,
+            minimumProceeds,
+            maximumProceeds,
+            startingTime,
+            endingTime,
+            isToken0 ? minTick : maxTick,
+            isToken0 ? maxTick : minTick,
+            epochLength,
+            gamma,
+            isToken0,
+            hookData,
+            salt
+        );
+        ERC20(token).transfer(hook, initialSupply);
+
+        (address governance, address timeLock) =
+            IGovernanceFactory(governanceFactory).create(name, token, governanceData);
+        // FIXME: I think the Timelock should be the owner of the token contract?
+        Ownable(token).transferOwnership(timeLock);
+
+        getTokenData[token] = TokenData({governance: governance, hook: hook, recipients: recipients, amounts: amounts});
+
+        PoolKey memory key = PoolKey({
+            currency0: Currency.wrap(isToken0 ? token : numeraire),
+            currency1: Currency.wrap(isToken0 ? numeraire : token),
+            fee: 0, // TODO: Do we want users to have the ability to set the fee?
+            tickSpacing: 60, // TODO: Do we want users to have the ability to set the tickSpacing?
+            hooks: IHooks(hook)
+        });
+
+        poolManager.initialize(key, TickMath.getSqrtPriceAtTick(isToken0 ? minTick : maxTick), new bytes(0));
+
+        return (token, governance, hook);
+    }
+
+    /**
+     * TODO: This function will be callable later by the hook contract itself, in order to move the liquidity
+     * from the Uniswap v4 pool to a v2 pool. The flow would be something like:
+     * 1) Enough tokens were sold to trigger the migration
+     * 2) Hook contract will remove its positions
+     */
+    function migrate() external {}
+
+    function setFactoryState(address factory, FactoryState state) external onlyOwner {
+        getFactoryState[factory] = state;
+    }
+}

src/DERC20.sol

@@ -0,0 +1,50 @@
+/// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {ERC20} from "@openzeppelin/token/ERC20/ERC20.sol";
+import {ERC20Votes} from "@openzeppelin/token/ERC20/extensions/ERC20Votes.sol";
+import {EIP712} from "@openzeppelin/utils/cryptography/EIP712.sol";
+import {Ownable} from "@openzeppelin/access/Ownable.sol";
+import {ERC20Permit} from "@openzeppelin/token/ERC20/extensions/ERC20Permit.sol";
+import {Nonces} from "@openzeppelin/utils/Nonces.sol";
+
+/**
+ * TODO:
+ * - Add mint cap: bounded annual max inflation which can only go down
+ */
+error MintingNotStartedYet();
+
+contract DERC20 is ERC20Votes, ERC20Permit, Ownable {
+    uint256 public immutable mintStartDate;
+    uint256 public immutable yearlyMintCap;
+
+    constructor(string memory name_, string memory symbol_, uint256 totalSupply_, address recipient, address owner_)
+        ERC20(name_, symbol_)
+        ERC20Permit(name_)
+        Ownable(owner_)
+    {
+        _mint(recipient, totalSupply_);
+        mintStartDate = block.timestamp + 365 days;
+    }
+
+    function mint(address to, uint256 value) external onlyOwner {
+        require(block.timestamp >= mintStartDate, MintingNotStartedYet());
+        _mint(to, value);
+    }
+
+    function clock() public view override returns (uint48) {
+        return uint48(block.timestamp);
+    }
+
+    function CLOCK_MODE() public pure override returns (string memory) {
+        return "mode=timestamp";
+    }
+
+    function nonces(address owner) public view virtual override(ERC20Permit, Nonces) returns (uint256) {
+        return super.nonces(owner);
+    }
+
+    function _update(address from, address to, uint256 value) internal virtual override(ERC20, ERC20Votes) {
+        super._update(from, to, value);
+    }
+}

src/Doppler.sol

@@ -79,7 +79,6 @@ contract Doppler is BaseHook {
 
     constructor(
         IPoolManager _poolManager,
-        PoolKey memory _poolKey,
         uint256 _numTokensToSell,
         uint256 _minimumProceeds,
         uint256 _maximumProceeds,
@@ -101,8 +100,6 @@ contract Doppler is BaseHook {
             if (_isToken0 && _startingTick <= _endingTick) revert InvalidTickRange();
             if (!_isToken0 && _startingTick >= _endingTick) revert InvalidTickRange();
         }
-        // Enforce maximum tick spacing
-        if (_poolKey.tickSpacing > MAX_TICK_SPACING) revert InvalidTickSpacing();
 
         /* Time checks */
         uint256 timeDelta = _endingTime - _startingTime;
@@ -117,11 +114,6 @@ contract Doppler is BaseHook {
         // _endingTime - startingTime must be divisible by epochLength
         if (timeDelta % _epochLength != 0) revert InvalidEpochLength();
 
-        /* Gamma checks */
-        // Enforce that the total tick delta is divisible by the total number of epochs
-        // Enforce that gamma is divisible by tick spacing
-        if (_gamma % _poolKey.tickSpacing != 0) revert InvalidGamma();
-
         /* Num price discovery slug checks */
         if (_numPDSlugs == 0) revert InvalidNumPDSlugs();
         if (_numPDSlugs > MAX_PRICE_DISCOVERY_SLUGS) revert InvalidNumPDSlugs();
@@ -142,6 +134,23 @@ contract Doppler is BaseHook {
         numPDSlugs = _numPDSlugs;
     }
 
+    function beforeInitialize(address, PoolKey calldata key, uint160, bytes calldata)
+        external
+        view
+        override
+        returns (bytes4)
+    {
+        // Enforce maximum tick spacing
+        if (key.tickSpacing > MAX_TICK_SPACING) revert InvalidTickSpacing();
+
+        /* Gamma checks */
+        // Enforce that the total tick delta is divisible by the total number of epochs
+        // Enforce that gamma is divisible by tick spacing
+        if (gamma % key.tickSpacing != 0) revert InvalidGamma();
+
+        return BaseHook.beforeInitialize.selector;
+    }
+
     /// @notice Called by poolManager following initialization, used to place initial liquidity slugs
     /// @param sender The address that called poolManager.initialize
     /// @param key The pool key

src/DopplerFactory.sol

@@ -0,0 +1,80 @@
+/// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
+import {Hooks} from "v4-core/src/libraries/Hooks.sol";
+import {IHookFactory} from "src/interfaces/IHookFactory.sol";
+import {Doppler} from "src/Doppler.sol";
+import {HookMiner} from "src/HookMiner.sol";
+
+contract DopplerFactory is IHookFactory {
+    function create(
+        IPoolManager poolManager,
+        uint256 numTokensToSell,
+        uint256 startingTime,
+        uint256 endingTime,
+        uint256 minimumProceeds,
+        uint256 maximumProceeds,
+        int24 startingTick,
+        int24 endingTick,
+        uint256 epochLength,
+        int24 gamma,
+        bool isToken0,
+        bytes memory,
+        bytes32 salt
+    ) external returns (address) {
+        return address(
+            new Doppler{salt: salt}(
+                poolManager,
+                numTokensToSell,
+                startingTime,
+                endingTime,
+                minimumProceeds,
+                maximumProceeds,
+                startingTick,
+                endingTick,
+                epochLength,
+                gamma,
+                isToken0,
+                3 // numPDSlugs
+            )
+        );
+    }
+
+    function predict(
+        IPoolManager poolManager,
+        uint256 numTokensToSell,
+        uint256 startingTime,
+        uint256 endingTime,
+        uint256 minimumProceeds,
+        uint256 maximumProceeds,
+        int24 startingTick,
+        int24 endingTick,
+        uint256 epochLength,
+        int24 gamma,
+        bool isToken0,
+        bytes memory
+    ) public view returns (address hookAddress, bytes32 salt) {
+        (hookAddress, salt) = HookMiner.find(
+            address(this),
+            uint160(
+                Hooks.BEFORE_INITIALIZE_FLAG | Hooks.AFTER_INITIALIZE_FLAG | Hooks.BEFORE_ADD_LIQUIDITY_FLAG
+                    | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
+            ),
+            type(Doppler).creationCode,
+            abi.encode(
+                poolManager,
+                numTokensToSell,
+                startingTime,
+                endingTime,
+                minimumProceeds,
+                maximumProceeds,
+                startingTick,
+                endingTick,
+                epochLength,
+                gamma,
+                isToken0
+            )
+        );
+    }
+}