#DEV-22 build: core contracts (deploy, init, and configuration)

.gitignore

@@ -7,9 +7,6 @@ out/
 /broadcast/*/31337/
 /broadcast/**/dry-run/
 
-# Docs
-docs/
-
 # Dotenv file
 .env
 

.gitmodules

@@ -4,3 +4,12 @@
 [submodule "lib/openzeppelin-contracts"]
 	path = lib/openzeppelin-contracts
 	url = https://github.com/openZeppelin/openzeppelin-contracts
+[submodule "lib/openzeppelin-contracts-upgradeable"]
+	path = lib/openzeppelin-contracts-upgradeable
+	url = https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable
+[submodule "lib/v3-core"]
+	path = lib/v3-core
+	url = https://github.com/Uniswap/v3-core
+[submodule "lib/v3-periphery"]
+	path = lib/v3-periphery
+	url = https://github.com/Uniswap/v3-periphery

docs/code_standards.md

@@ -0,0 +1,19 @@
+# Code Standards
+
+## Import Order
+
+- Packages
+- Interfaces
+- Libraries
+- Submodules
+- Helpers
+
+## Library Order
+
+- LibFunctionRouter
+- LibHelpers
+- LibBytes
+- LibDataTypes
+- LibErrors
+- LibEvents
+- LibConstants

docs/references.md

@@ -0,0 +1,8 @@
+# References
+
+## Table of Contents
+
+- [PancakeSwap MasterChefV3](https://etherscan.io/address/0x556b9306565093c855aea9ae92a594704c2cd59e)
+- [PancakeSwap NonfungiblePositionManager](https://etherscan.io/address/0x46a15b0b27311cedf172ab29e4f4766fbe7f4364)
+- [Intro. of diamond standard in Ethereum Forum](https://forum.openzeppelin.com/t/introduction-to-the-diamond-standard-eip-2535-diamonds/12505)
+- [Testing Position](https://etherscan.io/tx/0x77a9e9f12f3cbf31d64de0f0fb5c75e410d96819a4f992c2fbe0039ea7c8404a)

foundry.toml

@@ -1,6 +1,6 @@
 [profile.default]
 solc_version = '0.8.17'
-optimizer = false
+optimizer = true
 fs_permissions = [{ access = "read-write", path = "./"}]
 
 [profile.optimized]
@@ -13,4 +13,7 @@ line_length=130
 tab_width=4
 func_attrs_with_params_multiline=true
 
+[rpc_endpoints]
+mainnet = "https://eth-mainnet.g.alchemy.com/v2/${ALCHEMEY_KEY}"
+
 # See more config options https://github.com/foundry-rs/foundry/tree/master/config

remappings.txt

@@ -1,5 +1,7 @@
 ds-test/=lib/forge-std/lib/ds-test/src/
-erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/
+erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/
 forge-std/=lib/forge-std/src/
-openzeppelin-contracts/=lib/openzeppelin-contracts/
-openzeppelin/=lib/openzeppelin-contracts/contracts/
+@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/
+@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/
+@uniswap/v3-core/=lib/v3-core/
+@uniswap/v3-periphery/=lib/v3-periphery/

src/core/InitVault.sol

@@ -0,0 +1,47 @@
+//SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+// External Packages
+import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+// Libraries
+import {AppStorage, LibAppStorage} from "../libraries/LibAppStorage.sol";
+import {LibPostionManager} from "../libraries/LibPostionManager.sol";
+
+contract InitVault is Initializable, ERC20Upgradeable {
+    function initialize(address _nftPositionManager, address _masterchef, uint256 _tokenId, string calldata _vaultName)
+        public
+        initializer
+    {
+        AppStorage storage s = LibAppStorage.systemStorage();
+        s.systemInitialized = true;
+        s.tokenId = _tokenId;
+        s.nonFungibleTokenPositionManager = _nftPositionManager;
+        s.masterChef = _masterchef;
+
+        // stake position
+        LibPostionManager.stake();
+
+        // fetch info from position manager
+        (address _token0, address _token1, uint24 _fee, int24 _tickLower, int24 _tickUpper, uint256 _initialLiquidity) =
+            LibPostionManager.positionInfo(_tokenId);
+
+        // initialize the state variables
+        s.token0 = _token0;
+        s.token1 = _token1;
+        s.fee = _fee;
+        s.tickLower = _tickLower;
+        s.tickUpper = _tickUpper;
+        s.initialLiquidity = _initialLiquidity;
+
+        // initializing the vault token. By default, it has 18 decimals.
+        __ERC20_init_unchained(
+            string(abi.encodePacked(_vaultName, ERC20Upgradeable(_token0).symbol(), "_", ERC20Upgradeable(_token1).symbol())),
+            string(abi.encodePacked(_vaultName, ERC20Upgradeable(_token0).symbol(), "_", ERC20Upgradeable(_token1).symbol()))
+        );
+
+        // mint the initial shares and send them to the specified recipient, as well as overflow of the tokens
+        _mint(msg.sender, uint256(_initialLiquidity));
+    }
+}

src/core/Modifiers.sol

@@ -0,0 +1,62 @@
+//SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+/// @notice modifiers
+
+// Packages
+import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol";
+import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
+
+// Libraries
+import {AppStorage, LibAppStorage} from "../libraries/LibAppStorage.sol";
+import {LibHelpers} from "../libraries/LibHelpers.sol";
+import {LibErrors} from "../libraries/LibErrors.sol";
+import {LibConstants} from "../libraries/LibConstants.sol";
+
+/**
+ * @title Modifiers
+ * @notice Function modifiers to control access
+ * @dev Function modifiers to control access
+ */
+
+contract Modifiers {
+    modifier initialized() {
+        if (!LibAppStorage.systemStorage().systemInitialized) {
+            revert LibErrors.Initialized();
+        }
+        _;
+    }
+
+    modifier onlyGovernance() {
+        if (LibAppStorage.systemStorage().governance != msg.sender) {
+            revert LibErrors.NotGovernance();
+        }
+        _;
+    }
+
+    modifier onlyGovernanceOrController() {
+        if (LibAppStorage.systemStorage().governance != msg.sender || LibAppStorage.systemStorage().controller != msg.sender) {
+            revert LibErrors.NotGovernanceOrController();
+        }
+        _;
+    }
+
+    modifier checkSqrtPriceX96(uint256 offChainSqrtPriceX96, uint256 tolerance) {
+        address poolAddr = IUniswapV3Factory(LibConstants._UNI_POOL_FACTORY).getPool(
+            LibAppStorage.systemStorage().token0, LibAppStorage.systemStorage().token1, LibAppStorage.systemStorage().fee
+        );
+        (uint160 sqrtPriceX96,,,,,,) = IUniswapV3Pool(poolAddr).slot0();
+        uint256 current = uint256(sqrtPriceX96);
+        uint256 step = offChainSqrtPriceX96 * tolerance / 1000;
+        require(current < offChainSqrtPriceX96 + step, "Price too high");
+        require(current > offChainSqrtPriceX96 - step, "Price too low");
+        _;
+    }
+
+    modifier checkVaultNotPaused() {
+        if (LibAppStorage.systemStorage().vaultPause) {
+            revert LibErrors.Paused();
+        }
+        _;
+    }
+}

src/core/NonFungiblePositionVault.sol

@@ -0,0 +1,54 @@
+//SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+// Libraries
+import {LibFunctionRouter} from "../libraries/LibFunctionRouter.sol";
+
+// Submodules
+import {ConfigureSubmodule} from "../submodules/ConfigureSubmodule.sol";
+import {UpgradeSubmodule} from "../submodules/UpgradeSubmodule.sol";
+import {GovernanceSubmodule} from "../submodules/GovernanceSubmodule.sol";
+import {FunctionInfoSubmodule} from "../submodules/FunctionInfoSubmodule.sol";
+
+contract NonFungiblePositionVault {
+    constructor(address _contractOwner, address _governance, address _controller) payable {
+        LibFunctionRouter.setContractOwner(_contractOwner);
+        LibFunctionRouter.setGovernance(_governance);
+        LibFunctionRouter.setController(_controller);
+        LibFunctionRouter.setUpgradeExpiration();
+        LibFunctionRouter.addSubmoduleFunctions(
+            address(new UpgradeSubmodule()),
+            address(new FunctionInfoSubmodule()),
+            address(new ConfigureSubmodule()),
+            address(new GovernanceSubmodule())
+        );
+    }
+
+    // Find submodule for function that is called and execute the
+    // function if a submodule is found and return any value.
+    // solhint-disable no-complex-fallback
+    fallback() external payable {
+        LibFunctionRouter.FunctionRouterStorage storage frs = LibFunctionRouter.functionRouterStorage();
+
+        // get submodule from function selector
+        address submodule = address(bytes20(frs.submodules[msg.sig]));
+        // require(submodule != address(0), "FunctionRouter: Function does not exist"); - don't need to do this since we check for code below
+        LibFunctionRouter.enforceHasContractCode(submodule, "FunctionRouter: Submodule has no code");
+        // Execute external function from submodule using delegatecall and return any value.
+        assembly {
+            // copy function selector and any arguments
+            calldatacopy(0, 0, calldatasize())
+            // execute function call using the submodule
+            let result := delegatecall(gas(), submodule, 0, calldatasize(), 0, 0)
+            // get any return value
+            returndatacopy(0, 0, returndatasize())
+            // return any return value or error back to the caller
+            switch result
+            case 0 { revert(0, returndatasize()) }
+            default { return(0, returndatasize()) }
+        }
+    }
+
+    // solhint-disable no-empty-blocks
+    receive() external payable {}
+}

src/interfaces/core/INonFungiblePositionVault.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+// Submodules
+import {IConfigureSubmodule} from "../submodules/IConfigureSubmodule.sol";
+import {IUpgradeSubmodule} from "../submodules/IUpgradeSubmodule.sol";
+import {IGovernanceSubmodule} from "../submodules/IGovernanceSubmodule.sol";
+import {IFunctionInfoSubmodule} from "../submodules/IFunctionInfoSubmodule.sol";
+import {IInvestSubmodule} from "../submodules/IInvestSubmodule.sol";
+
+interface INonFungiblePositionVault is
+    IConfigureSubmodule,
+    IUpgradeSubmodule,
+    IGovernanceSubmodule,
+    IFunctionInfoSubmodule,
+    IInvestSubmodule
+{}

src/interfaces/protocols/pancake/IERC20Metadata.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+/// @title IERC20Metadata
+/// @title Interface for ERC20 Metadata
+/// @notice Extension to IERC20 that includes token metadata
+interface IERC20Metadata is IERC20 {
+    /// @return The name of the token
+    function name() external view returns (string memory);
+
+    /// @return The symbol of the token
+    function symbol() external view returns (string memory);
+
+    /// @return The number of decimal places the token has
+    function decimals() external view returns (uint8);
+}

src/interfaces/protocols/pancake/IERC721Permit.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.5;
+
+import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+
+/// @title ERC721 with permit
+/// @notice Extension to ERC721 that includes a permit function for signature based approvals
+interface IERC721Permit is IERC721 {
+    /// @notice The permit typehash used in the permit signature
+    /// @return The typehash for the permit
+    function PERMIT_TYPEHASH() external pure returns (bytes32);
+
+    /// @notice The domain separator used in the permit signature
+    /// @return The domain seperator used in encoding of permit signature
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+
+    /// @notice Approve of a specific token ID for spending by spender via signature
+    /// @param spender The account that is being approved
+    /// @param tokenId The ID of the token that is being approved for spending
+    /// @param deadline The deadline timestamp by which the call must be mined for the approve to work
+    /// @param v Must produce valid secp256k1 signature from the holder along with `r` and `s`
+    /// @param r Must produce valid secp256k1 signature from the holder along with `v` and `s`
+    /// @param s Must produce valid secp256k1 signature from the holder along with `r` and `v`
+    function permit(address spender, uint256 tokenId, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external payable;
+}

src/interfaces/protocols/pancake/IMulticall.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.5;
+pragma abicoder v2;
+
+/// @title Multicall interface
+/// @notice Enables calling multiple methods in a single call to the contract
+interface IMulticall {
+    /// @notice Call multiple functions in the current contract and return the data from all of them if they all succeed
+    /// @dev The `msg.value` should not be trusted for any method callable from multicall.
+    /// @param data The encoded function data for each of the calls to make to this contract
+    /// @return results The results from each of the calls passed in via data
+    function multicall(bytes[] calldata data) external payable returns (bytes[] memory results);
+}