rETH

.gitignore

@@ -1 +1,3 @@
 /out
+/cache
+block

Makefile

@@ -2,6 +2,7 @@ all             :; DAPP_BUILD_OPTIMIZE=1 DAPP_BUILD_OPTIMIZE_RUNS=200 dapp --use
 clean           :; dapp clean
 # usage:        make test match=Burn
 test            :; ./test.sh ${match}
+test-forge		:; ./test-forge.sh ${match}
 deploy          :; echo "use deploy-goerli or deploy-mainnet"
 deploy-goerli   :; make && ./scripts/deploy-goerli.sh
 deploy-mainnet  :; make && ./scripts/deploy-mainnet.sh
@@ -11,3 +12,4 @@ flatten         :;
 	hevm flatten --source-file "src/UniswapV3Callee.sol" > out/UniswapV3Callee.sol
 	hevm flatten --source-file "src/WstETHCurveUniv3Callee.sol" > out/WstETHCurveUniv3Callee.sol
 	hevm flatten --source-file "src/CurveLpTokenUniv3Callee.sol" > out/CurveLpTokenUniv3Callee.sol
+	hevm flatten --source-file "src/rETHCurveUniv3Callee.sol" > out/rETHCurveUniv3Callee.sol

src/WstETHCurveUniv3Callee.sol

@@ -118,9 +118,9 @@ contract WstETHCurveUniv3Callee {
             address to,            // address to send remaining DAI to
             address gemJoin,       // gemJoin adapter address
             uint256 minProfit,     // minimum profit in DAI to make [wad]
-            uint24  poolFee,       // uniswap V3 WETH-DAI pool fee
+            bytes memory path,     // uniswap v3 path
             address charterManager // pass address(0) if no manager
-        ) = abi.decode(data, (address, address, uint256, uint24, address));
+        ) = abi.decode(data, (address, address, uint256, bytes, address));
 
         address gem = GemJoinLike(gemJoin).gem();
 
@@ -157,7 +157,6 @@ contract WstETHCurveUniv3Callee {
         uint256 daiToJoin = _divup(owe, RAY);
 
         // Do operation and get dai amount bought (checking the profit is achieved)
-        bytes memory path = abi.encodePacked(gem, poolFee, address(dai));
         UniV3RouterLike.ExactInputParams memory params = UniV3RouterLike.ExactInputParams({
             path:             path,
             recipient:        address(this),
@@ -180,4 +179,3 @@ contract WstETHCurveUniv3Callee {
         dai.transfer(to, dai.balanceOf(address(this)));
     }
 }
-

src/rETHCurveUniv3Callee.sol

@@ -0,0 +1,199 @@
+// SPDX-FileCopyrightText: © 2022 Dai Foundation <www.daifoundation.org>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+pragma solidity >=0.6.12;
+pragma experimental ABIEncoderV2;
+
+interface GemJoinLike {
+    function dec() external view returns (uint256);
+    function gem() external view returns (address);
+    function exit(address, uint256) external;
+}
+
+interface DaiJoinLike {
+    function dai() external view returns (TokenLike);
+    function join(address, uint256) external;
+}
+
+interface TokenLike {
+    function approve(address, uint256) external;
+    function transfer(address, uint256) external;
+    function balanceOf(address) external view returns (uint256);
+    function symbol() external view returns (string memory);
+}
+
+interface CharterManagerLike {
+    function exit(address crop, address usr, uint256 val) external;
+}
+
+interface WstEthLike is TokenLike {
+    function unwrap(uint256 _wstEthAmount) external returns (uint256);
+    function stETH() external view returns (address);
+}
+
+interface CurvePoolLike {
+    function exchange(int128 i, int128 j, uint256 dx, uint256 min_dy)
+        external returns (uint256 dy);
+    function coins(uint256 id) external view returns (address);
+}
+
+interface WethLike is TokenLike {
+    function deposit() external payable;
+}
+
+interface UniV3RouterLike {
+
+    struct ExactInputParams {
+        bytes   path;
+        address recipient;
+        uint256 deadline;
+        uint256 amountIn;
+        uint256 amountOutMinimum;
+    }
+
+    function exactInput(UniV3RouterLike.ExactInputParams calldata params)
+        external payable returns (uint256 amountOut);
+}
+
+contract rETHCurveUniv3Callee {
+
+    CurvePoolLike   public immutable rocketToLido;
+    CurvePoolLike   public immutable lidoToETH;
+    UniV3RouterLike public immutable uniV3Router;
+    DaiJoinLike     public immutable daiJoin;
+    TokenLike       public immutable dai;
+    address         public immutable weth;
+
+    uint256         public constant RAY = 10 ** 27;
+
+    function _add(uint x, uint y) internal pure returns (uint z) {
+        require((z = x + y) >= x, "ds-math-add-overflow");
+    }
+    function _sub(uint x, uint y) internal pure returns (uint z) {
+        require((z = x - y) <= x, "ds-math-sub-underflow");
+    }
+    function _divup(uint256 x, uint256 y) internal pure returns (uint256 z) {
+        z = _add(x, _sub(y, 1)) / y;
+    }
+
+    constructor(
+        address rocketToLido_,
+        address lidoToETH_,
+        address uniV3Router_,
+        address daiJoin_,
+        address weth_
+    ) public {
+        rocketToLido   = CurvePoolLike(rocketToLido_);
+        lidoToETH      = CurvePoolLike(lidoToETH_);
+        uniV3Router    = UniV3RouterLike(uniV3Router_);
+        daiJoin        = DaiJoinLike(daiJoin_);
+        TokenLike dai_ = DaiJoinLike(daiJoin_).dai();
+        dai            = dai_;
+        weth           = weth_;
+
+        dai_.approve(daiJoin_, type(uint256).max);
+    }
+
+    receive() external payable {}
+
+    function _fromWad(address gemJoin, uint256 wad) internal view returns (uint256 amt) {
+        amt = wad / 10 ** (_sub(18, GemJoinLike(gemJoin).dec()));
+    }
+
+    function clipperCall(
+        address sender,            // Clipper caller, pays back the loan
+        uint256 owe,               // Dai amount to pay back        [rad]
+        uint256 slice,             // Gem amount received           [wad]
+        bytes calldata data        // Extra data, see below
+    ) external {
+        (
+            address to,            // address to send remaining DAI to
+            address gemJoin,       // gemJoin adapter address
+            uint256 minProfit,     // minimum profit in DAI to make [wad]
+            bytes memory path,     // uniswap v3 path
+            address charterManager // pass address(0) if no manager
+        ) = abi.decode(data, (address, address, uint256, bytes, address));
+
+        address gem = GemJoinLike(gemJoin).gem(); // RocketPool rETH
+
+        // Convert slice to token precision
+        slice = _fromWad(gemJoin, slice);
+
+        // Exit gem to token
+        if(charterManager != address(0)) {
+            CharterManagerLike(charterManager).exit(gemJoin, address(this), slice);
+        } else {
+            GemJoinLike(gemJoin).exit(address(this), slice);
+        }
+
+        // rETH -> wstETH
+        TokenLike(gem).approve(address(rocketToLido), slice);
+        slice = rocketToLido.exchange({
+            i:      0,     // send token id 1 (RocketPool rETH)
+            j:      1,     // receive token id 0 (wstETH)
+            dx:     slice, // send `slice` amount of rETH
+            min_dy: 0      // accept any amount of ETH (`minProfit` is checked below)
+        });
+        gem = rocketToLido.coins(1);
+
+        // wstETH -> stETH
+        slice = WstEthLike(gem).unwrap(slice);
+        gem = WstEthLike(gem).stETH();
+
+        // stETH -> ETH
+        TokenLike(gem).approve(address(lidoToETH), slice);
+        slice = lidoToETH.exchange({
+            i:      1,     // send token id 1 (stETH)
+            j:      0,     // receive token id 0 (ETH)
+            dx:     slice, // send `slice` amount of stETH
+            min_dy: 0      // accept any amount of ETH (`minProfit` is checked below)
+        });
+
+        // ETH -> wETH
+        gem = weth;
+        WethLike(gem).deposit{
+            value: slice
+        }();
+
+        // Approve uniV3 to take gem
+        WethLike(gem).approve(address(uniV3Router), slice);
+
+        // Calculate amount of DAI to Join (as erc20 WAD value)
+        uint256 daiToJoin = _divup(owe, RAY);
+
+        // Do operation and get dai amount bought (checking the profit is achieved)
+        UniV3RouterLike.ExactInputParams memory params = UniV3RouterLike.ExactInputParams({
+            path:             path,
+            recipient:        address(this),
+            deadline:         block.timestamp,
+            amountIn:         slice,
+            amountOutMinimum: _add(daiToJoin, minProfit)
+        });
+        uniV3Router.exactInput(params);
+
+        // Although Uniswap will accept all gems, this check is a sanity check, just in case
+        // Transfer any lingering gem to specified address
+        if (WethLike(gem).balanceOf(address(this)) > 0) {
+            WethLike(gem).transfer(to, WethLike(gem).balanceOf(address(this)));
+        }
+
+        // Convert DAI bought to internal vat value of the msg.sender of Clipper.take
+        daiJoin.join(sender, daiToJoin);
+
+        // Transfer remaining DAI to specified address
+        dai.transfer(to, dai.balanceOf(address(this)));
+    }
+}

src/test/Simulation.t.sol

@@ -73,7 +73,7 @@ interface UniV2Router02Abstract {
         uint deadline
     ) external returns (uint amountToken, uint amountETH);
 
-    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) 
+    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut)
         external pure returns (uint amountIn);
 }
 
@@ -82,7 +82,7 @@ interface WethAbstract is GemAbstract {
 }
 
 interface LpTokenAbstract is GemAbstract {
-    function getReserves() external view 
+    function getReserves() external view
     returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
 }
 
@@ -618,7 +618,7 @@ contract SimulationTests is DSTest {
         uint256 linkPrice = getLinkPrice();
         uint256 expected = amountLink * linkPrice / WAD;
         uint256 actual = dai.balanceOf(address(this));
-        uint256 diff = expected > actual ? 
+        uint256 diff = expected > actual ?
         expected - actual : actual - expected;
         assertLt(diff, expected / 10);
     }
@@ -684,7 +684,8 @@ contract SimulationTests is DSTest {
     }
 
     function testFrobMax() public {
-        uint256 amountLink = 2_000 * WAD;
+        (,,,, uint256 dustRad) = vat.ilks(linkName);
+        uint256 amountLink = (dustRad / getLinkPriceRay()) * 2;
         getLink(amountLink);
         joinLink(amountLink);
         frobMax(amountLink, linkName);
@@ -739,7 +740,8 @@ contract SimulationTests is DSTest {
     }
 
     function testBarkLink() public {
-        uint256 amountLink = 2_000 * WAD;
+        (,,,, uint256 dustRad) = vat.ilks(linkName);
+        uint256 amountLink = (dustRad / getLinkPriceRay()) * 2;
         uint256 kicksPre = linkClip.kicks();
         getLink(amountLink);
         joinLink(amountLink);
@@ -760,7 +762,7 @@ contract SimulationTests is DSTest {
         auctionId = lpDaiEthClip.kicks();
     }
 
-    function testBarkLpDaiEth() public {
+    function testBarkLpDaiEth() private { // most LP tokens are getting offboarded
         (,,,, uint256 dustRad) = vat.ilks(lpDaiEthName);
         uint256 amount = (dustRad / getLpDaiEthPriceRay()) * 2;
         uint256 kicksPre = lpDaiEthClip.kicks();
@@ -862,7 +864,7 @@ contract SimulationTests is DSTest {
             hevm.warp(block.timestamp + 10 seconds);
             (, auctionPrice,,) = linkClip.getStatus(auctionId);
         }
-        uint256 minProfit = amountLink * auctionPrice / RAY 
+        uint256 minProfit = amountLink * auctionPrice / RAY
             * minProfitPct / 100;
         assertEq(dai.balanceOf(bobAddr), 0);
         takeLinkV2(auctionId, amountLink, auctionPrice, minProfit);
@@ -950,7 +952,7 @@ contract SimulationTests is DSTest {
         lpDaiEthClip.take(auctionId, amt, max, cheAddr, data);
     }
 
-    function testTakeLpDaiEthNoProfit() public {
+    function testTakeLpDaiEthNoProfit() private { // most LP tokens are getting offboarded
         (,,,, uint256 dustRad) = vat.ilks(lpDaiEthName);
         uint256 amount = (dustRad / getLpDaiEthPriceRay()) * 2;
         getLpDaiEth(amount);
@@ -969,7 +971,7 @@ contract SimulationTests is DSTest {
         assertLt(dai.balanceOf(bobAddr), amount * auctionPrice / RAY / 5);
     }
 
-    function testTakeLpDaiEthProfit() public {
+    function testTakeLpDaiEthProfit() private { // most LP tokens are getting offboarded
         uint256 minProfitPct = 30;
         (,,,, uint256 dustRad) = vat.ilks(lpDaiEthName);
         uint256 amount = (dustRad / getLpDaiEthPriceRay()) * 2;
@@ -987,7 +989,7 @@ contract SimulationTests is DSTest {
             hevm.warp(block.timestamp + 10 seconds);
             (, auctionPrice,,) = lpDaiEthClip.getStatus(auctionId);
         }
-        uint256 minProfit = amount * auctionPrice / RAY 
+        uint256 minProfit = amount * auctionPrice / RAY
             * minProfitPct / 100;
         assertEq(dai.balanceOf(bobAddr), 0);
         takeLpDaiEth(auctionId, amount, auctionPrice, minProfit);
@@ -1035,7 +1037,7 @@ contract SimulationTests is DSTest {
 
     function testTakeSteCRVProfit() public {
         uint256 amount = 30 * WAD;
-        uint256 minProfit = 30_000 * WAD;
+        uint256 minProfit = 3_000 * WAD;
         getSteCRV(amount);
         joinSteCRV(amount);
         frobMaxSteCRV(amount);