Merge pull request #2 from sturgeon-protocol/dev

Dev

Author: a17

.gitignore

@@ -5,6 +5,7 @@ out/
 # Ignores development broadcast logs
 !/broadcast
 /broadcast/*/31337/
+/broadcast/*/5/
 /broadcast/**/dry-run/
 
 # Docs

README.md

@@ -1,4 +1,4 @@
-## Sturgeon contracts
+# Sturgeon contracts
 
 **Under development**
 
@@ -11,3 +11,16 @@ forge test -vv
 forge coverage
 forge fmt
 ```
+
+## Deployments
+
+### Goerli testnet
+
+* Controller 0xE3f1d1B8ea9721FF0399cF6c2990A4bE5e4fc023
+* IFO 0xE0D142466d1BF88FE23D5D265d76068077E4D6F0
+* STGN 0x95b012C1D02c859dab6b302F4b72941Ba4E3C3C3
+* veSTGN proxy 0x33222Ee7eAb1aBE6fC1724eAce207fA3Fa62C7C3
+* Multigauge 0xee7751bF946Da4cbb39A76fd8dD99a8872871a7F
+* IFO Harvester 0x4e02AbD5Aa2731bdD1655D3a0a936912Ea5f0857
+* Harvester 0x9FeCf0827e7253F4dd3e9bF92cDd7A0ebC547D16
+* CompunderVault 0x0A45e97ACEBa96650F47DA979bde3A8642f26739

chains/PolygonLib.sol

@@ -18,18 +18,25 @@ library PolygonLib {
         vestingAmount[1] = 375_000e18;
         vestingAmount[1] = 250_000e18;
 
-        Controller _c = Controller(DeployLib.deployPlatform(DeployLib.DeployParams({
-            governance: governance,
-            ifoRate: 12e17,
-            vestingClaimant: vestingClaimant,
-            vestingAmount:  vestingAmount,
-            vestingPeriod: 365 days,
-            vestingCliff: 180 days,
-            rewardToken: TOKEN_PEARL
-        })));
+        Controller _c = Controller(
+            DeployLib.deployPlatform(
+                DeployLib.DeployParams({
+                    governance: governance,
+                    ifoRate: 12e17,
+                    vestingClaimant: vestingClaimant,
+                    vestingAmount: vestingAmount,
+                    vestingPeriod: 365 days,
+                    vestingCliff: 180 days,
+                    rewardToken: TOKEN_PEARL,
+                    liquidator: address(0)
+                })
+            )
+        );
 
         if (showLog) {
-            console.log('Deployed. Controller:', address(_c));
+            console.log("Deployed. Controller:", address(_c));
         }
     }
+
+    function testA() public {}
 }

chains/TestnetLib.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.21;
+
+import {console} from "forge-std/Test.sol";
+import "../script/lib/DeployLib.sol";
+import "../test/mock/MockTetuLiquidator.sol";
+
+library TestnetLib {
+    address public constant TOKEN_WETH = 0x7b79995e5f793A07Bc00c21412e50Ecae098E7f9;
+
+    function runDeploy(bool showLog) internal returns(address) {
+        address governance = 0x3d0c177E035C30bb8681e5859EB98d114b48b935; // test deployer
+        address[] memory vestingClaimant = new address[](3);
+        uint[] memory vestingAmount = new uint[](3);
+        vestingClaimant[0] = 0x520Ab98a23100369E5280d214799b1E1c0123045; // Claw
+        vestingClaimant[1] = 0xe25e4df0432Ea55Fd76816fD8d4A21226dEE4bFF; // Minion
+        vestingClaimant[2] = 0xcc16d636dD05b52FF1D8B9CE09B09BC62b11412B; // Tetu
+        vestingAmount[0] = 375_000e18;
+        vestingAmount[1] = 375_000e18;
+        vestingAmount[1] = 250_000e18;
+
+        MockTetuLiquidator l = new MockTetuLiquidator();
+
+        Controller _c = Controller(
+            DeployLib.deployPlatform(
+                DeployLib.DeployParams({
+                    governance: governance,
+                    ifoRate: 12e17,
+                    vestingClaimant: vestingClaimant,
+                    vestingAmount: vestingAmount,
+                    vestingPeriod: 365 days,
+                    vestingCliff: 180 days,
+                    rewardToken: TOKEN_WETH,
+                    liquidator: address(l)
+                })
+            )
+        );
+
+        if (showLog) {
+            console.log("Deployed. Controller:", address(_c));
+        }
+
+        return address(_c);
+    }
+
+    function testA() public {}
+}

script/Deploy.Testnet.s.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.21;
+
+import "forge-std/Script.sol";
+import "../chains/TestnetLib.sol";
+import "../src/HarvesterVault.sol";
+import "../src/PearlStrategy.sol";
+import "../src/CompounderVault.sol";
+import "../test/mock/MockERC20.sol";
+import "../test/mock/MockPearlGaugeV2.sol";
+
+contract DeployTestnet is Script {
+    function run() external {
+        uint deployerPrivateKey = vm.envUint("PRIVATE_KEY");
+        vm.startBroadcast(deployerPrivateKey);
+        console.log("deployer", vm.addr(deployerPrivateKey));
+        IController controller = IController(TestnetLib.runDeploy(true));
+
+        // deploy mocks
+        address tokenA = address(new MockERC20("Mock Token A", "MOCK_A", 18));
+        address tokenC = address(new MockERC20("Mock Token C", "MOCK_C", 18));
+        address tokenD = address(new MockERC20("Mock Token D", "MOCK_D", 18));
+        IPearlGaugeV2 pearlGauge = IPearlGaugeV2(address(new MockPearlGaugeV2(tokenA, tokenC)));
+
+        // deploy IFO harvester
+        HarvesterVault vault =
+            new HarvesterVault(address(controller), IERC20(tokenA), "IFO Harvester MOCK_A", "xTokenA", 4_000);
+        PearlStrategy strategy = new PearlStrategy(address(vault), address(pearlGauge), true, address(0));
+        vault.setStrategy(address(strategy));
+        IGauge(controller.multigauge()).addStakingToken(address(vault));
+
+        // deploy compounder + harvester
+        vault = new HarvesterVault(address(controller), IERC20(tokenA), "Harvester MOCK_A", "xTokenA", 4_000);
+
+        CompounderVault compounderVault =
+            new CompounderVault(IERC20(tokenD), "Compounder vault for xTokenA", "xxTokenA");
+
+        strategy = new PearlStrategy(address(vault), address(pearlGauge), false, address(compounderVault));
+        vault.setStrategy(address(strategy));
+
+        IGauge(controller.multigauge()).addStakingToken(address(vault));
+        IMultiPool(controller.multigauge()).registerRewardToken(address(vault), address(compounderVault));
+
+        vm.stopBroadcast();
+    }
+
+    function testDeployPolygon() external {}
+}

script/lib/DeployLib.sol

@@ -19,43 +19,53 @@ library DeployLib {
         uint vestingPeriod;
         uint vestingCliff;
         address rewardToken; // PEARL
+        address liquidator;
+    }
+
+    struct DeployPlatformVars {
+        Controller c;
+        IFO ifo;
+        uint len;
+        address[] vesting;
+        STGN stgn;
     }
 
     function deployPlatform(DeployParams memory params) internal returns (address controller) {
-        Controller _c = new Controller(params.governance);
-        IFO ifo = new IFO(params.ifoRate); // 12e17
+        DeployPlatformVars memory v;
+        v.c = new Controller(params.governance);
+        v.ifo = new IFO(params.ifoRate); // 12e17
 
-        uint len = params.vestingClaimant.length;
-        address[] memory vesting = new address[](len);
-        for (uint i; i < len; ++i) {
-            vesting[i] = address(new Vesting());
+        v.len = params.vestingClaimant.length;
+        v.vesting = new address[](v.len);
+        for (uint i; i < v.len; ++i) {
+            v.vesting[i] = address(new Vesting());
         }
 
-        STGN stgn = new STGN(params.governance, address(ifo), 1e26, 5e25, vesting, params.vestingAmount);
-        ifo.setup(address(_c), address(stgn), params.rewardToken);
+        v.stgn = new STGN(params.governance, address(v.ifo), 1e26, 5e25, v.vesting, params.vestingAmount);
+        v.ifo.setup(address(v.c), address(v.stgn), params.rewardToken);
 
-        for (uint i; i < len; ++i) {
-            Vesting(vesting[i]).setup(
-                address(stgn), params.vestingPeriod, params.vestingCliff, params.vestingClaimant[i]
+        for (uint i; i < v.len; ++i) {
+            Vesting(v.vesting[i]).setup(
+                address(v.stgn), params.vestingPeriod, params.vestingCliff, params.vestingClaimant[i]
             );
         }
 
         ControllableProxy proxy = new ControllableProxy();
         address impl = address(new VeSTGN());
         proxy.initProxy(impl);
         VeSTGN ve = VeSTGN(address(proxy));
-        ve.init(address(stgn), 1e18, address(_c));
-        //        assertEq(IProxyControlled(proxy).implementation(), impl);
+        ve.init(address(v.stgn), 1e18, address(v.c));
+        // assertEq(IProxyControlled(proxy).implementation(), impl);
 
         proxy = new ControllableProxy();
         impl = address(new MultiGauge());
         proxy.initProxy(impl);
         MultiGauge multigauge = MultiGauge(address(proxy));
-        multigauge.init(address(_c), address(ve), address(stgn));
+        multigauge.init(address(v.c), /* address(ve),*/ address(v.stgn));
 
-        _c.setup(address(ifo), address(ve), address(stgn), address(multigauge));
+        v.c.setup(address(v.ifo), address(ve), address(v.stgn), address(multigauge), params.liquidator);
 
-        return address(_c);
+        return address(v.c);
     }
 
     function testDeployLib() external {}

src/Compounder.sol

@@ -139,11 +139,11 @@ contract Compounder is Controllable {
 
         IController _controller = IController(controller());
         uint _delay = delay;
-        uint vaultsLength = _controller.vaultsListLength();
+        uint vaultsLength = _controller.harvesterVaultsListLength();
         address[] memory _vaults = new address[](vaultsLength);
         uint counter;
         for (uint i; i < vaultsLength; ++i) {
-            address vault = _controller.vaults(i);
+            address vault = _controller.harvesterVaults(i);
             if (!excludedVaults[vault]) {
                 bool strategyNeedHardwork;
                 IStrategyStrict strategy = IVault(vault).strategy();

src/CompounderVault.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.21;
+
+import "openzeppelin-contracts/contracts/token/ERC20/extensions/ERC4626.sol";
+import "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol";
+import "openzeppelin-contracts/contracts/utils/math/Math.sol";
+import "openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol";
+import "./interfaces/IStrategyStrict.sol";
+import "./interfaces/IController.sol";
+import "./interfaces/IGauge.sol";
+
+/// @title Compounder ERC4626 tokenized vault implementation
+/// @author a17
+contract CompounderVault is ERC4626, ReentrancyGuard {
+    using SafeERC20 for IERC20;
+    using Math for uint;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                      INITIALIZATION                        */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    constructor(IERC20 asset_, string memory name_, string memory symbol_) ERC20(name_, symbol_) ERC4626(asset_) {}
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                         USER ACTIONS                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IERC4626
+    function deposit(uint assets, address receiver) public override nonReentrant returns (uint) {
+        uint shares = super.deposit(assets, receiver);
+        _afterDeposit(assets, shares, receiver);
+        return shares;
+    }
+
+    /// @inheritdoc IERC4626
+    function mint(uint shares, address receiver) public override nonReentrant returns (uint) {
+        uint assets = super.mint(shares, receiver);
+        _afterDeposit(assets, shares, receiver);
+        return assets;
+    }
+
+    /// @inheritdoc IERC4626
+    function withdraw(uint assets, address receiver, address owner) public override nonReentrant returns (uint) {
+        uint maxAssets = maxWithdraw(owner);
+        if (assets > maxAssets) {
+            revert ERC4626ExceededMaxWithdraw(owner, assets, maxAssets);
+        }
+
+        uint shares = previewWithdraw(assets);
+
+        _beforeWithdraw(assets, shares);
+
+        _withdraw(_msgSender(), receiver, owner, assets, shares);
+
+        return shares;
+    }
+
+    /// @inheritdoc IERC4626
+    function redeem(uint shares, address receiver, address owner) public override nonReentrant returns (uint) {
+        uint maxShares = maxRedeem(owner);
+        if (shares > maxShares) {
+            revert ERC4626ExceededMaxRedeem(owner, shares, maxShares);
+        }
+
+        uint assets = previewRedeem(shares);
+
+        require(assets != 0, "ZERO_ASSETS");
+        _beforeWithdraw(assets, shares);
+
+        _withdraw(_msgSender(), receiver, owner, assets, shares);
+
+        return assets;
+    }
+
+    /// @dev Withdraw all available shares for tx sender.
+    ///      The revert is expected if the balance is higher than `maxRedeem`
+    ///      It suppose to be used only on UI - for on-chain interactions withdraw concrete amount with properly checks.
+    function withdrawAll() external {
+        redeem(balanceOf(msg.sender), msg.sender, msg.sender);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                      VIEW FUNCTIONS                        */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @dev Total amount of the underlying asset that is “managed” by Vault
+    function totalAssets() public view override returns (uint) {
+        return IERC20(asset()).balanceOf(address(this));
+    }
+
+    /// @dev Price of 1 full share
+    function sharePrice() external view returns (uint) {
+        uint units = 10 ** uint(decimals());
+        uint totalSupply_ = totalSupply();
+        return totalSupply_ == 0 ? units : units * totalAssets() / totalSupply_;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       INTERNAL LOGIC                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @dev Calculate available to invest amount and send this amount to strategy
+    function _afterDeposit(uint, /*assets*/ uint, /*shares*/ address receiver) internal {}
+
+    /// @dev Internal hook for getting necessary assets from strategy.
+    function _beforeWithdraw(uint, /*assets*/ uint /*shares*/ ) internal {}
+}