Balancer Composable stable pool strategy

.gitignore

@@ -67,6 +67,7 @@ website/network.json
 
 todo.txt
 brownie/env-brownie/
+brownie/env-brownie_pandas/
 
 crytic-export
 contracts/echidna-corpus

brownie/balancer_deposit_withdrawal_test.py

@@ -109,7 +109,52 @@
 
 
 # DEPOSIT INTO COMPOSABLE POOL
+# wstETH/sfrxETH/eETH Composable stable pool
+pool_id=0x42ed016f826165c2e5976fe5bc3df540c5ad0af700000000000000000000058b
+# BPT address
+platform_address="0x42ED016F826165C2e5976fe5bC3df540C5aD0Af7"
+amount=10
+amountsIn = [0,0,0, 10 * 10**18]
+# without BPT address
+amountsInBPT = [0, 0, 10 * 10**18]
+reth.approve(ba_vault.address, 10**50, STD)
+
+tx_join = ba_vault.joinPool(
+  pool_id,
+  oeth_vault_admin.address, #sender
+  oeth_vault_admin.address, #recipient
+  [
+    # tokens need to be sorted numerically
+    [platform_address, wsteth.address, sfrxeth.address, reth.address], # assets
+    # indexes match above assets
+    amountsIn, # min amounts in
+    balancerUserDataEncoder.userDataExactTokenInForBPTOut.encode_input(1, amountsInBPT, amount * 10**18 * 0.9)[10:],
+    False, #fromInternalBalance
+  ],
+  STD
+)
 
-
+# should be all 0 since user encoded data will already have min amounts, that
+# can because of the rounding error actually be smaller than min amounts encoded
+# in the user data. (1 wei off)
+amountsOut = [0,0,0, 0]
+# without BPT address
+amountsOutBPT = [0, 0, 5 * 10**18]
+tx_exit = ba_vault.exitPool(
+  pool_id,
+  oeth_vault_admin.address, #sender
+  oeth_vault_admin.address, #recipient
+  [
+    # tokens need to be sorted numerically
+    [platform_address, wsteth.address, sfrxeth.address, reth.address], # assets
+    # indexes match above assets
+    amountsOut, # min amounts out
+    balancerUserDataEncoder.userDataBPTinForExactTokensOut.encode_input(2, amountsOutBPT, amount * 10**18 * 1.1)[10:],
+    #Composable stable pools require "1" encoded for BPT_IN_FOR_EXACT_TOKENS_OUT and not 2 because of different enum ordering 
+    balancerUserDataEncoder.userDataBPTinForExactTokensOut.encode_input(1, amountsOutBPT, amount * 10**18 * 1.1)[10:],
+    False, #fromInternalBalance
+  ],
+  STD
+)
 
 # END DEPOSIT INTO COMPOSABLE POOL

contracts/contracts/interfaces/IVault.sol

@@ -124,6 +124,8 @@ interface IVault {
 
     function withdrawAllFromStrategies() external;
 
+    function faultTolerantWithdrawAllFromStrategies() external;
+
     function withdrawFromStrategy(
         address _strategyFromAddress,
         address[] calldata _assets,

contracts/contracts/interfaces/balancer/IMetaStablePool.sol → contracts/contracts/interfaces/balancer/IBalancerPool.sol

@@ -3,9 +3,11 @@ pragma solidity ^0.8.0;
 
 import { IRateProvider } from "./IRateProvider.sol";
 
-interface IMetaStablePool {
+interface IBalancerPool {
     function getRateProviders()
         external
         view
         returns (IRateProvider[] memory providers);
+
+    function inRecoveryMode() external view returns (bool);
 }

contracts/contracts/interfaces/balancer/IBalancerVault.sol

@@ -4,19 +4,22 @@ pragma solidity ^0.8.0;
 import { IERC20 } from "../../utils/InitializableAbstractStrategy.sol";
 
 interface IBalancerVault {
-    enum WeightedPoolJoinKind {
+    enum MetaStablePoolJoinKind {
         INIT,
         EXACT_TOKENS_IN_FOR_BPT_OUT,
-        TOKEN_IN_FOR_EXACT_BPT_OUT,
-        ALL_TOKENS_IN_FOR_EXACT_BPT_OUT,
-        ADD_TOKEN
+        TOKEN_IN_FOR_EXACT_BPT_OUT
     }
 
-    enum WeightedPoolExitKind {
+    enum MetaStablePoolExitKind {
         EXACT_BPT_IN_FOR_ONE_TOKEN_OUT,
         EXACT_BPT_IN_FOR_TOKENS_OUT,
+        BPT_IN_FOR_EXACT_TOKENS_OUT
+    }
+
+    enum ComposablePoolExitKind {
+        EXACT_BPT_IN_FOR_ONE_TOKEN_OUT,
         BPT_IN_FOR_EXACT_TOKENS_OUT,
-        REMOVE_TOKEN
+        EXACT_BPT_IN_FOR_ALL_TOKENS_OUT
     }
 
     /**

contracts/contracts/mocks/BalancerComposablePoolBrokenTestStrategy.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/**
+ * @title OETH Balancer BalancerComposablePoolTest Strategy
+ * This one is required to expose internal functions to our test suite. In fixtures
+ * we replace the mainnet byte code with the one from this contract.
+ *
+ * @author Origin Protocol Inc
+ */
+import { BalancerComposablePoolStrategy } from "../strategies/balancer/BalancerComposablePoolStrategy.sol";
+
+contract BalancerComposablePoolBrokenTestStrategy is
+    BalancerComposablePoolStrategy
+{
+    constructor(
+        BaseStrategyConfig memory _stratConfig,
+        BaseBalancerConfig memory _balancerConfig,
+        address _auraRewardPoolAddress,
+        uint256 _bptTokenPoolPosition
+    )
+        BalancerComposablePoolStrategy(
+            _stratConfig,
+            _balancerConfig,
+            _auraRewardPoolAddress,
+            _bptTokenPoolPosition
+        )
+    {}
+
+    function withdrawAll() external override onlyVaultOrGovernor nonReentrant {
+        require(false, "Simulating a failed call");
+    }
+}

contracts/contracts/mocks/BalancerComposablePoolTestStrategy.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/**
+ * @title OETH Balancer BalancerComposablePoolTest Strategy
+ * This one is required to expose internal functions to our test suite. In fixtures
+ * we replace the mainnet byte code with the one from this contract.
+ *
+ * @author Origin Protocol Inc
+ */
+import { BalancerComposablePoolStrategy } from "../strategies/balancer/BalancerComposablePoolStrategy.sol";
+
+contract BalancerComposablePoolTestStrategy is BalancerComposablePoolStrategy {
+    constructor(
+        BaseStrategyConfig memory _stratConfig,
+        BaseBalancerConfig memory _balancerConfig,
+        address _auraRewardPoolAddress,
+        uint256 _bptTokenPoolPosition
+    )
+        BalancerComposablePoolStrategy(
+            _stratConfig,
+            _balancerConfig,
+            _auraRewardPoolAddress,
+            _bptTokenPoolPosition
+        )
+    {}
+
+    function getRateProviderRate(address _asset)
+        external
+        view
+        returns (uint256)
+    {
+        return _getRateProviderRate(_asset);
+    }
+
+    function assetConfigVerification(address[] calldata _assets)
+        external
+        view
+        returns (uint256)
+    {
+        _assetConfigVerification(_assets);
+    }
+
+    function getUserDataEncodedAmounts(uint256[] memory _amounts)
+        external
+        view
+        returns (uint256[] memory amounts)
+    {
+        return _getUserDataEncodedAmounts(_amounts);
+    }
+
+    function getUserDataEncodedAssets(address[] memory _assets)
+        external
+        view
+        returns (address[] memory assets)
+    {
+        return _getUserDataEncodedAssets(_assets);
+    }
+}

contracts/contracts/mocks/BalancerMetaPoolTestStrategy.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/**
+ * @title OETH Balancer BalancerMetaPoolTest Strategy
+ * This one is required to expose internal functions to our test suite. In fixtures
+ * we replace the mainnet byte code with the one from this contract.
+ *
+ * @author Origin Protocol Inc
+ */
+import { BalancerMetaPoolStrategy } from "../strategies/balancer/BalancerMetaPoolStrategy.sol";
+
+contract BalancerMetaPoolTestStrategy is BalancerMetaPoolStrategy {
+    constructor(
+        BaseStrategyConfig memory _stratConfig,
+        BaseBalancerConfig memory _balancerConfig,
+        address _auraRewardPoolAddress
+    )
+        BalancerMetaPoolStrategy(
+            _stratConfig,
+            _balancerConfig,
+            _auraRewardPoolAddress
+        )
+    {}
+
+    function getRateProviderRate(address _asset)
+        external
+        view
+        returns (uint256)
+    {
+        return _getRateProviderRate(_asset);
+    }
+
+    /**
+     * @notice This exposes the function that is currently not implemented
+     * just to future proof the usage of _deposit.
+     */
+    function deposit(
+        address[] calldata _strategyAssets,
+        uint256[] calldata _strategyAmounts
+    ) external override onlyVault nonReentrant {
+        _deposit(_strategyAssets, _strategyAmounts);
+    }
+}

contracts/contracts/mocks/MockEvilReentrantContract.sol

@@ -54,7 +54,7 @@ contract MockEvilReentrantContract {
         );
 
         bytes memory joinUserData = abi.encode(
-            IBalancerVault.WeightedPoolJoinKind.EXACT_TOKENS_IN_FOR_BPT_OUT,
+            IBalancerVault.MetaStablePoolJoinKind.EXACT_TOKENS_IN_FOR_BPT_OUT,
             amounts,
             minBPT
         );
@@ -73,7 +73,9 @@ contract MockEvilReentrantContract {
 
         // 2. Redeem as ETH
         bytes memory exitUserData = abi.encode(
-            IBalancerVault.WeightedPoolExitKind.EXACT_BPT_IN_FOR_ONE_TOKEN_OUT,
+            IBalancerVault
+                .MetaStablePoolExitKind
+                .EXACT_BPT_IN_FOR_ONE_TOKEN_OUT,
             bptTokenBalance,
             1
         );

contracts/contracts/mocks/MockwstETH.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "./MintableERC20.sol";
+
+contract MockwstETH is MintableERC20 {
+    constructor() ERC20("wstETH", "wstETH") {}
+}

contracts/contracts/proxies/Proxies.sol

@@ -175,6 +175,26 @@ contract OETHBalancerMetaPoolwstEthStrategyProxy is
 
 }
 
+/**
+ * @notice OETHBalancerComposablePoolwstEthStrategyProxy delegates calls to a
+ * BalancerComposablePoolStrategy implementation
+ */
+contract OETHBalancerComposablePoolwstEthStrategyProxy is
+    InitializeGovernedUpgradeabilityProxy
+{
+
+}
+
+/**
+ * @notice OETHBalancerCompPoolSfrxEthWstETHrETHStrategyProxy delegates calls to a
+ * BalancerComposablePoolStrategy implementation
+ */
+contract OETHBalancerCompPoolSfrxEthWstETHrETHStrategyProxy is
+    InitializeGovernedUpgradeabilityProxy
+{
+
+}
+
 /**
  * @notice FluxStrategyProxy delegates calls to a CompoundStrategy implementation
  */