Feat/airlock (WIP)

README.md

@@ -1,66 +1,27 @@
-## Foundry
-
-**Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.**
-
-Foundry consists of:
-
--   **Forge**: Ethereum testing framework (like Truffle, Hardhat and DappTools).
--   **Cast**: Swiss army knife for interacting with EVM smart contracts, sending transactions and getting chain data.
--   **Anvil**: Local Ethereum node, akin to Ganache, Hardhat Network.
--   **Chisel**: Fast, utilitarian, and verbose solidity REPL.
-
-## Documentation
-
-https://book.getfoundry.sh/
-
-## Usage
-
-### Build
-
-```shell
-$ forge build
-```
-
-### Test
-
-```shell
-$ forge test
-```
-
-### Format
-
-```shell
-$ forge fmt
-```
-
-### Gas Snapshots
-
-```shell
-$ forge snapshot
-```
-
-### Anvil
-
-```shell
-$ anvil
-```
-
-### Deploy
-
-```shell
-$ forge script script/Counter.s.sol:CounterScript --rpc-url <your_rpc_url> --private-key <your_private_key>
-```
-
-### Cast
-
-```shell
-$ cast <subcommand>
-```
-
-### Help
-
-```shell
-$ forge --help
-$ anvil --help
-$ cast --help
-```
+# Doppler
+
+## Initialization
+
+This sequence diagram explains how a new pair of token and pool is created:
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant A as Airlock
+    participant F as TokenFactory
+    participant P as PoolManager
+    participant H as Hook
+
+    U->>A: calls create()
+    A->>F: calls deploy()
+    F-->>A: send tokens
+    A->>P: initialize()
+    P->>H: beforeInitialize()
+    H-->>A: take tokens
+    H->>P: unlock()
+    P->>+H: unlockCallback()
+    H->>P: modifyLiquidity()
+    H->>P: ...
+    H->>P: sync()
+    H->>-P: settle()
+```

foundry.toml

@@ -3,5 +3,6 @@ src = "src"
 out = "out"
 libs = ["lib"]
 evm_version = "cancun"
+remappings = ["solady/=lib/solady/src/"]
 
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

remappings.txt

@@ -1,2 +1,3 @@
 v4-core/=lib/v4-periphery/lib/v4-core/
-v4-periphery/=lib/v4-periphery/
+v4-periphery/=lib/v4-periphery/
+openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/contracts/

src/Airlock.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {IPoolManager, PoolKey, Currency, IHooks} from "v4-core/src/PoolManager.sol";
+import {Ownable} from "openzeppelin/access/Ownable.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 Token {
+    address governance;
+    bool hasMigrated;
+    address hook;
+    address[] recipients;
+    uint256[] amounts;
+}
+
+contract Airlock is Ownable {
+    IPoolManager public immutable poolManager;
+
+    mapping(address => FactoryState) public getFactoryState;
+    mapping(address => Token) public getToken;
+
+    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(
+        address tokenFactory,
+        string memory name,
+        string memory symbol,
+        uint256 totalSupply,
+        address owner,
+        bytes memory tokenData,
+        address governanceFactory,
+        bytes memory governanceData,
+        address hookFactory,
+        bytes memory hookData,
+        uint256 liquidityAmount, // TODO: Maybe we should use an amount of tokens instead of liquidity?
+        address stageAdmin,
+        address[] memory recipients,
+        uint256[] memory amounts
+    ) external returns (address token, address governance, address hook) {
+        require(getFactoryState[tokenFactory] == FactoryState.TokenFactory, WrongFactoryState());
+        require(getFactoryState[governanceFactory] == FactoryState.GovernanceFactory, WrongFactoryState());
+        require(getFactoryState[hookFactory] == FactoryState.HookFactory, WrongFactoryState());
+
+        // FIXME: Address of the hook is unknown at this point
+        token = ITokenFactory(tokenFactory).create(name, symbol, totalSupply, hook, owner, tokenData);
+        (governance,) = IGovernanceFactory(governanceFactory).create(name, token, governanceData);
+        hook = IHookFactory(hookFactory).create(poolManager, hookData);
+
+        getToken[token] =
+            Token({governance: governance, hasMigrated: false, hook: hook, recipients: recipients, amounts: amounts});
+
+        PoolKey memory key = PoolKey({
+            // TODO: Currently only ETH pairs are supported
+            currency0: Currency.wrap(address(0)),
+            currency1: Currency.wrap(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)
+        });
+
+        uint160 sqrtPriceX96;
+
+        poolManager.initialize(key, sqrtPriceX96, new bytes(0));
+    }
+
+    /**
+     * 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,74 @@
+/// 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 feeOnTransfer;
+    mapping(address => bool) public isExemptFromFees;
+    address public feeCollector;
+
+    uint256 public immutable mintStartDate;
+    uint256 public immutable yearlyMintCap;
+
+    constructor(
+        string memory name_,
+        string memory symbol_,
+        uint256 totalSupply_,
+        address recipient,
+        uint256 feeOnTransfer_,
+        address[] memory exemptFromFees,
+        address feeCollector_,
+        address owner_
+    ) ERC20(name_, symbol_) ERC20Permit(name_) Ownable(owner_) {
+        _mint(recipient, totalSupply_);
+        feeOnTransfer = feeOnTransfer_;
+
+        for (uint256 i = 0; i < exemptFromFees.length; i++) {
+            isExemptFromFees[exemptFromFees[i]] = true;
+        }
+
+        feeCollector = feeCollector_;
+        isExemptFromFees[feeCollector_] = true; // Just in case
+
+        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);
+
+        // TODO: Check when should we charge / NOT charge the fee?
+        if (feeOnTransfer > 0 && !isExemptFromFees[from] && !isExemptFromFees[to]) {
+            uint256 fee = feeOnTransfer * value / 10_000;
+            _transfer(to, feeCollector, fee);
+        }
+    }
+}

src/DopplerFactory.sol

@@ -0,0 +1,35 @@
+/// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
+import {IHookFactory} from "src/interfaces/IHookFactory.sol";
+import {Doppler} from "src/Doppler.sol";
+
+contract DopplerFactory is IHookFactory {
+    function create(IPoolManager poolManager, bytes memory hookData) external returns (address) {
+        (
+            uint256 numTokensToSell,
+            uint256 startingTime,
+            uint256 endingTime,
+            int24 startingTick,
+            int24 endingTick,
+            uint256 epochLength,
+            uint256 gamma,
+            bool isToken0
+        ) = abi.decode(hookData, (uint256, uint256, uint256, int24, int24, uint256, uint256, bool));
+
+        return address(
+            new Doppler(
+                poolManager,
+                numTokensToSell,
+                startingTime,
+                endingTime,
+                startingTick,
+                endingTick,
+                epochLength,
+                gamma,
+                isToken0
+            )
+        );
+    }
+}