@enzymefinance/testutils 4.0.0-next.5 → 4.0.0

package/dist/enzymefinance-testutils.browser.cjs.js

@@ -8,6 +8,7 @@ var protocol = require('@enzymefinance/protocol');
 var ethers = require('ethers');
 var ethers$1 = require('@enzymefinance/ethers');
 var _taggedTemplateLiteral = require('@babel/runtime/helpers/taggedTemplateLiteral');
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
 var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
 
@@ -112,6 +113,8 @@ function _deployProtocolFixture() {
 
             deployment = {
               aaveAdapter: new protocol.AaveAdapter(fixture['AaveAdapter'].address, deployer),
+              aaveDebtPositionLib: new protocol.AaveDebtPositionLib(fixture['AaveDebtPositionLib'].address, deployer),
+              aaveDebtPositionParser: new protocol.AaveDebtPositionParser(fixture['AaveDebtPositionParser'].address, deployer),
               aavePriceFeed: new protocol.AavePriceFeed(fixture['AavePriceFeed'].address, deployer),
               addressListRegistry: new protocol.AddressListRegistry(fixture['AddressListRegistry'].address, deployer),
               allowedAdapterIncomingAssetsPolicy: new protocol.AllowedAdapterIncomingAssetsPolicy(fixture['AllowedAdapterIncomingAssetsPolicy'].address, deployer),
@@ -120,18 +123,17 @@ function _deployProtocolFixture() {
               allowedDepositRecipientsPolicy: new protocol.AllowedDepositRecipientsPolicy(fixture['AllowedDepositRecipientsPolicy'].address, deployer),
               allowedExternalPositionTypesPolicy: new protocol.AllowedExternalPositionTypesPolicy(fixture['AllowedExternalPositionTypesPolicy'].address, deployer),
               allowedSharesTransferRecipientsPolicy: new protocol.AllowedSharesTransferRecipientsPolicy(fixture['AllowedSharesTransferRecipientsPolicy'].address, deployer),
-              assetFinalityResolver: new protocol.AssetFinalityResolver(fixture['AssetFinalityResolver'].address, deployer),
               compoundAdapter: new protocol.CompoundAdapter(fixture['CompoundAdapter'].address, deployer),
               compoundDebtPositionLib: new protocol.CompoundDebtPositionLib(fixture['CompoundDebtPositionLib'].address, deployer),
               compoundDebtPositionParser: new protocol.CompoundDebtPositionParser(fixture['CompoundDebtPositionParser'].address, deployer),
               compoundPriceFeed: new protocol.CompoundPriceFeed(fixture['CompoundPriceFeed'].address, deployer),
               comptrollerLib: new protocol.ComptrollerLib(fixture['ComptrollerLib'].address, deployer),
+              convexCurveLpStakingAdapter: new protocol.ConvexCurveLpStakingAdapter(fixture['ConvexCurveLpStakingAdapter'].address, deployer),
+              convexCurveLpStakingWrapperFactory: new protocol.ConvexCurveLpStakingWrapperFactory(fixture['ConvexCurveLpStakingWrapperFactory'].address, deployer),
+              convexCurveLpStakingWrapperPriceFeed: new protocol.ConvexCurveLpStakingWrapperPriceFeed(fixture['ConvexCurveLpStakingWrapperPriceFeed'].address, deployer),
               cumulativeSlippageTolerancePolicy: new protocol.CumulativeSlippageTolerancePolicy(fixture['CumulativeSlippageTolerancePolicy'].address, deployer),
               curveExchangeAdapter: new protocol.CurveExchangeAdapter(fixture['CurveExchangeAdapter'].address, deployer),
-              curveLiquidityAaveAdapter: new protocol.CurveLiquidityAaveAdapter(fixture['CurveLiquidityAaveAdapter'].address, deployer),
-              curveLiquidityEursAdapter: new protocol.CurveLiquidityEursAdapter(fixture['CurveLiquidityEursAdapter'].address, deployer),
-              curveLiquiditySethAdapter: new protocol.CurveLiquiditySethAdapter(fixture['CurveLiquiditySethAdapter'].address, deployer),
-              curveLiquidityStethAdapter: new protocol.CurveLiquidityStethAdapter(fixture['CurveLiquidityStethAdapter'].address, deployer),
+              curveLiquidityAdapter: new protocol.CurveLiquidityAdapter(fixture['CurveLiquidityAdapter'].address, deployer),
               curvePriceFeed: new protocol.CurvePriceFeed(fixture['CurvePriceFeed'].address, deployer),
               depositWrapper: new protocol.DepositWrapper(fixture['DepositWrapper'].address, deployer),
               dispatcher: new protocol.Dispatcher(fixture['Dispatcher'].address, deployer),
@@ -146,8 +148,9 @@ function _deployProtocolFixture() {
               fundValueCalculator: new protocol.FundValueCalculator(fixture['FundValueCalculator'].address, deployer),
               fundValueCalculatorRouter: new protocol.FundValueCalculatorRouter(fixture['FundValueCalculatorRouter'].address, deployer),
               fundValueCalculatorUsdWrapper: new protocol.FundValueCalculatorUsdWrapper(fixture['FundValueCalculatorUsdWrapper'].address, deployer),
+              fuseAdapter: new protocol.FuseAdapter(fixture['FuseAdapter'].address, deployer),
+              fusePriceFeed: new protocol.FusePriceFeed(fixture['FusePriceFeed'].address, deployer),
               gasRelayPaymasterFactory: new protocol.GasRelayPaymasterFactory(fixture['GasRelayPaymasterFactory'].address, deployer),
-              guaranteedRedemptionPolicy: new protocol.GuaranteedRedemptionPolicy(fixture['GuaranteedRedemptionPolicy'].address, deployer),
               idleAdapter: new protocol.IdleAdapter(fixture['IdleAdapter'].address, deployer),
               idlePriceFeed: new protocol.IdlePriceFeed(fixture['IdlePriceFeed'].address, deployer),
               integrationManager: new protocol.IntegrationManager(fixture['IntegrationManager'].address, deployer),
@@ -155,9 +158,9 @@ function _deployProtocolFixture() {
               managementFee: new protocol.ManagementFee(fixture['ManagementFee'].address, deployer),
               minAssetBalancesPostRedemptionPolicy: new protocol.MinAssetBalancesPostRedemptionPolicy(fixture['MinAssetBalancesPostRedemptionPolicy'].address, deployer),
               minMaxInvestmentPolicy: new protocol.MinMaxInvestmentPolicy(fixture['MinMaxInvestmentPolicy'].address, deployer),
+              olympusV2Adapter: new protocol.OlympusV2Adapter(fixture['OlympusV2Adapter'].address, deployer),
               onlyRemoveDustExternalPositionPolicy: new protocol.OnlyRemoveDustExternalPositionPolicy(fixture['OnlyRemoveDustExternalPositionPolicy'].address, deployer),
               onlyUntrackDustOrPricelessAssetsPolicy: new protocol.OnlyUntrackDustOrPricelessAssetsPolicy(fixture['OnlyUntrackDustOrPricelessAssetsPolicy'].address, deployer),
-              paraSwapV4Adapter: new protocol.ParaSwapV4Adapter(fixture['ParaSwapV4Adapter'].address, deployer),
               paraSwapV5Adapter: new protocol.ParaSwapV5Adapter(fixture['ParaSwapV5Adapter'].address, deployer),
               performanceFee: new protocol.PerformanceFee(fixture['PerformanceFee'].address, deployer),
               policyManager: new protocol.PolicyManager(fixture['PolicyManager'].address, deployer),
@@ -167,14 +170,13 @@ function _deployProtocolFixture() {
               protocolFeeReserveProxy: new protocol.ProtocolFeeReserveLib(fixture['ProtocolFeeReserveProxy'].address, deployer),
               protocolFeeTracker: new protocol.ProtocolFeeTracker(fixture['ProtocolFeeTracker'].address, deployer),
               revertingPriceFeed: new protocol.RevertingPriceFeed(fixture['RevertingPriceFeed'].address, deployer),
-              stakehoundEthPriceFeed: new protocol.StakehoundEthPriceFeed(fixture['StakehoundEthPriceFeed'].address, deployer),
               synthetixAdapter: new protocol.SynthetixAdapter(fixture['SynthetixAdapter'].address, deployer),
-              synthetixPriceFeed: new protocol.SynthetixPriceFeed(fixture['SynthetixPriceFeed'].address, deployer),
               uniswapV2ExchangeAdapter: new protocol.UniswapV2ExchangeAdapter(fixture['UniswapV2ExchangeAdapter'].address, deployer),
               uniswapV2LiquidityAdapter: new protocol.UniswapV2LiquidityAdapter(fixture['UniswapV2LiquidityAdapter'].address, deployer),
               uniswapV2PoolPriceFeed: new protocol.UniswapV2PoolPriceFeed(fixture['UniswapV2PoolPriceFeed'].address, deployer),
               uniswapV3Adapter: new protocol.UniswapV3Adapter(fixture['UniswapV3Adapter'].address, deployer),
               unpermissionedActionsWrapper: new protocol.UnpermissionedActionsWrapper(fixture['UnpermissionedActionsWrapper'].address, deployer),
+              usdEthSimulatedAggregator: new protocol.UsdEthSimulatedAggregator(fixture['UsdEthSimulatedAggregator'].address, deployer),
               valueInterpreter: new protocol.ValueInterpreter(fixture['ValueInterpreter'].address, deployer),
               vaultLib: new protocol.VaultLib(fixture['VaultLib'].address, deployer),
               yearnVaultV2Adapter: new protocol.YearnVaultV2Adapter(fixture['YearnVaultV2Adapter'].address, deployer),
@@ -230,7 +232,7 @@ function _addNewAssetsToFund() {
         switch (_context.prev = _context.next) {
           case 0:
             signer = _ref.signer, comptrollerProxy = _ref.comptrollerProxy, integrationManager = _ref.integrationManager, assets = _ref.assets, _ref$amounts = _ref.amounts, amounts = _ref$amounts === void 0 ? new Array(assets.length).fill(1) : _ref$amounts;
-            // First, add tracked assets while their balances are 0
+            // First, add tracked assets
             receipt = addTrackedAssetsToVault({
               assets: assets,
               comptrollerProxy: comptrollerProxy,
@@ -387,13 +389,13 @@ function createFundDeployer(_x) {
 
 function _createFundDeployer() {
   _createFundDeployer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee(_ref) {
-    var deployer, assetFinalityResolver, externalPositionManager, dispatcher, gasRelayPaymasterFactory, valueInterpreter, vaultLib, _ref$setOnDispatcher, setOnDispatcher, _ref$setReleaseLive, setReleaseLive, mlnToken, wethToken, protocolFeeReserve, nextFundDeployer, nextPolicyManager, nextExternalPositionManager, nextFeeManager, nextIntegrationManager, nextComptrollerLib, nextProtocolFeeTracker, nextVaultLib;
+    var deployer, externalPositionManager, dispatcher, gasRelayPaymasterFactory, valueInterpreter, vaultLib, _ref$setOnDispatcher, setOnDispatcher, _ref$setReleaseLive, setReleaseLive, mlnToken, wethToken, protocolFeeReserve, nextFundDeployer, nextPolicyManager, nextExternalPositionManager, nextFeeManager, nextIntegrationManager, nextComptrollerLib, nextProtocolFeeTracker, nextVaultLib;
 
     return _regeneratorRuntime__default['default'].wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            deployer = _ref.deployer, assetFinalityResolver = _ref.assetFinalityResolver, externalPositionManager = _ref.externalPositionManager, dispatcher = _ref.dispatcher, gasRelayPaymasterFactory = _ref.gasRelayPaymasterFactory, valueInterpreter = _ref.valueInterpreter, vaultLib = _ref.vaultLib, _ref$setOnDispatcher = _ref.setOnDispatcher, setOnDispatcher = _ref$setOnDispatcher === void 0 ? true : _ref$setOnDispatcher, _ref$setReleaseLive = _ref.setReleaseLive, setReleaseLive = _ref$setReleaseLive === void 0 ? true : _ref$setReleaseLive;
+            deployer = _ref.deployer, externalPositionManager = _ref.externalPositionManager, dispatcher = _ref.dispatcher, gasRelayPaymasterFactory = _ref.gasRelayPaymasterFactory, valueInterpreter = _ref.valueInterpreter, vaultLib = _ref.vaultLib, _ref$setOnDispatcher = _ref.setOnDispatcher, setOnDispatcher = _ref$setOnDispatcher === void 0 ? true : _ref$setOnDispatcher, _ref$setReleaseLive = _ref.setReleaseLive, setReleaseLive = _ref$setReleaseLive === void 0 ? true : _ref$setReleaseLive;
             _context.next = 3;
             return vaultLib.getMlnToken();
 
@@ -444,7 +446,7 @@ function _createFundDeployer() {
           case 31:
             nextIntegrationManager = _context.sent;
             _context.next = 34;
-            return protocol.ComptrollerLib.deploy(deployer, dispatcher, protocolFeeReserve, nextFundDeployer, valueInterpreter, nextExternalPositionManager, nextFeeManager, nextIntegrationManager, nextPolicyManager, assetFinalityResolver, gasRelayPaymasterFactory, mlnToken, wethToken);
+            return protocol.ComptrollerLib.deploy(deployer, dispatcher, protocolFeeReserve, nextFundDeployer, valueInterpreter, nextExternalPositionManager, nextFeeManager, nextIntegrationManager, nextPolicyManager, gasRelayPaymasterFactory, mlnToken, wethToken);
 
           case 34:
             nextComptrollerLib = _context.sent;
@@ -481,40 +483,50 @@ function _createFundDeployer() {
           case 54:
             _context.t11 = _context.sent;
             _context.next = 57;
-            return vaultLib.getWethToken();
+            return vaultLib.getMlnBurner();
 
           case 57:
             _context.t12 = _context.sent;
             _context.next = 60;
-            return _context.t5.deploy.call(_context.t5, _context.t6, _context.t7, _context.t8, _context.t9, _context.t10, _context.t11, _context.t12);
+            return vaultLib.getWethToken();
 
           case 60:
-            nextVaultLib = _context.sent;
+            _context.t13 = _context.sent;
             _context.next = 63;
-            return nextFundDeployer.setVaultLib(nextVaultLib);
+            return vaultLib.getPositionsLimit();
 
           case 63:
+            _context.t14 = _context.sent;
+            _context.next = 66;
+            return _context.t5.deploy.call(_context.t5, _context.t6, _context.t7, _context.t8, _context.t9, _context.t10, _context.t11, _context.t12, _context.t13, _context.t14);
+
+          case 66:
+            nextVaultLib = _context.sent;
+            _context.next = 69;
+            return nextFundDeployer.setVaultLib(nextVaultLib);
+
+          case 69:
             if (!setReleaseLive) {
-              _context.next = 66;
+              _context.next = 72;
               break;
             }
 
-            _context.next = 66;
+            _context.next = 72;
             return nextFundDeployer.setReleaseLive();
 
-          case 66:
+          case 72:
             if (!setOnDispatcher) {
-              _context.next = 69;
+              _context.next = 75;
               break;
             }
 
-            _context.next = 69;
+            _context.next = 75;
             return dispatcher.setCurrentFundDeployer(nextFundDeployer);
 
-          case 69:
+          case 75:
             return _context.abrupt("return", nextFundDeployer);
 
-          case 70:
+          case 76:
           case "end":
             return _context.stop();
         }
@@ -595,15 +607,15 @@ function createExternalPosition(_x2) {
 
 function _createExternalPosition() {
   _createExternalPosition = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee2(_ref2) {
-    var signer, comptrollerProxy, externalPositionManager, externalPositionTypeId, _ref2$initializationD, initializationData, receipt, event, externalPositionProxy;
+    var signer, comptrollerProxy, externalPositionManager, externalPositionTypeId, _ref2$initializationD, initializationData, _ref2$callOnExternalP, callOnExternalPositionData, receipt, event, externalPositionProxy;
 
     return _regeneratorRuntime__default['default'].wrap(function _callee2$(_context2) {
       while (1) {
         switch (_context2.prev = _context2.next) {
           case 0:
-            signer = _ref2.signer, comptrollerProxy = _ref2.comptrollerProxy, externalPositionManager = _ref2.externalPositionManager, externalPositionTypeId = _ref2.externalPositionTypeId, _ref2$initializationD = _ref2.initializationData, initializationData = _ref2$initializationD === void 0 ? '0x' : _ref2$initializationD;
+            signer = _ref2.signer, comptrollerProxy = _ref2.comptrollerProxy, externalPositionManager = _ref2.externalPositionManager, externalPositionTypeId = _ref2.externalPositionTypeId, _ref2$initializationD = _ref2.initializationData, initializationData = _ref2$initializationD === void 0 ? '0x' : _ref2$initializationD, _ref2$callOnExternalP = _ref2.callOnExternalPositionData, callOnExternalPositionData = _ref2$callOnExternalP === void 0 ? '0x' : _ref2$callOnExternalP;
             _context2.next = 3;
-            return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, protocol.ExternalPositionManagerActionId.CreateExternalPosition, protocol.encodeArgs(['uint256', 'bytes'], [externalPositionTypeId, initializationData]));
+            return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, protocol.ExternalPositionManagerActionId.CreateExternalPosition, protocol.encodeArgs(['uint256', 'bytes', 'bytes'], [externalPositionTypeId, initializationData, callOnExternalPositionData]));
 
           case 3:
             receipt = _context2.sent;
@@ -932,7 +944,12 @@ function _createMockExternalPosition() {
 
           case 21:
             _context.next = 23;
-            return comptrollerProxy.connect(fundOwner).callOnExtension(externalPositionManager, protocol.ExternalPositionManagerActionId.CreateExternalPosition, protocol.encodeArgs(['uint256', 'bytes'], [typeId, '0x']));
+            return createExternalPosition({
+              comptrollerProxy: comptrollerProxy,
+              externalPositionManager: externalPositionManager,
+              externalPositionTypeId: typeId,
+              signer: fundOwner
+            });
 
           case 23:
             receipt = _context.sent;
@@ -1099,6 +1116,209 @@ function _mockExternalPositionRemoveManagedAssets() {
   return _mockExternalPositionRemoveManagedAssets.apply(this, arguments);
 }
 
+function aaveDebtPositionAddCollateral(_x) {
+  return _aaveDebtPositionAddCollateral.apply(this, arguments);
+}
+
+function _aaveDebtPositionAddCollateral() {
+  _aaveDebtPositionAddCollateral = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee(_ref) {
+    var comptrollerProxy, externalPositionManager, signer, aTokens, amounts, externalPositionProxy, actionArgs;
+    return _regeneratorRuntime__default['default'].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            comptrollerProxy = _ref.comptrollerProxy, externalPositionManager = _ref.externalPositionManager, signer = _ref.signer, aTokens = _ref.aTokens, amounts = _ref.amounts, externalPositionProxy = _ref.externalPositionProxy;
+            actionArgs = protocol.aaveDebtPositionAddCollateralArgs({
+              aTokens: aTokens,
+              amounts: amounts
+            });
+            return _context.abrupt("return", callOnExternalPosition({
+              actionArgs: actionArgs,
+              actionId: protocol.AaveDebtPositionActionId.AddCollateralAssets,
+              comptrollerProxy: comptrollerProxy,
+              externalPositionManager: externalPositionManager,
+              externalPositionProxy: externalPositionProxy,
+              signer: signer
+            }));
+
+          case 3:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _aaveDebtPositionAddCollateral.apply(this, arguments);
+}
+
+function aaveDebtPositionBorrow(_x2) {
+  return _aaveDebtPositionBorrow.apply(this, arguments);
+}
+
+function _aaveDebtPositionBorrow() {
+  _aaveDebtPositionBorrow = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee2(_ref2) {
+    var comptrollerProxy, externalPositionManager, signer, tokens, amounts, externalPositionProxy, actionArgs;
+    return _regeneratorRuntime__default['default'].wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            comptrollerProxy = _ref2.comptrollerProxy, externalPositionManager = _ref2.externalPositionManager, signer = _ref2.signer, tokens = _ref2.tokens, amounts = _ref2.amounts, externalPositionProxy = _ref2.externalPositionProxy;
+            actionArgs = protocol.aaveDebtPositionBorrowArgs({
+              amounts: amounts,
+              tokens: tokens
+            });
+            return _context2.abrupt("return", callOnExternalPosition({
+              actionArgs: actionArgs,
+              actionId: protocol.AaveDebtPositionActionId.BorrowAsset,
+              comptrollerProxy: comptrollerProxy,
+              externalPositionManager: externalPositionManager,
+              externalPositionProxy: externalPositionProxy,
+              signer: signer
+            }));
+
+          case 3:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _aaveDebtPositionBorrow.apply(this, arguments);
+}
+
+function aaveDebtPositionClaimRewards(_x3) {
+  return _aaveDebtPositionClaimRewards.apply(this, arguments);
+}
+
+function _aaveDebtPositionClaimRewards() {
+  _aaveDebtPositionClaimRewards = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee3(_ref3) {
+    var comptrollerProxy, externalPositionManager, signer, assets, externalPositionProxy, actionArgs;
+    return _regeneratorRuntime__default['default'].wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            comptrollerProxy = _ref3.comptrollerProxy, externalPositionManager = _ref3.externalPositionManager, signer = _ref3.signer, assets = _ref3.assets, externalPositionProxy = _ref3.externalPositionProxy;
+            actionArgs = protocol.aaveDebtPositionClaimRewardsArgs({
+              assets: assets
+            });
+            return _context3.abrupt("return", callOnExternalPosition({
+              actionArgs: actionArgs,
+              actionId: protocol.AaveDebtPositionActionId.ClaimRewards,
+              comptrollerProxy: comptrollerProxy,
+              externalPositionManager: externalPositionManager,
+              externalPositionProxy: externalPositionProxy,
+              signer: signer
+            }));
+
+          case 3:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _aaveDebtPositionClaimRewards.apply(this, arguments);
+}
+
+function aaveDebtPositionRemoveCollateral(_x4) {
+  return _aaveDebtPositionRemoveCollateral.apply(this, arguments);
+}
+
+function _aaveDebtPositionRemoveCollateral() {
+  _aaveDebtPositionRemoveCollateral = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee4(_ref4) {
+    var comptrollerProxy, externalPositionManager, signer, aTokens, amounts, externalPositionProxy, actionArgs;
+    return _regeneratorRuntime__default['default'].wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            comptrollerProxy = _ref4.comptrollerProxy, externalPositionManager = _ref4.externalPositionManager, signer = _ref4.signer, aTokens = _ref4.aTokens, amounts = _ref4.amounts, externalPositionProxy = _ref4.externalPositionProxy;
+            actionArgs = protocol.aaveDebtPositionRemoveCollateralArgs({
+              aTokens: aTokens,
+              amounts: amounts
+            });
+            return _context4.abrupt("return", callOnExternalPosition({
+              actionArgs: actionArgs,
+              actionId: protocol.AaveDebtPositionActionId.RemoveCollateralAssets,
+              comptrollerProxy: comptrollerProxy,
+              externalPositionManager: externalPositionManager,
+              externalPositionProxy: externalPositionProxy,
+              signer: signer
+            }));
+
+          case 3:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _aaveDebtPositionRemoveCollateral.apply(this, arguments);
+}
+
+function aaveDebtPositionRepayBorrow(_x5) {
+  return _aaveDebtPositionRepayBorrow.apply(this, arguments);
+}
+
+function _aaveDebtPositionRepayBorrow() {
+  _aaveDebtPositionRepayBorrow = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee5(_ref5) {
+    var comptrollerProxy, externalPositionManager, signer, tokens, amounts, externalPositionProxy, actionArgs;
+    return _regeneratorRuntime__default['default'].wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            comptrollerProxy = _ref5.comptrollerProxy, externalPositionManager = _ref5.externalPositionManager, signer = _ref5.signer, tokens = _ref5.tokens, amounts = _ref5.amounts, externalPositionProxy = _ref5.externalPositionProxy;
+            actionArgs = protocol.aaveDebtPositionRepayBorrowArgs({
+              amounts: amounts,
+              tokens: tokens
+            });
+            return _context5.abrupt("return", callOnExternalPosition({
+              actionArgs: actionArgs,
+              actionId: protocol.AaveDebtPositionActionId.RepayBorrowedAssets,
+              comptrollerProxy: comptrollerProxy,
+              externalPositionManager: externalPositionManager,
+              externalPositionProxy: externalPositionProxy,
+              signer: signer
+            }));
+
+          case 3:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+  return _aaveDebtPositionRepayBorrow.apply(this, arguments);
+}
+
+function createAaveDebtPosition(_x6) {
+  return _createAaveDebtPosition.apply(this, arguments);
+}
+
+function _createAaveDebtPosition() {
+  _createAaveDebtPosition = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee6(_ref6) {
+    var signer, comptrollerProxy, externalPositionManager;
+    return _regeneratorRuntime__default['default'].wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            signer = _ref6.signer, comptrollerProxy = _ref6.comptrollerProxy, externalPositionManager = _ref6.externalPositionManager;
+            return _context6.abrupt("return", createExternalPosition({
+              comptrollerProxy: comptrollerProxy,
+              externalPositionManager: externalPositionManager,
+              externalPositionTypeId: protocol.ExternalPositionType.AaveDebtPosition,
+              signer: signer
+            }));
+
+          case 2:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6);
+  }));
+  return _createAaveDebtPosition.apply(this, arguments);
+}
+
 var _templateObject$3;
 exports.UniswapV3FeeAmount = void 0;
 
@@ -1121,41 +1341,32 @@ function createUniswapV3LiquidityPosition(_x) {
 
 function _createUniswapV3LiquidityPosition() {
   _createUniswapV3LiquidityPosition = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee(_ref) {
-    var signer, comptrollerProxy, externalPositionManager, token0, token1, initArgs, receipt, vaultProxy, externalPositions, externalPositionProxyAddress;
+    var signer, comptrollerProxy, externalPositionManager, _ref$callOnExternalPo, callOnExternalPositionData, _yield$createExternal, externalPositionProxyContract, receipt;
+
     return _regeneratorRuntime__default['default'].wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            signer = _ref.signer, comptrollerProxy = _ref.comptrollerProxy, externalPositionManager = _ref.externalPositionManager, token0 = _ref.token0, token1 = _ref.token1;
-            initArgs = protocol.uniswapV3LiquidityPositionInitArgs({
-              token0: token0,
-              token1: token1
+            signer = _ref.signer, comptrollerProxy = _ref.comptrollerProxy, externalPositionManager = _ref.externalPositionManager, _ref$callOnExternalPo = _ref.callOnExternalPositionData, callOnExternalPositionData = _ref$callOnExternalPo === void 0 ? '0x' : _ref$callOnExternalPo;
+            _context.next = 3;
+            return createExternalPosition({
+              callOnExternalPositionData: callOnExternalPositionData,
+              comptrollerProxy: comptrollerProxy,
+              externalPositionManager: externalPositionManager,
+              externalPositionTypeId: protocol.ExternalPositionType.UniswapV3LiquidityPosition,
+              signer: signer
             });
-            _context.next = 4;
-            return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, protocol.ExternalPositionManagerActionId.CreateExternalPosition, protocol.encodeArgs(['uint256', 'bytes'], [protocol.ExternalPositionType.UniswapV3LiquidityPosition, initArgs]));
-
-          case 4:
-            receipt = _context.sent;
-            _context.t0 = protocol.VaultLib;
-            _context.next = 8;
-            return comptrollerProxy.getVaultProxy();
-
-          case 8:
-            _context.t1 = _context.sent;
-            _context.t2 = signer;
-            vaultProxy = new _context.t0(_context.t1, _context.t2);
-            _context.next = 13;
-            return vaultProxy.getActiveExternalPositions.call();
 
-          case 13:
-            externalPositions = _context.sent;
-            externalPositionProxyAddress = externalPositions[externalPositions.length - 1];
+          case 3:
+            _yield$createExternal = _context.sent;
+            externalPositionProxyContract = _yield$createExternal.externalPositionProxy;
+            receipt = _yield$createExternal.receipt;
             return _context.abrupt("return", {
-              externalPositionProxyAddress: externalPositionProxyAddress,
+              externalPositionProxyAddress: externalPositionProxyContract.address,
               receipt: receipt
             });
 
-          case 16:
+          case 7:
           case "end":
             return _context.stop();
         }
@@ -1240,13 +1451,13 @@ function uniswapV3LiquidityPositionMint(_x4) {
 
 function _uniswapV3LiquidityPositionMint() {
   _uniswapV3LiquidityPositionMint = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee4(_ref4) {
-    var signer, comptrollerProxy, externalPositionManager, externalPositionProxy, fee, tickLower, tickUpper, amount0Desired, amount1Desired, _ref4$amount0Min, amount0Min, _ref4$amount1Min, amount1Min, actionArgs, callArgs, receipt, externalPosition, nftId;
+    var signer, comptrollerProxy, externalPositionManager, externalPositionProxy, token0, token1, fee, tickLower, tickUpper, amount0Desired, amount1Desired, _ref4$amount0Min, amount0Min, _ref4$amount1Min, amount1Min, actionArgs, callArgs, receipt, externalPosition, nftId;
 
     return _regeneratorRuntime__default['default'].wrap(function _callee4$(_context4) {
       while (1) {
         switch (_context4.prev = _context4.next) {
           case 0:
-            signer = _ref4.signer, comptrollerProxy = _ref4.comptrollerProxy, externalPositionManager = _ref4.externalPositionManager, externalPositionProxy = _ref4.externalPositionProxy, fee = _ref4.fee, tickLower = _ref4.tickLower, tickUpper = _ref4.tickUpper, amount0Desired = _ref4.amount0Desired, amount1Desired = _ref4.amount1Desired, _ref4$amount0Min = _ref4.amount0Min, amount0Min = _ref4$amount0Min === void 0 ? 0 : _ref4$amount0Min, _ref4$amount1Min = _ref4.amount1Min, amount1Min = _ref4$amount1Min === void 0 ? 0 : _ref4$amount1Min;
+            signer = _ref4.signer, comptrollerProxy = _ref4.comptrollerProxy, externalPositionManager = _ref4.externalPositionManager, externalPositionProxy = _ref4.externalPositionProxy, token0 = _ref4.token0, token1 = _ref4.token1, fee = _ref4.fee, tickLower = _ref4.tickLower, tickUpper = _ref4.tickUpper, amount0Desired = _ref4.amount0Desired, amount1Desired = _ref4.amount1Desired, _ref4$amount0Min = _ref4.amount0Min, amount0Min = _ref4$amount0Min === void 0 ? 0 : _ref4$amount0Min, _ref4$amount1Min = _ref4.amount1Min, amount1Min = _ref4$amount1Min === void 0 ? 0 : _ref4$amount1Min;
             actionArgs = protocol.uniswapV3LiquidityPositionMintArgs({
               amount0Desired: amount0Desired,
               amount0Min: amount0Min,
@@ -1254,7 +1465,9 @@ function _uniswapV3LiquidityPositionMint() {
               amount1Min: amount1Min,
               fee: fee,
               tickLower: tickLower,
-              tickUpper: tickUpper
+              tickUpper: tickUpper,
+              token0: token0,
+              token1: token1
             });
             callArgs = protocol.callOnExternalPositionArgs({
               actionArgs: actionArgs,
@@ -1526,19 +1739,234 @@ function _aaveRedeem() {
 
 var _templateObject$2;
 var ICompoundComptroller = ethers$1.contract()(_templateObject$2 || (_templateObject$2 = _taggedTemplateLiteral(["\n  function claimComp(address)\n"])));
-function compoundLend(_x) {
-  return _compoundLend.apply(this, arguments);
+function assertCompoundLend(_x) {
+  return _assertCompoundLend.apply(this, arguments);
 }
 
-function _compoundLend() {
-  _compoundLend = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee(_ref) {
-    var comptrollerProxy, integrationManager, fundOwner, compoundAdapter, cToken, _ref$tokenAmount, tokenAmount, _ref$cTokenAmount, cTokenAmount, lendArgs, callArgs, lendTx;
+function _assertCompoundLend() {
+  _assertCompoundLend = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee(_ref) {
+    var tokenWhale, comptrollerProxy, vaultProxy, integrationManager, fundOwner, compoundAdapter, _ref$tokenAmount, tokenAmount, cToken, compoundPriceFeed, token, rateBefore, minIncomingCTokenAmount, _yield$getAssetBalanc, _yield$getAssetBalanc2, preTxIncomingAssetBalance, preTxOutgoingAssetBalance, lendReceipt, rate, _yield$getAssetBalanc3, _yield$getAssetBalanc4, postTxIncomingAssetBalance, postTxOutgoingAssetBalance, expectedCTokenAmount;
 
     return _regeneratorRuntime__default['default'].wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            comptrollerProxy = _ref.comptrollerProxy, integrationManager = _ref.integrationManager, fundOwner = _ref.fundOwner, compoundAdapter = _ref.compoundAdapter, cToken = _ref.cToken, _ref$tokenAmount = _ref.tokenAmount, tokenAmount = _ref$tokenAmount === void 0 ? ethers.utils.parseEther('1') : _ref$tokenAmount, _ref$cTokenAmount = _ref.cTokenAmount, cTokenAmount = _ref$cTokenAmount === void 0 ? ethers.utils.parseEther('1') : _ref$cTokenAmount;
+            tokenWhale = _ref.tokenWhale, comptrollerProxy = _ref.comptrollerProxy, vaultProxy = _ref.vaultProxy, integrationManager = _ref.integrationManager, fundOwner = _ref.fundOwner, compoundAdapter = _ref.compoundAdapter, _ref$tokenAmount = _ref.tokenAmount, tokenAmount = _ref$tokenAmount === void 0 ? ethers.utils.parseEther('1') : _ref$tokenAmount, cToken = _ref.cToken, compoundPriceFeed = _ref.compoundPriceFeed;
+            _context.t0 = protocol.StandardToken;
+            _context.next = 4;
+            return compoundPriceFeed.getTokenFromCToken.args(cToken).call();
+
+          case 4:
+            _context.t1 = _context.sent;
+            _context.t2 = tokenWhale;
+            token = new _context.t0(_context.t1, _context.t2);
+            _context.next = 9;
+            return token.connect(tokenWhale).transfer(vaultProxy, tokenAmount);
+
+          case 9:
+            _context.next = 11;
+            return cToken.exchangeRateStored.call();
+
+          case 11:
+            rateBefore = _context.sent;
+            // Exchange rate stored can have a small deviation from exchangeRateStored
+            minIncomingCTokenAmount = tokenAmount.mul(ethers.utils.parseEther('1')).div(rateBefore).mul(ethers.BigNumber.from('999')).div(ethers.BigNumber.from('1000'));
+            _context.next = 15;
+            return getAssetBalances({
+              account: vaultProxy,
+              assets: [cToken, token]
+            });
+
+          case 15:
+            _yield$getAssetBalanc = _context.sent;
+            _yield$getAssetBalanc2 = _slicedToArray(_yield$getAssetBalanc, 2);
+            preTxIncomingAssetBalance = _yield$getAssetBalanc2[0];
+            preTxOutgoingAssetBalance = _yield$getAssetBalanc2[1];
+            _context.next = 21;
+            return compoundLend({
+              cToken: cToken,
+              cTokenAmount: minIncomingCTokenAmount,
+              compoundAdapter: compoundAdapter,
+              comptrollerProxy: comptrollerProxy,
+              fundOwner: fundOwner,
+              integrationManager: integrationManager,
+              tokenAmount: tokenAmount
+            });
+
+          case 21:
+            lendReceipt = _context.sent;
+            _context.next = 24;
+            return cToken.exchangeRateStored();
+
+          case 24:
+            rate = _context.sent;
+            _context.next = 27;
+            return getAssetBalances({
+              account: vaultProxy,
+              assets: [cToken, token]
+            });
+
+          case 27:
+            _yield$getAssetBalanc3 = _context.sent;
+            _yield$getAssetBalanc4 = _slicedToArray(_yield$getAssetBalanc3, 2);
+            postTxIncomingAssetBalance = _yield$getAssetBalanc4[0];
+            postTxOutgoingAssetBalance = _yield$getAssetBalanc4[1];
+            expectedCTokenAmount = tokenAmount.mul(ethers.utils.parseEther('1')).div(rate);
+            expect(postTxIncomingAssetBalance).toEqBigNumber(preTxIncomingAssetBalance.add(expectedCTokenAmount));
+            expect(postTxOutgoingAssetBalance).toEqBigNumber(preTxOutgoingAssetBalance.sub(tokenAmount));
+            return _context.abrupt("return", lendReceipt);
+
+          case 35:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _assertCompoundLend.apply(this, arguments);
+}
+
+function assertCompoundRedeem(_x2) {
+  return _assertCompoundRedeem.apply(this, arguments);
+}
+
+function _assertCompoundRedeem() {
+  _assertCompoundRedeem = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee2(_ref2) {
+    var comptrollerProxy, vaultProxy, integrationManager, fundOwner, compoundAdapter, cToken, compoundPriceFeed, cTokenAmount, token, _yield$getAssetBalanc5, _yield$getAssetBalanc6, preTxIncomingAssetBalance, preTxOutgoingAssetBalance, rateBefore, minIncomingTokenAmount, redeemReceipt, _yield$getAssetBalanc7, _yield$getAssetBalanc8, postTxIncomingAssetBalance, postTxOutgoingAssetBalance, rate, expectedTokenAmount;
+
+    return _regeneratorRuntime__default['default'].wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            comptrollerProxy = _ref2.comptrollerProxy, vaultProxy = _ref2.vaultProxy, integrationManager = _ref2.integrationManager, fundOwner = _ref2.fundOwner, compoundAdapter = _ref2.compoundAdapter, cToken = _ref2.cToken, compoundPriceFeed = _ref2.compoundPriceFeed;
+            _context2.t0 = ethers.utils;
+            _context2.next = 4;
+            return cToken.decimals();
+
+          case 4:
+            _context2.t1 = _context2.sent;
+            cTokenAmount = _context2.t0.parseUnits.call(_context2.t0, '1', _context2.t1);
+            _context2.next = 8;
+            return cToken.transfer(vaultProxy, cTokenAmount);
+
+          case 8:
+            _context2.t2 = protocol.StandardToken;
+            _context2.next = 11;
+            return compoundPriceFeed.getTokenFromCToken.args(cToken).call();
+
+          case 11:
+            _context2.t3 = _context2.sent;
+            _context2.t4 = provider;
+            token = new _context2.t2(_context2.t3, _context2.t4);
+            _context2.next = 16;
+            return getAssetBalances({
+              account: vaultProxy,
+              assets: [token, cToken]
+            });
+
+          case 16:
+            _yield$getAssetBalanc5 = _context2.sent;
+            _yield$getAssetBalanc6 = _slicedToArray(_yield$getAssetBalanc5, 2);
+            preTxIncomingAssetBalance = _yield$getAssetBalanc6[0];
+            preTxOutgoingAssetBalance = _yield$getAssetBalanc6[1];
+            _context2.next = 22;
+            return cToken.exchangeRateStored();
+
+          case 22:
+            rateBefore = _context2.sent;
+            minIncomingTokenAmount = cTokenAmount.mul(rateBefore).div(ethers.utils.parseEther('1'));
+            _context2.next = 26;
+            return compoundRedeem({
+              cToken: cToken,
+              cTokenAmount: cTokenAmount,
+              compoundAdapter: compoundAdapter,
+              comptrollerProxy: comptrollerProxy,
+              fundOwner: fundOwner,
+              integrationManager: integrationManager,
+              tokenAmount: minIncomingTokenAmount,
+              vaultProxy: vaultProxy
+            });
+
+          case 26:
+            redeemReceipt = _context2.sent;
+            _context2.next = 29;
+            return getAssetBalances({
+              account: vaultProxy,
+              assets: [token, cToken]
+            });
+
+          case 29:
+            _yield$getAssetBalanc7 = _context2.sent;
+            _yield$getAssetBalanc8 = _slicedToArray(_yield$getAssetBalanc7, 2);
+            postTxIncomingAssetBalance = _yield$getAssetBalanc8[0];
+            postTxOutgoingAssetBalance = _yield$getAssetBalanc8[1];
+            _context2.next = 35;
+            return cToken.exchangeRateStored();
+
+          case 35:
+            rate = _context2.sent;
+            expectedTokenAmount = cTokenAmount.mul(rate).div(ethers.utils.parseEther('1'));
+            expect(postTxIncomingAssetBalance).toEqBigNumber(preTxIncomingAssetBalance.add(expectedTokenAmount));
+            expect(postTxOutgoingAssetBalance).toEqBigNumber(preTxOutgoingAssetBalance.sub(cTokenAmount));
+            return _context2.abrupt("return", redeemReceipt);
+
+          case 40:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _assertCompoundRedeem.apply(this, arguments);
+}
+
+function compoundClaim(_x3) {
+  return _compoundClaim.apply(this, arguments);
+}
+
+function _compoundClaim() {
+  _compoundClaim = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee3(_ref3) {
+    var comptrollerProxy, integrationManager, fundOwner, compoundAdapter, compoundComptroller, cTokens, claimArgs, callArgs, claimRewardsTx;
+    return _regeneratorRuntime__default['default'].wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            comptrollerProxy = _ref3.comptrollerProxy, integrationManager = _ref3.integrationManager, fundOwner = _ref3.fundOwner, compoundAdapter = _ref3.compoundAdapter, compoundComptroller = _ref3.compoundComptroller, cTokens = _ref3.cTokens;
+            claimArgs = protocol.compoundClaimRewardsArgs({
+              cTokens: cTokens,
+              compoundComptroller: compoundComptroller
+            });
+            callArgs = protocol.callOnIntegrationArgs({
+              adapter: compoundAdapter,
+              encodedCallArgs: claimArgs,
+              selector: protocol.claimRewardsSelector
+            });
+            claimRewardsTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+            return _context3.abrupt("return", claimRewardsTx);
+
+          case 5:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _compoundClaim.apply(this, arguments);
+}
+
+function compoundLend(_x4) {
+  return _compoundLend.apply(this, arguments);
+}
+
+function _compoundLend() {
+  _compoundLend = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee4(_ref4) {
+    var comptrollerProxy, integrationManager, fundOwner, compoundAdapter, cToken, _ref4$tokenAmount, tokenAmount, _ref4$cTokenAmount, cTokenAmount, lendArgs, callArgs, lendTx;
+
+    return _regeneratorRuntime__default['default'].wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            comptrollerProxy = _ref4.comptrollerProxy, integrationManager = _ref4.integrationManager, fundOwner = _ref4.fundOwner, compoundAdapter = _ref4.compoundAdapter, cToken = _ref4.cToken, _ref4$tokenAmount = _ref4.tokenAmount, tokenAmount = _ref4$tokenAmount === void 0 ? ethers.utils.parseEther('1') : _ref4$tokenAmount, _ref4$cTokenAmount = _ref4.cTokenAmount, cTokenAmount = _ref4$cTokenAmount === void 0 ? ethers.utils.parseEther('1') : _ref4$cTokenAmount;
             lendArgs = protocol.compoundArgs({
               cToken: cToken,
               minIncomingAssetAmount: cTokenAmount,
@@ -1550,31 +1978,31 @@ function _compoundLend() {
               selector: protocol.lendSelector
             });
             lendTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-            return _context.abrupt("return", lendTx);
+            return _context4.abrupt("return", lendTx);
 
           case 5:
           case "end":
-            return _context.stop();
+            return _context4.stop();
         }
       }
-    }, _callee);
+    }, _callee4);
   }));
   return _compoundLend.apply(this, arguments);
 }
 
-function compoundRedeem(_x2) {
+function compoundRedeem(_x5) {
   return _compoundRedeem.apply(this, arguments);
 }
 
 function _compoundRedeem() {
-  _compoundRedeem = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee2(_ref2) {
-    var comptrollerProxy, integrationManager, fundOwner, compoundAdapter, cToken, _ref2$tokenAmount, tokenAmount, _ref2$cTokenAmount, cTokenAmount, redeemArgs, callArgs, redeemTx;
+  _compoundRedeem = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee5(_ref5) {
+    var comptrollerProxy, integrationManager, fundOwner, compoundAdapter, cToken, _ref5$tokenAmount, tokenAmount, _ref5$cTokenAmount, cTokenAmount, redeemArgs, callArgs, redeemTx;
 
-    return _regeneratorRuntime__default['default'].wrap(function _callee2$(_context2) {
+    return _regeneratorRuntime__default['default'].wrap(function _callee5$(_context5) {
       while (1) {
-        switch (_context2.prev = _context2.next) {
+        switch (_context5.prev = _context5.next) {
           case 0:
-            comptrollerProxy = _ref2.comptrollerProxy, integrationManager = _ref2.integrationManager, fundOwner = _ref2.fundOwner, compoundAdapter = _ref2.compoundAdapter, cToken = _ref2.cToken, _ref2$tokenAmount = _ref2.tokenAmount, tokenAmount = _ref2$tokenAmount === void 0 ? ethers.utils.parseEther('1') : _ref2$tokenAmount, _ref2$cTokenAmount = _ref2.cTokenAmount, cTokenAmount = _ref2$cTokenAmount === void 0 ? ethers.utils.parseEther('1') : _ref2$cTokenAmount;
+            comptrollerProxy = _ref5.comptrollerProxy, integrationManager = _ref5.integrationManager, fundOwner = _ref5.fundOwner, compoundAdapter = _ref5.compoundAdapter, cToken = _ref5.cToken, _ref5$tokenAmount = _ref5.tokenAmount, tokenAmount = _ref5$tokenAmount === void 0 ? ethers.utils.parseEther('1') : _ref5$tokenAmount, _ref5$cTokenAmount = _ref5.cTokenAmount, cTokenAmount = _ref5$cTokenAmount === void 0 ? ethers.utils.parseEther('1') : _ref5$cTokenAmount;
             redeemArgs = protocol.compoundArgs({
               cToken: ethers$1.resolveAddress(cToken),
               minIncomingAssetAmount: tokenAmount,
@@ -1586,27 +2014,28 @@ function _compoundRedeem() {
               selector: protocol.redeemSelector
             });
             redeemTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-            return _context2.abrupt("return", redeemTx);
+            return _context5.abrupt("return", redeemTx);
 
           case 5:
           case "end":
-            return _context2.stop();
+            return _context5.stop();
         }
       }
-    }, _callee2);
+    }, _callee5);
   }));
   return _compoundRedeem.apply(this, arguments);
 }
 
-var _templateObject$1, _templateObject2, _templateObject3;
-var CurveLiquidityGaugeV2 = ethers$1.contract()(_templateObject$1 || (_templateObject$1 = _taggedTemplateLiteral(["\n  function claim_rewards(address)\n  function integrate_fraction(address) view returns (uint256)\n"]))); // prettier-ignore
+var _templateObject$1, _templateObject2, _templateObject3, _templateObject4;
+var CurveLiquidityGaugeV2 = ethers$1.contract()(_templateObject$1 || (_templateObject$1 = _taggedTemplateLiteral(["\n  function claim_rewards(address)\n  function integrate_fraction(address) view returns (uint256)\n"])));
+var CurveRegistry = ethers$1.contract()(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  function get_coins(address) view returns (address[8])\n  function get_lp_token(address) view returns (address)\n"]))); // prettier-ignore
 
-var CurveSwaps = ethers$1.contract()(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  function get_best_rate(address _from, address to, uint256 amount) view returns (address bestPool, uint256 amountReceived)\n"])));
-var CurveMinter = ethers$1.contract()(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  function mint_for(address,address)\n"]))); // exchanges
+var CurveSwaps = ethers$1.contract()(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  function get_best_rate(address _from, address to, uint256 amount) view returns (address bestPool, uint256 amountReceived)\n"])));
+var CurveMinter = ethers$1.contract()(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  function mint_for(address,address)\n"]))); // exchanges
 
 function curveTakeOrder(_x) {
   return _curveTakeOrder.apply(this, arguments);
-} // aave pool
+} // combined liquidity
 
 function _curveTakeOrder() {
   _curveTakeOrder = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee(_ref) {
@@ -1631,542 +2060,237 @@ function _curveTakeOrder() {
             });
             return _context.abrupt("return", comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs));
 
-          case 4:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee);
-  }));
-  return _curveTakeOrder.apply(this, arguments);
-}
-
-function curveAaveClaimRewards(_ref2) {
-  var comptrollerProxy = _ref2.comptrollerProxy,
-      integrationManager = _ref2.integrationManager,
-      fundOwner = _ref2.fundOwner,
-      curveLiquidityAaveAdapter = _ref2.curveLiquidityAaveAdapter;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityAaveAdapter,
-    encodedCallArgs: ethers.constants.HashZero,
-    selector: protocol.claimRewardsSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveAaveLend(_ref3) {
-  var comptrollerProxy = _ref3.comptrollerProxy,
-      integrationManager = _ref3.integrationManager,
-      fundOwner = _ref3.fundOwner,
-      curveLiquidityAaveAdapter = _ref3.curveLiquidityAaveAdapter,
-      _ref3$outgoingAaveDai = _ref3.outgoingAaveDaiAmount,
-      outgoingAaveDaiAmount = _ref3$outgoingAaveDai === void 0 ? ethers.BigNumber.from(0) : _ref3$outgoingAaveDai,
-      _ref3$outgoingAaveUsd = _ref3.outgoingAaveUsdcAmount,
-      outgoingAaveUsdcAmount = _ref3$outgoingAaveUsd === void 0 ? ethers.BigNumber.from(0) : _ref3$outgoingAaveUsd,
-      _ref3$outgoingAaveUsd2 = _ref3.outgoingAaveUsdtAmount,
-      outgoingAaveUsdtAmount = _ref3$outgoingAaveUsd2 === void 0 ? ethers.BigNumber.from(0) : _ref3$outgoingAaveUsd2,
-      _ref3$minIncomingLPTo = _ref3.minIncomingLPTokenAmount,
-      minIncomingLPTokenAmount = _ref3$minIncomingLPTo === void 0 ? ethers.BigNumber.from(1) : _ref3$minIncomingLPTo,
-      _ref3$useUnderlyings = _ref3.useUnderlyings,
-      useUnderlyings = _ref3$useUnderlyings === void 0 ? false : _ref3$useUnderlyings;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityAaveAdapter,
-    encodedCallArgs: protocol.curveAaveLendArgs({
-      minIncomingLPTokenAmount: minIncomingLPTokenAmount,
-      outgoingAaveDaiAmount: outgoingAaveDaiAmount,
-      outgoingAaveUsdcAmount: outgoingAaveUsdcAmount,
-      outgoingAaveUsdtAmount: outgoingAaveUsdtAmount,
-      useUnderlyings: useUnderlyings
-    }),
-    selector: protocol.lendSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveAaveLendAndStake(_ref4) {
-  var comptrollerProxy = _ref4.comptrollerProxy,
-      integrationManager = _ref4.integrationManager,
-      fundOwner = _ref4.fundOwner,
-      curveLiquidityAaveAdapter = _ref4.curveLiquidityAaveAdapter,
-      _ref4$outgoingAaveDai = _ref4.outgoingAaveDaiAmount,
-      outgoingAaveDaiAmount = _ref4$outgoingAaveDai === void 0 ? ethers.BigNumber.from(0) : _ref4$outgoingAaveDai,
-      _ref4$outgoingAaveUsd = _ref4.outgoingAaveUsdcAmount,
-      outgoingAaveUsdcAmount = _ref4$outgoingAaveUsd === void 0 ? ethers.BigNumber.from(0) : _ref4$outgoingAaveUsd,
-      _ref4$outgoingAaveUsd2 = _ref4.outgoingAaveUsdtAmount,
-      outgoingAaveUsdtAmount = _ref4$outgoingAaveUsd2 === void 0 ? ethers.BigNumber.from(0) : _ref4$outgoingAaveUsd2,
-      _ref4$minIncomingLiqu = _ref4.minIncomingLiquidityGaugeTokenAmount,
-      minIncomingLiquidityGaugeTokenAmount = _ref4$minIncomingLiqu === void 0 ? ethers.BigNumber.from(1) : _ref4$minIncomingLiqu,
-      _ref4$useUnderlyings = _ref4.useUnderlyings,
-      useUnderlyings = _ref4$useUnderlyings === void 0 ? false : _ref4$useUnderlyings;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityAaveAdapter,
-    encodedCallArgs: protocol.curveAaveLendAndStakeArgs({
-      minIncomingLiquidityGaugeTokenAmount: minIncomingLiquidityGaugeTokenAmount,
-      outgoingAaveDaiAmount: outgoingAaveDaiAmount,
-      outgoingAaveUsdcAmount: outgoingAaveUsdcAmount,
-      outgoingAaveUsdtAmount: outgoingAaveUsdtAmount,
-      useUnderlyings: useUnderlyings
-    }),
-    selector: protocol.lendAndStakeSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveAaveRedeem(_ref5) {
-  var comptrollerProxy = _ref5.comptrollerProxy,
-      integrationManager = _ref5.integrationManager,
-      fundOwner = _ref5.fundOwner,
-      curveLiquidityAaveAdapter = _ref5.curveLiquidityAaveAdapter,
-      outgoingLPTokenAmount = _ref5.outgoingLPTokenAmount,
-      _ref5$minIncomingAave = _ref5.minIncomingAaveDaiAmount,
-      minIncomingAaveDaiAmount = _ref5$minIncomingAave === void 0 ? ethers.BigNumber.from(1) : _ref5$minIncomingAave,
-      _ref5$minIncomingAave2 = _ref5.minIncomingAaveUsdcAmount,
-      minIncomingAaveUsdcAmount = _ref5$minIncomingAave2 === void 0 ? ethers.BigNumber.from(1) : _ref5$minIncomingAave2,
-      _ref5$minIncomingAave3 = _ref5.minIncomingAaveUsdtAmount,
-      minIncomingAaveUsdtAmount = _ref5$minIncomingAave3 === void 0 ? ethers.BigNumber.from(1) : _ref5$minIncomingAave3,
-      _ref5$receiveSingleAs = _ref5.receiveSingleAsset,
-      receiveSingleAsset = _ref5$receiveSingleAs === void 0 ? false : _ref5$receiveSingleAs,
-      _ref5$useUnderlyings = _ref5.useUnderlyings,
-      useUnderlyings = _ref5$useUnderlyings === void 0 ? false : _ref5$useUnderlyings;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityAaveAdapter,
-    encodedCallArgs: protocol.curveAaveRedeemArgs({
-      minIncomingAaveDaiAmount: minIncomingAaveDaiAmount,
-      minIncomingAaveUsdcAmount: minIncomingAaveUsdcAmount,
-      minIncomingAaveUsdtAmount: minIncomingAaveUsdtAmount,
-      outgoingLPTokenAmount: outgoingLPTokenAmount,
-      receiveSingleAsset: receiveSingleAsset,
-      useUnderlyings: useUnderlyings
-    }),
-    selector: protocol.redeemSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveAaveStake(_ref6) {
-  var comptrollerProxy = _ref6.comptrollerProxy,
-      integrationManager = _ref6.integrationManager,
-      fundOwner = _ref6.fundOwner,
-      curveLiquidityAaveAdapter = _ref6.curveLiquidityAaveAdapter,
-      outgoingLPTokenAmount = _ref6.outgoingLPTokenAmount;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityAaveAdapter,
-    encodedCallArgs: protocol.curveAaveStakeArgs({
-      outgoingLPTokenAmount: outgoingLPTokenAmount
-    }),
-    selector: protocol.stakeSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveAaveUnstakeAndRedeem(_ref7) {
-  var comptrollerProxy = _ref7.comptrollerProxy,
-      integrationManager = _ref7.integrationManager,
-      fundOwner = _ref7.fundOwner,
-      curveLiquidityAaveAdapter = _ref7.curveLiquidityAaveAdapter,
-      outgoingLiquidityGaugeTokenAmount = _ref7.outgoingLiquidityGaugeTokenAmount,
-      _ref7$minIncomingAave = _ref7.minIncomingAaveDaiAmount,
-      minIncomingAaveDaiAmount = _ref7$minIncomingAave === void 0 ? ethers.BigNumber.from(1) : _ref7$minIncomingAave,
-      _ref7$minIncomingAave2 = _ref7.minIncomingAaveUsdcAmount,
-      minIncomingAaveUsdcAmount = _ref7$minIncomingAave2 === void 0 ? ethers.BigNumber.from(1) : _ref7$minIncomingAave2,
-      _ref7$minIncomingAave3 = _ref7.minIncomingAaveUsdtAmount,
-      minIncomingAaveUsdtAmount = _ref7$minIncomingAave3 === void 0 ? ethers.BigNumber.from(1) : _ref7$minIncomingAave3,
-      _ref7$receiveSingleAs = _ref7.receiveSingleAsset,
-      receiveSingleAsset = _ref7$receiveSingleAs === void 0 ? false : _ref7$receiveSingleAs,
-      _ref7$useUnderlyings = _ref7.useUnderlyings,
-      useUnderlyings = _ref7$useUnderlyings === void 0 ? false : _ref7$useUnderlyings;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityAaveAdapter,
-    encodedCallArgs: protocol.curveAaveUnstakeAndRedeemArgs({
-      minIncomingAaveDaiAmount: minIncomingAaveDaiAmount,
-      minIncomingAaveUsdcAmount: minIncomingAaveUsdcAmount,
-      minIncomingAaveUsdtAmount: minIncomingAaveUsdtAmount,
-      outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount,
-      receiveSingleAsset: receiveSingleAsset,
-      useUnderlyings: useUnderlyings
-    }),
-    selector: protocol.unstakeAndRedeemSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveAaveUnstake(_ref8) {
-  var comptrollerProxy = _ref8.comptrollerProxy,
-      integrationManager = _ref8.integrationManager,
-      fundOwner = _ref8.fundOwner,
-      curveLiquidityAaveAdapter = _ref8.curveLiquidityAaveAdapter,
-      outgoingLiquidityGaugeTokenAmount = _ref8.outgoingLiquidityGaugeTokenAmount;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityAaveAdapter,
-    encodedCallArgs: protocol.curveAaveUnstakeArgs({
-      outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount
-    }),
-    selector: protocol.unstakeSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-} // eurs pool
-
-function curveEursClaimRewards(_ref9) {
-  var comptrollerProxy = _ref9.comptrollerProxy,
-      integrationManager = _ref9.integrationManager,
-      fundOwner = _ref9.fundOwner,
-      curveLiquidityEursAdapter = _ref9.curveLiquidityEursAdapter;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: ethers.constants.HashZero,
-    selector: protocol.claimRewardsSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveEursLend(_ref10) {
-  var comptrollerProxy = _ref10.comptrollerProxy,
-      integrationManager = _ref10.integrationManager,
-      fundOwner = _ref10.fundOwner,
-      curveLiquidityEursAdapter = _ref10.curveLiquidityEursAdapter,
-      outgoingEursAmount = _ref10.outgoingEursAmount,
-      outgoingSeurAmount = _ref10.outgoingSeurAmount,
-      minIncomingLPTokenAmount = _ref10.minIncomingLPTokenAmount;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: protocol.curveEursLendArgs({
-      minIncomingLPTokenAmount: minIncomingLPTokenAmount,
-      outgoingEursAmount: outgoingEursAmount,
-      outgoingSeurAmount: outgoingSeurAmount
-    }),
-    selector: protocol.lendSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveEursLendAndStake(_ref11) {
-  var comptrollerProxy = _ref11.comptrollerProxy,
-      integrationManager = _ref11.integrationManager,
-      fundOwner = _ref11.fundOwner,
-      curveLiquidityEursAdapter = _ref11.curveLiquidityEursAdapter,
-      outgoingEursAmount = _ref11.outgoingEursAmount,
-      outgoingSeurAmount = _ref11.outgoingSeurAmount,
-      minIncomingLiquidityGaugeTokenAmount = _ref11.minIncomingLiquidityGaugeTokenAmount;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: protocol.curveEursLendAndStakeArgs({
-      minIncomingLiquidityGaugeTokenAmount: minIncomingLiquidityGaugeTokenAmount,
-      outgoingEursAmount: outgoingEursAmount,
-      outgoingSeurAmount: outgoingSeurAmount
-    }),
-    selector: protocol.lendAndStakeSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveEursRedeem(_ref12) {
-  var comptrollerProxy = _ref12.comptrollerProxy,
-      integrationManager = _ref12.integrationManager,
-      fundOwner = _ref12.fundOwner,
-      curveLiquidityEursAdapter = _ref12.curveLiquidityEursAdapter,
-      outgoingLPTokenAmount = _ref12.outgoingLPTokenAmount,
-      minIncomingEursAmount = _ref12.minIncomingEursAmount,
-      minIncomingSeurAmount = _ref12.minIncomingSeurAmount,
-      receiveSingleAsset = _ref12.receiveSingleAsset;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: protocol.curveEursRedeemArgs({
-      minIncomingEursAmount: minIncomingEursAmount,
-      minIncomingSeurAmount: minIncomingSeurAmount,
-      outgoingLPTokenAmount: outgoingLPTokenAmount,
-      receiveSingleAsset: receiveSingleAsset
-    }),
-    selector: protocol.redeemSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveEursStake(_ref13) {
-  var comptrollerProxy = _ref13.comptrollerProxy,
-      integrationManager = _ref13.integrationManager,
-      fundOwner = _ref13.fundOwner,
-      curveLiquidityEursAdapter = _ref13.curveLiquidityEursAdapter,
-      outgoingLPTokenAmount = _ref13.outgoingLPTokenAmount;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: protocol.curveEursStakeArgs({
-      outgoingLPTokenAmount: outgoingLPTokenAmount
-    }),
-    selector: protocol.stakeSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveEursUnstakeAndRedeem(_ref14) {
-  var comptrollerProxy = _ref14.comptrollerProxy,
-      integrationManager = _ref14.integrationManager,
-      fundOwner = _ref14.fundOwner,
-      curveLiquidityEursAdapter = _ref14.curveLiquidityEursAdapter,
-      outgoingLiquidityGaugeTokenAmount = _ref14.outgoingLiquidityGaugeTokenAmount,
-      minIncomingEursAmount = _ref14.minIncomingEursAmount,
-      minIncomingSeurAmount = _ref14.minIncomingSeurAmount,
-      receiveSingleAsset = _ref14.receiveSingleAsset;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: protocol.curveEursUnstakeAndRedeemArgs({
-      minIncomingEursAmount: minIncomingEursAmount,
-      minIncomingSeurAmount: minIncomingSeurAmount,
-      outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount,
-      receiveSingleAsset: receiveSingleAsset
-    }),
-    selector: protocol.unstakeAndRedeemSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _curveTakeOrder.apply(this, arguments);
 }
-function curveEursUnstake(_ref15) {
-  var comptrollerProxy = _ref15.comptrollerProxy,
-      integrationManager = _ref15.integrationManager,
-      fundOwner = _ref15.fundOwner,
-      curveLiquidityEursAdapter = _ref15.curveLiquidityEursAdapter,
-      outgoingLiquidityGaugeTokenAmount = _ref15.outgoingLiquidityGaugeTokenAmount;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: protocol.curveEursUnstakeArgs({
-      outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount
-    }),
-    selector: protocol.unstakeSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-} // sETH pool
 
-function curveSethClaimRewards(_ref16) {
-  var comptrollerProxy = _ref16.comptrollerProxy,
-      integrationManager = _ref16.integrationManager,
-      fundOwner = _ref16.fundOwner,
-      curveLiquiditySethAdapter = _ref16.curveLiquiditySethAdapter;
+function curveClaimRewards(_ref2) {
+  var comptrollerProxy = _ref2.comptrollerProxy,
+      integrationManager = _ref2.integrationManager,
+      fundOwner = _ref2.fundOwner,
+      curveLiquidityAdapter = _ref2.curveLiquidityAdapter,
+      stakingToken = _ref2.stakingToken;
   var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: ethers.constants.HashZero,
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: protocol.curveClaimRewardsArgs({
+      stakingToken: stakingToken
+    }),
     selector: protocol.claimRewardsSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
-function curveSethLend(_ref17) {
-  var comptrollerProxy = _ref17.comptrollerProxy,
-      integrationManager = _ref17.integrationManager,
-      fundOwner = _ref17.fundOwner,
-      curveLiquiditySethAdapter = _ref17.curveLiquiditySethAdapter,
-      outgoingWethAmount = _ref17.outgoingWethAmount,
-      outgoingSethAmount = _ref17.outgoingSethAmount,
-      minIncomingLPTokenAmount = _ref17.minIncomingLPTokenAmount;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: protocol.curveSethLendArgs({
-      minIncomingLPTokenAmount: minIncomingLPTokenAmount,
-      outgoingSethAmount: outgoingSethAmount,
-      outgoingWethAmount: outgoingWethAmount
-    }),
-    selector: protocol.lendSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+function curveLend(_x2) {
+  return _curveLend.apply(this, arguments);
 }
-function curveSethLendAndStake(_ref18) {
-  var comptrollerProxy = _ref18.comptrollerProxy,
-      integrationManager = _ref18.integrationManager,
-      fundOwner = _ref18.fundOwner,
-      curveLiquiditySethAdapter = _ref18.curveLiquiditySethAdapter,
-      outgoingWethAmount = _ref18.outgoingWethAmount,
-      outgoingSethAmount = _ref18.outgoingSethAmount,
-      minIncomingLiquidityGaugeTokenAmount = _ref18.minIncomingLiquidityGaugeTokenAmount;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: protocol.curveSethLendAndStakeArgs({
-      minIncomingLiquidityGaugeTokenAmount: minIncomingLiquidityGaugeTokenAmount,
-      outgoingSethAmount: outgoingSethAmount,
-      outgoingWethAmount: outgoingWethAmount
-    }),
-    selector: protocol.lendAndStakeSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+function _curveLend() {
+  _curveLend = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee2(_ref3) {
+    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, orderedOutgoingAssetAmounts, _ref3$minIncomingLpTo, minIncomingLpTokenAmount, useUnderlyings, callArgs;
+
+    return _regeneratorRuntime__default['default'].wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            comptrollerProxy = _ref3.comptrollerProxy, integrationManager = _ref3.integrationManager, signer = _ref3.signer, curveLiquidityAdapter = _ref3.curveLiquidityAdapter, pool = _ref3.pool, orderedOutgoingAssetAmounts = _ref3.orderedOutgoingAssetAmounts, _ref3$minIncomingLpTo = _ref3.minIncomingLpTokenAmount, minIncomingLpTokenAmount = _ref3$minIncomingLpTo === void 0 ? ethers.BigNumber.from(1) : _ref3$minIncomingLpTo, useUnderlyings = _ref3.useUnderlyings;
+            callArgs = protocol.callOnIntegrationArgs({
+              adapter: curveLiquidityAdapter,
+              encodedCallArgs: protocol.curveLendArgs({
+                minIncomingLpTokenAmount: minIncomingLpTokenAmount,
+                orderedOutgoingAssetAmounts: orderedOutgoingAssetAmounts,
+                pool: pool,
+                useUnderlyings: useUnderlyings
+              }),
+              selector: protocol.lendSelector
+            });
+            return _context2.abrupt("return", comptrollerProxy.connect(signer).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs));
+
+          case 3:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _curveLend.apply(this, arguments);
 }
-function curveSethRedeem(_ref19) {
-  var comptrollerProxy = _ref19.comptrollerProxy,
-      integrationManager = _ref19.integrationManager,
-      fundOwner = _ref19.fundOwner,
-      curveLiquiditySethAdapter = _ref19.curveLiquiditySethAdapter,
-      outgoingLPTokenAmount = _ref19.outgoingLPTokenAmount,
-      minIncomingWethAmount = _ref19.minIncomingWethAmount,
-      minIncomingSethAmount = _ref19.minIncomingSethAmount,
-      receiveSingleAsset = _ref19.receiveSingleAsset;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: protocol.curveSethRedeemArgs({
-      minIncomingSethAmount: minIncomingSethAmount,
-      minIncomingWethAmount: minIncomingWethAmount,
-      outgoingLPTokenAmount: outgoingLPTokenAmount,
-      receiveSingleAsset: receiveSingleAsset
-    }),
-    selector: protocol.redeemSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+function curveLendAndStake(_x3) {
+  return _curveLendAndStake.apply(this, arguments);
 }
-function curveSethStake(_ref20) {
-  var comptrollerProxy = _ref20.comptrollerProxy,
-      integrationManager = _ref20.integrationManager,
-      fundOwner = _ref20.fundOwner,
-      curveLiquiditySethAdapter = _ref20.curveLiquiditySethAdapter,
-      outgoingLPTokenAmount = _ref20.outgoingLPTokenAmount;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: protocol.curveSethStakeArgs({
-      outgoingLPTokenAmount: outgoingLPTokenAmount
-    }),
-    selector: protocol.stakeSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+function _curveLendAndStake() {
+  _curveLendAndStake = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee3(_ref4) {
+    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, orderedOutgoingAssetAmounts, incomingStakingToken, _ref4$minIncomingStak, minIncomingStakingTokenAmount, useUnderlyings, callArgs;
+
+    return _regeneratorRuntime__default['default'].wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            comptrollerProxy = _ref4.comptrollerProxy, integrationManager = _ref4.integrationManager, signer = _ref4.signer, curveLiquidityAdapter = _ref4.curveLiquidityAdapter, pool = _ref4.pool, orderedOutgoingAssetAmounts = _ref4.orderedOutgoingAssetAmounts, incomingStakingToken = _ref4.incomingStakingToken, _ref4$minIncomingStak = _ref4.minIncomingStakingTokenAmount, minIncomingStakingTokenAmount = _ref4$minIncomingStak === void 0 ? ethers.BigNumber.from(1) : _ref4$minIncomingStak, useUnderlyings = _ref4.useUnderlyings;
+            callArgs = protocol.callOnIntegrationArgs({
+              adapter: curveLiquidityAdapter,
+              encodedCallArgs: protocol.curveLendAndStakeArgs({
+                incomingStakingToken: incomingStakingToken,
+                minIncomingStakingTokenAmount: minIncomingStakingTokenAmount,
+                orderedOutgoingAssetAmounts: orderedOutgoingAssetAmounts,
+                pool: pool,
+                useUnderlyings: useUnderlyings
+              }),
+              selector: protocol.lendAndStakeSelector
+            });
+            return _context3.abrupt("return", comptrollerProxy.connect(signer).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs));
+
+          case 3:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _curveLendAndStake.apply(this, arguments);
 }
-function curveSethUnstakeAndRedeem(_ref21) {
-  var comptrollerProxy = _ref21.comptrollerProxy,
-      integrationManager = _ref21.integrationManager,
-      fundOwner = _ref21.fundOwner,
-      curveLiquiditySethAdapter = _ref21.curveLiquiditySethAdapter,
-      outgoingLiquidityGaugeTokenAmount = _ref21.outgoingLiquidityGaugeTokenAmount,
-      minIncomingWethAmount = _ref21.minIncomingWethAmount,
-      minIncomingSethAmount = _ref21.minIncomingSethAmount,
-      receiveSingleAsset = _ref21.receiveSingleAsset;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: protocol.curveSethUnstakeAndRedeemArgs({
-      minIncomingSethAmount: minIncomingSethAmount,
-      minIncomingWethAmount: minIncomingWethAmount,
-      outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount,
-      receiveSingleAsset: receiveSingleAsset
-    }),
-    selector: protocol.unstakeAndRedeemSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+function curveRedeem(_x4) {
+  return _curveRedeem.apply(this, arguments);
 }
-function curveSethUnstake(_ref22) {
-  var comptrollerProxy = _ref22.comptrollerProxy,
-      integrationManager = _ref22.integrationManager,
-      fundOwner = _ref22.fundOwner,
-      curveLiquiditySethAdapter = _ref22.curveLiquiditySethAdapter,
-      outgoingLiquidityGaugeTokenAmount = _ref22.outgoingLiquidityGaugeTokenAmount;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: protocol.curveSethUnstakeArgs({
-      outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount
-    }),
-    selector: protocol.unstakeSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
-} // stETH pool
 
-function curveStethClaimRewards(_ref23) {
-  var comptrollerProxy = _ref23.comptrollerProxy,
-      integrationManager = _ref23.integrationManager,
-      fundOwner = _ref23.fundOwner,
-      curveLiquidityStethAdapter = _ref23.curveLiquidityStethAdapter;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityStethAdapter,
-    encodedCallArgs: ethers.constants.HashZero,
-    selector: protocol.claimRewardsSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+function _curveRedeem() {
+  _curveRedeem = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee4(_ref5) {
+    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, outgoingLpTokenAmount, useUnderlyings, redeemType, incomingAssetData, callArgs;
+    return _regeneratorRuntime__default['default'].wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            comptrollerProxy = _ref5.comptrollerProxy, integrationManager = _ref5.integrationManager, signer = _ref5.signer, curveLiquidityAdapter = _ref5.curveLiquidityAdapter, pool = _ref5.pool, outgoingLpTokenAmount = _ref5.outgoingLpTokenAmount, useUnderlyings = _ref5.useUnderlyings, redeemType = _ref5.redeemType, incomingAssetData = _ref5.incomingAssetData;
+            callArgs = protocol.callOnIntegrationArgs({
+              adapter: curveLiquidityAdapter,
+              encodedCallArgs: protocol.curveRedeemArgs({
+                incomingAssetData: incomingAssetData,
+                outgoingLpTokenAmount: outgoingLpTokenAmount,
+                pool: pool,
+                redeemType: redeemType,
+                useUnderlyings: useUnderlyings
+              }),
+              selector: protocol.redeemSelector
+            });
+            return _context4.abrupt("return", comptrollerProxy.connect(signer).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs));
+
+          case 3:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _curveRedeem.apply(this, arguments);
 }
-function curveStethLend(_ref24) {
-  var comptrollerProxy = _ref24.comptrollerProxy,
-      integrationManager = _ref24.integrationManager,
-      fundOwner = _ref24.fundOwner,
-      curveLiquidityStethAdapter = _ref24.curveLiquidityStethAdapter,
-      outgoingWethAmount = _ref24.outgoingWethAmount,
-      outgoingStethAmount = _ref24.outgoingStethAmount,
-      minIncomingLPTokenAmount = _ref24.minIncomingLPTokenAmount;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityStethAdapter,
-    encodedCallArgs: protocol.curveStethLendArgs({
-      minIncomingLPTokenAmount: minIncomingLPTokenAmount,
-      outgoingStethAmount: outgoingStethAmount,
-      outgoingWethAmount: outgoingWethAmount
-    }),
-    selector: protocol.lendSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+function curveStake(_x5) {
+  return _curveStake.apply(this, arguments);
 }
-function curveStethLendAndStake(_ref25) {
-  var comptrollerProxy = _ref25.comptrollerProxy,
-      integrationManager = _ref25.integrationManager,
-      fundOwner = _ref25.fundOwner,
-      curveLiquidityStethAdapter = _ref25.curveLiquidityStethAdapter,
-      outgoingWethAmount = _ref25.outgoingWethAmount,
-      outgoingStethAmount = _ref25.outgoingStethAmount,
-      minIncomingLiquidityGaugeTokenAmount = _ref25.minIncomingLiquidityGaugeTokenAmount;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityStethAdapter,
-    encodedCallArgs: protocol.curveStethLendAndStakeArgs({
-      minIncomingLiquidityGaugeTokenAmount: minIncomingLiquidityGaugeTokenAmount,
-      outgoingStethAmount: outgoingStethAmount,
-      outgoingWethAmount: outgoingWethAmount
-    }),
-    selector: protocol.lendAndStakeSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+function _curveStake() {
+  _curveStake = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee5(_ref6) {
+    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, incomingStakingToken, amount, callArgs;
+    return _regeneratorRuntime__default['default'].wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            comptrollerProxy = _ref6.comptrollerProxy, integrationManager = _ref6.integrationManager, signer = _ref6.signer, curveLiquidityAdapter = _ref6.curveLiquidityAdapter, pool = _ref6.pool, incomingStakingToken = _ref6.incomingStakingToken, amount = _ref6.amount;
+            callArgs = protocol.callOnIntegrationArgs({
+              adapter: curveLiquidityAdapter,
+              encodedCallArgs: protocol.curveStakeArgs({
+                amount: amount,
+                incomingStakingToken: incomingStakingToken,
+                pool: pool
+              }),
+              selector: protocol.stakeSelector
+            });
+            return _context5.abrupt("return", comptrollerProxy.connect(signer).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs));
+
+          case 3:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+  return _curveStake.apply(this, arguments);
 }
-function curveStethRedeem(_ref26) {
-  var comptrollerProxy = _ref26.comptrollerProxy,
-      integrationManager = _ref26.integrationManager,
-      fundOwner = _ref26.fundOwner,
-      curveLiquidityStethAdapter = _ref26.curveLiquidityStethAdapter,
-      outgoingLPTokenAmount = _ref26.outgoingLPTokenAmount,
-      minIncomingWethAmount = _ref26.minIncomingWethAmount,
-      minIncomingStethAmount = _ref26.minIncomingStethAmount,
-      receiveSingleAsset = _ref26.receiveSingleAsset;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityStethAdapter,
-    encodedCallArgs: protocol.curveStethRedeemArgs({
-      minIncomingStethAmount: minIncomingStethAmount,
-      minIncomingWethAmount: minIncomingWethAmount,
-      outgoingLPTokenAmount: outgoingLPTokenAmount,
-      receiveSingleAsset: receiveSingleAsset
-    }),
-    selector: protocol.redeemSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+function curveUnstake(_x6) {
+  return _curveUnstake.apply(this, arguments);
 }
-function curveStethStake(_ref27) {
-  var comptrollerProxy = _ref27.comptrollerProxy,
-      integrationManager = _ref27.integrationManager,
-      fundOwner = _ref27.fundOwner,
-      curveLiquidityStethAdapter = _ref27.curveLiquidityStethAdapter,
-      outgoingLPTokenAmount = _ref27.outgoingLPTokenAmount;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityStethAdapter,
-    encodedCallArgs: protocol.curveStethStakeArgs({
-      outgoingLPTokenAmount: outgoingLPTokenAmount
-    }),
-    selector: protocol.stakeSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+function _curveUnstake() {
+  _curveUnstake = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee6(_ref7) {
+    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, outgoingStakingToken, amount, callArgs;
+    return _regeneratorRuntime__default['default'].wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            comptrollerProxy = _ref7.comptrollerProxy, integrationManager = _ref7.integrationManager, signer = _ref7.signer, curveLiquidityAdapter = _ref7.curveLiquidityAdapter, pool = _ref7.pool, outgoingStakingToken = _ref7.outgoingStakingToken, amount = _ref7.amount;
+            callArgs = protocol.callOnIntegrationArgs({
+              adapter: curveLiquidityAdapter,
+              encodedCallArgs: protocol.curveUnstakeArgs({
+                amount: amount,
+                outgoingStakingToken: outgoingStakingToken,
+                pool: pool
+              }),
+              selector: protocol.unstakeSelector
+            });
+            return _context6.abrupt("return", comptrollerProxy.connect(signer).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs));
+
+          case 3:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6);
+  }));
+  return _curveUnstake.apply(this, arguments);
 }
-function curveStethUnstakeAndRedeem(_ref28) {
-  var comptrollerProxy = _ref28.comptrollerProxy,
-      integrationManager = _ref28.integrationManager,
-      fundOwner = _ref28.fundOwner,
-      curveLiquidityStethAdapter = _ref28.curveLiquidityStethAdapter,
-      outgoingLiquidityGaugeTokenAmount = _ref28.outgoingLiquidityGaugeTokenAmount,
-      minIncomingWethAmount = _ref28.minIncomingWethAmount,
-      minIncomingStethAmount = _ref28.minIncomingStethAmount,
-      receiveSingleAsset = _ref28.receiveSingleAsset;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityStethAdapter,
-    encodedCallArgs: protocol.curveStethUnstakeAndRedeemArgs({
-      minIncomingStethAmount: minIncomingStethAmount,
-      minIncomingWethAmount: minIncomingWethAmount,
-      outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount,
-      receiveSingleAsset: receiveSingleAsset
-    }),
-    selector: protocol.unstakeAndRedeemSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+function curveUnstakeAndRedeem(_x7) {
+  return _curveUnstakeAndRedeem.apply(this, arguments);
 }
-function curveStethUnstake(_ref29) {
-  var comptrollerProxy = _ref29.comptrollerProxy,
-      integrationManager = _ref29.integrationManager,
-      fundOwner = _ref29.fundOwner,
-      curveLiquidityStethAdapter = _ref29.curveLiquidityStethAdapter,
-      outgoingLiquidityGaugeTokenAmount = _ref29.outgoingLiquidityGaugeTokenAmount;
-  var callArgs = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityStethAdapter,
-    encodedCallArgs: protocol.curveStethUnstakeArgs({
-      outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount
-    }),
-    selector: protocol.unstakeSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+function _curveUnstakeAndRedeem() {
+  _curveUnstakeAndRedeem = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee7(_ref8) {
+    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, outgoingStakingToken, outgoingStakingTokenAmount, useUnderlyings, redeemType, incomingAssetData, callArgs;
+    return _regeneratorRuntime__default['default'].wrap(function _callee7$(_context7) {
+      while (1) {
+        switch (_context7.prev = _context7.next) {
+          case 0:
+            comptrollerProxy = _ref8.comptrollerProxy, integrationManager = _ref8.integrationManager, signer = _ref8.signer, curveLiquidityAdapter = _ref8.curveLiquidityAdapter, pool = _ref8.pool, outgoingStakingToken = _ref8.outgoingStakingToken, outgoingStakingTokenAmount = _ref8.outgoingStakingTokenAmount, useUnderlyings = _ref8.useUnderlyings, redeemType = _ref8.redeemType, incomingAssetData = _ref8.incomingAssetData;
+            callArgs = protocol.callOnIntegrationArgs({
+              adapter: curveLiquidityAdapter,
+              encodedCallArgs: protocol.curveUnstakeAndRedeemArgs({
+                incomingAssetData: incomingAssetData,
+                outgoingStakingToken: outgoingStakingToken,
+                outgoingStakingTokenAmount: outgoingStakingTokenAmount,
+                pool: pool,
+                redeemType: redeemType,
+                useUnderlyings: useUnderlyings
+              }),
+              selector: protocol.unstakeAndRedeemSelector
+            });
+            return _context7.abrupt("return", comptrollerProxy.connect(signer).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs));
+
+          case 3:
+          case "end":
+            return _context7.stop();
+        }
+      }
+    }, _callee7);
+  }));
+  return _curveUnstakeAndRedeem.apply(this, arguments);
 }
 
 function idleClaimRewards(_x) {
@@ -2354,53 +2478,70 @@ function _mockGenericSwap() {
   return _mockGenericSwap.apply(this, arguments);
 }
 
-function paraSwapV4GenerateDummyPaths(_ref) {
-  var toTokens = _ref.toTokens;
-  return toTokens.map(function (toToken) {
-    return {
-      // Not supported in our protocol
-      routes: [],
-      to: toToken,
-      totalNetworkFee: 0 // Can ignore this param in the dummy
-
-    };
-  });
-}
-function paraSwapV4TakeOrder(_x) {
-  return _paraSwapV4TakeOrder.apply(this, arguments);
+function olympusV2Stake(_x) {
+  return _olympusV2Stake.apply(this, arguments);
 }
 
-function _paraSwapV4TakeOrder() {
-  _paraSwapV4TakeOrder = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee(_ref2) {
-    var comptrollerProxy, integrationManager, fundOwner, paraSwapV4Adapter, outgoingAsset, _ref2$outgoingAssetAm, outgoingAssetAmount, _ref2$minIncomingAsse, minIncomingAssetAmount, _ref2$expectedIncomin, expectedIncomingAssetAmount, paths, takeOrderArgs, callArgs;
-
+function _olympusV2Stake() {
+  _olympusV2Stake = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee(_ref) {
+    var comptrollerProxy, integrationManager, signer, olympusV2Adapter, amount, stakeArgs, callArgs, stakeTx;
     return _regeneratorRuntime__default['default'].wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            comptrollerProxy = _ref2.comptrollerProxy, integrationManager = _ref2.integrationManager, fundOwner = _ref2.fundOwner, paraSwapV4Adapter = _ref2.paraSwapV4Adapter, outgoingAsset = _ref2.outgoingAsset, _ref2$outgoingAssetAm = _ref2.outgoingAssetAmount, outgoingAssetAmount = _ref2$outgoingAssetAm === void 0 ? ethers.utils.parseEther('1') : _ref2$outgoingAssetAm, _ref2$minIncomingAsse = _ref2.minIncomingAssetAmount, minIncomingAssetAmount = _ref2$minIncomingAsse === void 0 ? 1 : _ref2$minIncomingAsse, _ref2$expectedIncomin = _ref2.expectedIncomingAssetAmount, expectedIncomingAssetAmount = _ref2$expectedIncomin === void 0 ? minIncomingAssetAmount : _ref2$expectedIncomin, paths = _ref2.paths;
-            takeOrderArgs = protocol.paraSwapV4TakeOrderArgs({
-              expectedIncomingAssetAmount: expectedIncomingAssetAmount,
-              minIncomingAssetAmount: minIncomingAssetAmount,
-              outgoingAsset: outgoingAsset,
-              outgoingAssetAmount: outgoingAssetAmount,
-              paths: paths
+            comptrollerProxy = _ref.comptrollerProxy, integrationManager = _ref.integrationManager, signer = _ref.signer, olympusV2Adapter = _ref.olympusV2Adapter, amount = _ref.amount;
+            stakeArgs = protocol.olympusV2StakeArgs({
+              amount: amount
             });
             callArgs = protocol.callOnIntegrationArgs({
-              adapter: paraSwapV4Adapter,
-              encodedCallArgs: takeOrderArgs,
-              selector: protocol.takeOrderSelector
+              adapter: olympusV2Adapter,
+              encodedCallArgs: stakeArgs,
+              selector: protocol.stakeSelector
             });
-            return _context.abrupt("return", comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs));
+            stakeTx = comptrollerProxy.connect(signer).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+            return _context.abrupt("return", stakeTx);
 
-          case 4:
+          case 5:
           case "end":
             return _context.stop();
         }
       }
     }, _callee);
   }));
-  return _paraSwapV4TakeOrder.apply(this, arguments);
+  return _olympusV2Stake.apply(this, arguments);
+}
+
+function olympusV2Unstake(_x2) {
+  return _olympusV2Unstake.apply(this, arguments);
+}
+
+function _olympusV2Unstake() {
+  _olympusV2Unstake = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee2(_ref2) {
+    var comptrollerProxy, integrationManager, signer, olympusV2Adapter, amount, unstakeArgs, callArgs, unstakeTx;
+    return _regeneratorRuntime__default['default'].wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            comptrollerProxy = _ref2.comptrollerProxy, integrationManager = _ref2.integrationManager, signer = _ref2.signer, olympusV2Adapter = _ref2.olympusV2Adapter, amount = _ref2.amount;
+            unstakeArgs = protocol.olympusV2UnstakeArgs({
+              amount: amount
+            });
+            callArgs = protocol.callOnIntegrationArgs({
+              adapter: olympusV2Adapter,
+              encodedCallArgs: unstakeArgs,
+              selector: protocol.unstakeSelector
+            });
+            unstakeTx = comptrollerProxy.connect(signer).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+            return _context2.abrupt("return", unstakeTx);
+
+          case 5:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _olympusV2Unstake.apply(this, arguments);
 }
 
 function paraSwapV5GenerateDummyPaths(_ref) {
@@ -2564,24 +2705,16 @@ function synthetixAssignExchangeDelegate(_x) {
 
 function _synthetixAssignExchangeDelegate() {
   _synthetixAssignExchangeDelegate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee(_ref) {
-    var comptrollerProxy, addressResolver, fundOwner, delegate, delegateApprovals;
+    var comptrollerProxy, synthetixDelegateApprovals, fundOwner, delegate;
     return _regeneratorRuntime__default['default'].wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            comptrollerProxy = _ref.comptrollerProxy, addressResolver = _ref.addressResolver, fundOwner = _ref.fundOwner, delegate = _ref.delegate;
+            comptrollerProxy = _ref.comptrollerProxy, synthetixDelegateApprovals = _ref.synthetixDelegateApprovals, fundOwner = _ref.fundOwner, delegate = _ref.delegate;
             _context.next = 3;
-            return synthetixResolveAddress({
-              addressResolver: addressResolver,
-              name: 'DelegateApprovals'
-            });
+            return comptrollerProxy.connect(fundOwner).vaultCallOnContract(synthetixDelegateApprovals, protocol.synthetixAssignExchangeDelegateSelector, protocol.encodeArgs(['address'], [delegate]));
 
           case 3:
-            delegateApprovals = _context.sent;
-            _context.next = 6;
-            return comptrollerProxy.connect(fundOwner).vaultCallOnContract(delegateApprovals, protocol.synthetixAssignExchangeDelegateSelector, protocol.encodeArgs(['address'], [delegate]));
-
-          case 6:
           case "end":
             return _context.stop();
         }
@@ -2591,42 +2724,18 @@ function _synthetixAssignExchangeDelegate() {
   return _synthetixAssignExchangeDelegate.apply(this, arguments);
 }
 
-function synthetixResolveAddress(_x2) {
-  return _synthetixResolveAddress.apply(this, arguments);
-}
-
-function _synthetixResolveAddress() {
-  _synthetixResolveAddress = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee2(_ref2) {
-    var addressResolver, name;
-    return _regeneratorRuntime__default['default'].wrap(function _callee2$(_context2) {
-      while (1) {
-        switch (_context2.prev = _context2.next) {
-          case 0:
-            addressResolver = _ref2.addressResolver, name = _ref2.name;
-            return _context2.abrupt("return", addressResolver.requireAndGetAddress(ethers.utils.formatBytes32String(name), "Missing ".concat(name)));
-
-          case 2:
-          case "end":
-            return _context2.stop();
-        }
-      }
-    }, _callee2);
-  }));
-  return _synthetixResolveAddress.apply(this, arguments);
-}
-
-function synthetixRedeem(_x3) {
+function synthetixRedeem(_x2) {
   return _synthetixRedeem.apply(this, arguments);
 }
 
 function _synthetixRedeem() {
-  _synthetixRedeem = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee3(_ref3) {
+  _synthetixRedeem = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee2(_ref2) {
     var comptrollerProxy, integrationManager, signer, synthetixAdapter, synths, redeemArgs, callArgs;
-    return _regeneratorRuntime__default['default'].wrap(function _callee3$(_context3) {
+    return _regeneratorRuntime__default['default'].wrap(function _callee2$(_context2) {
       while (1) {
-        switch (_context3.prev = _context3.next) {
+        switch (_context2.prev = _context2.next) {
           case 0:
-            comptrollerProxy = _ref3.comptrollerProxy, integrationManager = _ref3.integrationManager, signer = _ref3.signer, synthetixAdapter = _ref3.synthetixAdapter, synths = _ref3.synths;
+            comptrollerProxy = _ref2.comptrollerProxy, integrationManager = _ref2.integrationManager, signer = _ref2.signer, synthetixAdapter = _ref2.synthetixAdapter, synths = _ref2.synths;
             redeemArgs = protocol.synthetixRedeemArgs({
               synths: synths
             });
@@ -2635,48 +2744,47 @@ function _synthetixRedeem() {
               encodedCallArgs: redeemArgs,
               selector: protocol.redeemSelector
             });
-            return _context3.abrupt("return", comptrollerProxy.connect(signer).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs));
+            return _context2.abrupt("return", comptrollerProxy.connect(signer).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs));
 
           case 4:
           case "end":
-            return _context3.stop();
+            return _context2.stop();
         }
       }
-    }, _callee3);
+    }, _callee2);
   }));
   return _synthetixRedeem.apply(this, arguments);
 }
 
-function synthetixTakeOrder(_x4) {
+function synthetixTakeOrder(_x3) {
   return _synthetixTakeOrder.apply(this, arguments);
 }
 
 function _synthetixTakeOrder() {
-  _synthetixTakeOrder = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee4(_ref4) {
-    var comptrollerProxy, vaultProxy, integrationManager, fundOwner, synthetixAdapter, outgoingAsset, _ref4$outgoingAssetAm, outgoingAssetAmount, incomingAsset, _ref4$minIncomingAsse, minIncomingAssetAmount, _ref4$seedFund, seedFund, takeOrderArgs, callArgs;
+  _synthetixTakeOrder = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee3(_ref3) {
+    var comptrollerProxy, vaultProxy, integrationManager, fundOwner, synthetixAdapter, outgoingAsset, _ref3$outgoingAssetAm, outgoingAssetAmount, _ref3$minIncomingSusd, minIncomingSusdAmount, _ref3$seedFund, seedFund, takeOrderArgs, callArgs;
 
-    return _regeneratorRuntime__default['default'].wrap(function _callee4$(_context4) {
+    return _regeneratorRuntime__default['default'].wrap(function _callee3$(_context3) {
       while (1) {
-        switch (_context4.prev = _context4.next) {
+        switch (_context3.prev = _context3.next) {
           case 0:
-            comptrollerProxy = _ref4.comptrollerProxy, vaultProxy = _ref4.vaultProxy, integrationManager = _ref4.integrationManager, fundOwner = _ref4.fundOwner, synthetixAdapter = _ref4.synthetixAdapter, outgoingAsset = _ref4.outgoingAsset, _ref4$outgoingAssetAm = _ref4.outgoingAssetAmount, outgoingAssetAmount = _ref4$outgoingAssetAm === void 0 ? ethers.utils.parseEther('1') : _ref4$outgoingAssetAm, incomingAsset = _ref4.incomingAsset, _ref4$minIncomingAsse = _ref4.minIncomingAssetAmount, minIncomingAssetAmount = _ref4$minIncomingAsse === void 0 ? ethers.utils.parseEther('1') : _ref4$minIncomingAsse, _ref4$seedFund = _ref4.seedFund, seedFund = _ref4$seedFund === void 0 ? false : _ref4$seedFund;
+            comptrollerProxy = _ref3.comptrollerProxy, vaultProxy = _ref3.vaultProxy, integrationManager = _ref3.integrationManager, fundOwner = _ref3.fundOwner, synthetixAdapter = _ref3.synthetixAdapter, outgoingAsset = _ref3.outgoingAsset, _ref3$outgoingAssetAm = _ref3.outgoingAssetAmount, outgoingAssetAmount = _ref3$outgoingAssetAm === void 0 ? ethers.utils.parseEther('1') : _ref3$outgoingAssetAm, _ref3$minIncomingSusd = _ref3.minIncomingSusdAmount, minIncomingSusdAmount = _ref3$minIncomingSusd === void 0 ? ethers.utils.parseEther('1') : _ref3$minIncomingSusd, _ref3$seedFund = _ref3.seedFund, seedFund = _ref3$seedFund === void 0 ? false : _ref3$seedFund;
 
             if (!seedFund) {
-              _context4.next = 4;
+              _context3.next = 4;
               break;
             }
 
-            _context4.next = 4;
+            _context3.next = 4;
             return outgoingAsset.transfer(vaultProxy, outgoingAssetAmount);
 
           case 4:
             takeOrderArgs = protocol.synthetixTakeOrderArgs({
-              incomingAsset: incomingAsset,
-              minIncomingAssetAmount: minIncomingAssetAmount,
+              minIncomingSusdAmount: minIncomingSusdAmount,
               outgoingAsset: outgoingAsset,
               outgoingAssetAmount: outgoingAssetAmount
             });
-            _context4.next = 7;
+            _context3.next = 7;
             return protocol.callOnIntegrationArgs({
               adapter: synthetixAdapter,
               encodedCallArgs: takeOrderArgs,
@@ -2684,15 +2792,15 @@ function _synthetixTakeOrder() {
             });
 
           case 7:
-            callArgs = _context4.sent;
-            return _context4.abrupt("return", comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs));
+            callArgs = _context3.sent;
+            return _context3.abrupt("return", comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.IntegrationManagerActionId.CallOnIntegration, callArgs));
 
           case 9:
           case "end":
-            return _context4.stop();
+            return _context3.stop();
         }
       }
-    }, _callee4);
+    }, _callee3);
   }));
   return _synthetixTakeOrder.apply(this, arguments);
 }
@@ -3653,12 +3761,15 @@ var whales = {
   crv: '0x4ce799e6eD8D64536b67dD428565d52A531B3640',
   dai: '0x47ac0fb4f2d84898e4d9e7b4dab3c24507a6d503',
   knc: '0x09d51654bd9efbfcb56da3491989cc1444095fff',
+  ldo: '0x3dba737ccc50a32a1764b493285dd51c8af6c278',
   link: '0xbe6977e08d4479c0a6777539ae0e8fa27be4e9d6',
   mana: '0xefb94ac00f1cee8a89d5c3f49faa799da6f03024',
   mln: '0xd8f8a53945bcfbbc19da162aa405e662ef71c40d',
+  ohm: '0x71a53aff36a699110d66d6bdfff2320caf8d2d59',
   rep: '0xc6a043b07d33b6f30d8cb501026c391cfd25abe1',
   ren: '0xbe0eb53f46cd790cd13851d5eff43d12404d33e8',
   susd: '0xa5f7a39e55d7878bc5bd754ee5d6bd7a7662355b',
+  sohm: '0xf280f037cdbda99727ddf5dfede91e68fa78605c',
   uni: '0x47173b170c64d16393a52e6c480b3ad8c302ba1e',
   usdc: '0xae2d4617c862309a3d75a0ffb358c7a5009c673f',
   usdt: '0x5041ed759dd4afc3a72b8192c143f72f4724081a',
@@ -3666,23 +3777,29 @@ var whales = {
   zrx: '0x206376e8940e42538781cd94ef024df3c1e0fd43',
   // aTokens
   ausdc: '0x3DdfA8eC3052539b6C9549F12cEA2C295cfF5296',
+  ausdt: '0x7d6149ad9a573a6e2ca6ebf7d4897c1b766841b4',
   // cTokens
   ccomp: '0xd74f186194ab9219fafac5c2fe4b3270169666db',
   cdai: '0xab4ce310054a11328685ece1043211b68ba5d082',
   ceth: '0x8aceab8167c80cb8b3de7fa6228b889bb1130ee8',
   cuni: '0x39d8014b4f40d2cbc441137011d32023f4f1fd87',
-  cusdc: '0xb3bd459e0598dde1fe84b1d0a1430be175b5d5be',
+  cusdc: '0xe1ed4da4284924ddaf69983b4d813fb1be58c380',
+  // fTokens
+  fdai7: '0x88884e35d7006ae84efef09ee6bc6a43dd8e2bb8',
+  feth7: '0xcd2ba6a4d50745b0b4096186f925115387852c15',
+  fdai8: '0x93f3f612a525a59523e91cc5552f718df9fc0746',
+  ftribe8: '0xdb5ac83c137321da29a59a7592232bc4ed461730',
   // ptTokens
   ptUsdc: '0xd18236cd213f39d078177b6f6908f0e44e88e4aa',
-  // synths
+  // synths (unsupported)
   seth: '0xc34a7c65aa08cb36744bda8eeec7b8e9891e147c',
-  seur: '0xc3f2f91723b16b95bef0619b2504c049075d5b0b',
   sxag: '0x40d68c490bf7262ec40048099aec23535f734be2',
   sxau: '0x92eb453b7b5b8d41edb44e2c8b8b53eb70a482c7',
   // misc
   lidoSteth: '0x31f644e2dd5d74f5c8d6d9de89dd517474d51800',
-  ldo: '0x3dba737ccc50a32a1764b493285dd51c8af6c278',
-  eurs: '0x98ed26de6451db36246672df78ae7c50f2c76f6d'
+  ust: '0xf584f8728b874a6a5c7a8d4d387c9aae9172d621',
+  // Curve steth pool related
+  stecrv: '0x56c915758ad3f76fd287fff7563ee313142fb663'
 };
 /* eslint-enable sort-keys-fix/sort-keys-fix */
 
@@ -3918,14 +4035,22 @@ function assertPaymasterDidRejectForReason(receipt, reason) {
 
 exports.CurveLiquidityGaugeV2 = CurveLiquidityGaugeV2;
 exports.CurveMinter = CurveMinter;
+exports.CurveRegistry = CurveRegistry;
 exports.CurveSwaps = CurveSwaps;
 exports.ICompoundComptroller = ICompoundComptroller;
 exports.IUniswapV3NonFungibleTokenManager = IUniswapV3NonFungibleTokenManager;
 exports.UniswapV2Factory = UniswapV2Factory;
+exports.aaveDebtPositionAddCollateral = aaveDebtPositionAddCollateral;
+exports.aaveDebtPositionBorrow = aaveDebtPositionBorrow;
+exports.aaveDebtPositionClaimRewards = aaveDebtPositionClaimRewards;
+exports.aaveDebtPositionRemoveCollateral = aaveDebtPositionRemoveCollateral;
+exports.aaveDebtPositionRepayBorrow = aaveDebtPositionRepayBorrow;
 exports.aaveLend = aaveLend;
 exports.aaveRedeem = aaveRedeem;
 exports.addNewAssetsToFund = addNewAssetsToFund;
 exports.addTrackedAssetsToVault = addTrackedAssetsToVault;
+exports.assertCompoundLend = assertCompoundLend;
+exports.assertCompoundRedeem = assertCompoundRedeem;
 exports.assertDidRelay = assertDidRelay;
 exports.assertDidRelaySuccessfully = assertDidRelaySuccessfully;
 exports.assertDidRelayWithCharge = assertDidRelayWithCharge;
@@ -3939,6 +4064,7 @@ exports.buySharesFunction = buySharesFunction;
 exports.calcMlnValueAndBurnAmountForSharesBuyback = calcMlnValueAndBurnAmountForSharesBuyback;
 exports.callOnExtension = callOnExtension;
 exports.callOnExternalPosition = callOnExternalPosition;
+exports.compoundClaim = compoundClaim;
 exports.compoundDebtPositionAddCollateral = compoundDebtPositionAddCollateral;
 exports.compoundDebtPositionBorrow = compoundDebtPositionBorrow;
 exports.compoundDebtPositionClaimComp = compoundDebtPositionClaimComp;
@@ -3946,6 +4072,7 @@ exports.compoundDebtPositionRemoveCollateral = compoundDebtPositionRemoveCollate
 exports.compoundDebtPositionRepayBorrow = compoundDebtPositionRepayBorrow;
 exports.compoundLend = compoundLend;
 exports.compoundRedeem = compoundRedeem;
+exports.createAaveDebtPosition = createAaveDebtPosition;
 exports.createCompoundDebtPosition = createCompoundDebtPosition;
 exports.createComptrollerProxy = createComptrollerProxy;
 exports.createExternalPosition = createExternalPosition;
@@ -3956,35 +4083,14 @@ exports.createNewFund = createNewFund;
 exports.createReconfigurationRequest = createReconfigurationRequest;
 exports.createUniswapV3LiquidityPosition = createUniswapV3LiquidityPosition;
 exports.createVaultProxy = createVaultProxy;
-exports.curveAaveClaimRewards = curveAaveClaimRewards;
-exports.curveAaveLend = curveAaveLend;
-exports.curveAaveLendAndStake = curveAaveLendAndStake;
-exports.curveAaveRedeem = curveAaveRedeem;
-exports.curveAaveStake = curveAaveStake;
-exports.curveAaveUnstake = curveAaveUnstake;
-exports.curveAaveUnstakeAndRedeem = curveAaveUnstakeAndRedeem;
-exports.curveEursClaimRewards = curveEursClaimRewards;
-exports.curveEursLend = curveEursLend;
-exports.curveEursLendAndStake = curveEursLendAndStake;
-exports.curveEursRedeem = curveEursRedeem;
-exports.curveEursStake = curveEursStake;
-exports.curveEursUnstake = curveEursUnstake;
-exports.curveEursUnstakeAndRedeem = curveEursUnstakeAndRedeem;
-exports.curveSethClaimRewards = curveSethClaimRewards;
-exports.curveSethLend = curveSethLend;
-exports.curveSethLendAndStake = curveSethLendAndStake;
-exports.curveSethRedeem = curveSethRedeem;
-exports.curveSethStake = curveSethStake;
-exports.curveSethUnstake = curveSethUnstake;
-exports.curveSethUnstakeAndRedeem = curveSethUnstakeAndRedeem;
-exports.curveStethClaimRewards = curveStethClaimRewards;
-exports.curveStethLend = curveStethLend;
-exports.curveStethLendAndStake = curveStethLendAndStake;
-exports.curveStethRedeem = curveStethRedeem;
-exports.curveStethStake = curveStethStake;
-exports.curveStethUnstake = curveStethUnstake;
-exports.curveStethUnstakeAndRedeem = curveStethUnstakeAndRedeem;
+exports.curveClaimRewards = curveClaimRewards;
+exports.curveLend = curveLend;
+exports.curveLendAndStake = curveLendAndStake;
+exports.curveRedeem = curveRedeem;
+exports.curveStake = curveStake;
 exports.curveTakeOrder = curveTakeOrder;
+exports.curveUnstake = curveUnstake;
+exports.curveUnstakeAndRedeem = curveUnstakeAndRedeem;
 exports.deployProtocolFixture = deployProtocolFixture;
 exports.generateFeeManagerConfigWithMockFees = generateFeeManagerConfigWithMockFees;
 exports.generateMockFees = generateMockFees;
@@ -4008,8 +4114,8 @@ exports.mockGenericSwapArgs = mockGenericSwapArgs;
 exports.mockGenericSwapBSelector = mockGenericSwapBSelector;
 exports.mockGenericSwapDirectFromVaultSelector = mockGenericSwapDirectFromVaultSelector;
 exports.mockGenericSwapViaApprovalSelector = mockGenericSwapViaApprovalSelector;
-exports.paraSwapV4GenerateDummyPaths = paraSwapV4GenerateDummyPaths;
-exports.paraSwapV4TakeOrder = paraSwapV4TakeOrder;
+exports.olympusV2Stake = olympusV2Stake;
+exports.olympusV2Unstake = olympusV2Unstake;
 exports.paraSwapV5GenerateDummyPaths = paraSwapV5GenerateDummyPaths;
 exports.paraSwapV5TakeOrder = paraSwapV5TakeOrder;
 exports.poolTogetherV4ClaimRewards = poolTogetherV4ClaimRewards;
@@ -4024,7 +4130,6 @@ exports.removeTrackedAssetsFromVault = removeTrackedAssetsFromVault;
 exports.setupGasRelayerPaymaster = setupGasRelayerPaymaster;
 exports.synthetixAssignExchangeDelegate = synthetixAssignExchangeDelegate;
 exports.synthetixRedeem = synthetixRedeem;
-exports.synthetixResolveAddress = synthetixResolveAddress;
 exports.synthetixTakeOrder = synthetixTakeOrder;
 exports.transactionTimestamp = transactionTimestamp;
 exports.uniswapV2Lend = uniswapV2Lend;