@enzymefinance/testutils 4.0.0-next.6 → 4.0.0-next.7

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

@@ -1,9 +1,10 @@
 import _asyncToGenerator from '@babel/runtime/helpers/esm/asyncToGenerator';
 import _regeneratorRuntime from '@babel/runtime/regenerator';
-import { AaveAdapter, AavePriceFeed, AddressListRegistry, AllowedAdapterIncomingAssetsPolicy, AllowedAdaptersPolicy, AllowedAssetsForRedemptionPolicy, AllowedDepositRecipientsPolicy, AllowedExternalPositionTypesPolicy, AllowedSharesTransferRecipientsPolicy, AssetFinalityResolver, CompoundAdapter, CompoundDebtPositionLib, CompoundDebtPositionParser, CompoundPriceFeed, ComptrollerLib, CumulativeSlippageTolerancePolicy, CurveExchangeAdapter, CurveLiquidityAaveAdapter, CurveLiquidityAdapter, CurveLiquidityEursAdapter, CurveLiquiditySethAdapter, CurveLiquidityStethAdapter, CurvePriceFeed, DepositWrapper, Dispatcher, EntranceRateBurnFee, EntranceRateDirectFee, ExitRateBurnFee, ExitRateDirectFee, ExternalPositionFactory, ExternalPositionManager, FeeManager, FundDeployer, FundValueCalculator, FundValueCalculatorRouter, FundValueCalculatorUsdWrapper, GasRelayPaymasterFactory, GuaranteedRedemptionPolicy, IdleAdapter, IdlePriceFeed, IntegrationManager, LidoStethPriceFeed, ManagementFee, MinAssetBalancesPostRedemptionPolicy, MinMaxInvestmentPolicy, OlympusV2Adapter, OnlyRemoveDustExternalPositionPolicy, OnlyUntrackDustOrPricelessAssetsPolicy, ParaSwapV4Adapter, ParaSwapV5Adapter, PerformanceFee, PolicyManager, PoolTogetherV4Adapter, PoolTogetherV4PriceFeed, ProtocolFeeReserveLib, ProtocolFeeTracker, RevertingPriceFeed, StakehoundEthPriceFeed, SynthetixAdapter, SynthetixPriceFeed, UniswapV2ExchangeAdapter, UniswapV2LiquidityAdapter, UniswapV2PoolPriceFeed, UniswapV3Adapter, UnpermissionedActionsWrapper, ValueInterpreter, VaultLib, YearnVaultV2Adapter, YearnVaultV2PriceFeed, ZeroExV2Adapter, IntegrationManagerActionId, addTrackedAssetsToVaultArgs, removeTrackedAssetsFromVaultArgs, StandardToken, callOnExternalPositionArgs, ExternalPositionManagerActionId, IExternalPositionProxy, encodeArgs, externalPositionReactivateArgs, externalPositionRemoveArgs, compoundExternalPositionActionArgs, CompoundDebtPositionActionId, ExternalPositionType, MockGenericExternalPositionParser, MockGenericExternalPositionLib, mockGenericExternalPositionActionArgs, MockGenericExternalPositionActionId, uniswapV3LiquidityPositionInitArgs, uniswapV3LiquidityPositionAddLiquidityArgs, UniswapV3LiquidityPositionActionId, uniswapV3LiquidityPositionCollectArgs, UniswapV3LiquidityPositionLib, uniswapV3LiquidityPositionMintArgs, uniswapV3LiquidityPositionPurgeArgs, uniswapV3LiquidityPositionRemoveLiquidityArgs, feeManagerConfigArgs, FeeSettlementType, FeeHook, IFee, aaveLendArgs, callOnIntegrationArgs, lendSelector, aaveRedeemArgs, redeemSelector, compoundArgs, curveTakeOrderArgs, takeOrderSelector, curveClaimRewardsArgs, claimRewardsSelector, curveLendArgs, curveLendAndStakeArgs, lendAndStakeSelector, curveRedeemArgs, curveStakeArgs, stakeSelector, curveUnstakeArgs, unstakeSelector, curveUnstakeAndRedeemArgs, unstakeAndRedeemSelector, curveAaveLendArgs, curveAaveLendAndStakeArgs, curveAaveRedeemArgs, curveAaveStakeArgs, curveAaveUnstakeAndRedeemArgs, curveAaveUnstakeArgs, curveEursLendArgs, curveEursLendAndStakeArgs, curveEursRedeemArgs, curveEursStakeArgs, curveEursUnstakeAndRedeemArgs, curveEursUnstakeArgs, curveSethLendArgs, curveSethLendAndStakeArgs, curveSethRedeemArgs, curveSethStakeArgs, curveSethUnstakeAndRedeemArgs, curveSethUnstakeArgs, curveStethLendArgs, curveStethLendAndStakeArgs, curveStethRedeemArgs, curveStethStakeArgs, curveStethUnstakeAndRedeemArgs, curveStethUnstakeArgs, idleClaimRewardsArgs, idleLendArgs, idleRedeemArgs, sighash, olympusV2StakeArgs, olympusV2UnstakeArgs, paraSwapV4TakeOrderArgs, paraSwapV5TakeOrderArgs, poolTogetherV4LendArgs, poolTogetherV4RedeemArgs, poolTogetherV4ClaimRewardsArgs, synthetixAssignExchangeDelegateSelector, synthetixRedeemArgs, synthetixTakeOrderArgs, uniswapV2LendArgs, uniswapV2RedeemArgs, uniswapV2TakeOrderArgs, uniswapV3TakeOrderArgs, yearnVaultV2LendArgs, yearnVaultV2RedeemArgs, zeroExV2TakeOrderArgs, policyManagerConfigArgs, PolicyHook, IPolicy, encodeFunctionData, ComptrollerProxy, VaultProxy, GasRelayPaymasterLib, addressListRegistryCreateListSelector, curveMinterMintSelector, curveMinterMintManySelector, curveMinterToggleApproveMintSelector, IGsnRelayHub, createSignedRelayRequest, isTypedDataSigner } from '@enzymefinance/protocol';
+import { AaveAdapter, AavePriceFeed, AddressListRegistry, AllowedAdapterIncomingAssetsPolicy, AllowedAdaptersPolicy, AllowedAssetsForRedemptionPolicy, AllowedDepositRecipientsPolicy, AllowedExternalPositionTypesPolicy, AllowedSharesTransferRecipientsPolicy, CompoundAdapter, CompoundDebtPositionLib, CompoundDebtPositionParser, CompoundPriceFeed, ComptrollerLib, ConvexCurveLpStakingAdapter, ConvexCurveLpStakingWrapperFactory, ConvexCurveLpStakingWrapperPriceFeed, CumulativeSlippageTolerancePolicy, CurveExchangeAdapter, CurveLiquidityAaveAdapter, CurveLiquidityAdapter, CurveLiquiditySethAdapter, CurveLiquidityStethAdapter, CurvePriceFeed, DepositWrapper, Dispatcher, EntranceRateBurnFee, EntranceRateDirectFee, ExitRateBurnFee, ExitRateDirectFee, ExternalPositionFactory, ExternalPositionManager, FeeManager, FundDeployer, FundValueCalculator, FundValueCalculatorRouter, FundValueCalculatorUsdWrapper, FuseAdapter, FusePriceFeed, GasRelayPaymasterFactory, IdleAdapter, IdlePriceFeed, IntegrationManager, LidoStethPriceFeed, ManagementFee, MinAssetBalancesPostRedemptionPolicy, MinMaxInvestmentPolicy, OlympusV2Adapter, OnlyRemoveDustExternalPositionPolicy, OnlyUntrackDustOrPricelessAssetsPolicy, ParaSwapV4Adapter, ParaSwapV5Adapter, PerformanceFee, PolicyManager, PoolTogetherV4Adapter, PoolTogetherV4PriceFeed, ProtocolFeeReserveLib, ProtocolFeeTracker, RevertingPriceFeed, StakehoundEthPriceFeed, SynthetixAdapter, UniswapV2ExchangeAdapter, UniswapV2LiquidityAdapter, UniswapV2PoolPriceFeed, UniswapV3Adapter, UnpermissionedActionsWrapper, ValueInterpreter, VaultLib, YearnVaultV2Adapter, YearnVaultV2PriceFeed, ZeroExV2Adapter, IntegrationManagerActionId, addTrackedAssetsToVaultArgs, removeTrackedAssetsFromVaultArgs, StandardToken, callOnExternalPositionArgs, ExternalPositionManagerActionId, IExternalPositionProxy, encodeArgs, externalPositionReactivateArgs, externalPositionRemoveArgs, compoundExternalPositionActionArgs, CompoundDebtPositionActionId, ExternalPositionType, MockGenericExternalPositionParser, MockGenericExternalPositionLib, mockGenericExternalPositionActionArgs, MockGenericExternalPositionActionId, uniswapV3LiquidityPositionAddLiquidityArgs, UniswapV3LiquidityPositionActionId, uniswapV3LiquidityPositionCollectArgs, UniswapV3LiquidityPositionLib, uniswapV3LiquidityPositionMintArgs, uniswapV3LiquidityPositionPurgeArgs, uniswapV3LiquidityPositionRemoveLiquidityArgs, feeManagerConfigArgs, FeeSettlementType, FeeHook, IFee, aaveLendArgs, callOnIntegrationArgs, lendSelector, aaveRedeemArgs, redeemSelector, compoundClaimRewardsArgs, claimRewardsSelector, compoundArgs, curveTakeOrderArgs, takeOrderSelector, curveClaimRewardsArgs, curveLendArgs, curveLendAndStakeArgs, lendAndStakeSelector, curveRedeemArgs, curveStakeArgs, stakeSelector, curveUnstakeArgs, unstakeSelector, curveUnstakeAndRedeemArgs, unstakeAndRedeemSelector, curveAaveLendArgs, curveAaveLendAndStakeArgs, curveAaveRedeemArgs, curveAaveStakeArgs, curveAaveUnstakeAndRedeemArgs, curveAaveUnstakeArgs, curveSethLendArgs, curveSethLendAndStakeArgs, curveSethRedeemArgs, curveSethStakeArgs, curveSethUnstakeAndRedeemArgs, curveSethUnstakeArgs, curveStethLendArgs, curveStethLendAndStakeArgs, curveStethRedeemArgs, curveStethStakeArgs, curveStethUnstakeAndRedeemArgs, curveStethUnstakeArgs, idleClaimRewardsArgs, idleLendArgs, idleRedeemArgs, sighash, olympusV2StakeArgs, olympusV2UnstakeArgs, paraSwapV4TakeOrderArgs, paraSwapV5TakeOrderArgs, poolTogetherV4LendArgs, poolTogetherV4RedeemArgs, poolTogetherV4ClaimRewardsArgs, synthetixAssignExchangeDelegateSelector, synthetixRedeemArgs, synthetixTakeOrderArgs, uniswapV2LendArgs, uniswapV2RedeemArgs, uniswapV2TakeOrderArgs, uniswapV3TakeOrderArgs, yearnVaultV2LendArgs, yearnVaultV2RedeemArgs, zeroExV2TakeOrderArgs, policyManagerConfigArgs, PolicyHook, IPolicy, encodeFunctionData, ComptrollerProxy, VaultProxy, GasRelayPaymasterLib, addressListRegistryCreateListSelector, curveMinterMintSelector, curveMinterMintManySelector, curveMinterToggleApproveMintSelector, IGsnRelayHub, createSignedRelayRequest, isTypedDataSigner } from '@enzymefinance/protocol';
 import { utils, constants, BigNumber } from 'ethers';
 import { extractEvent, contract, resolveAddress, randomAddress } from '@enzymefinance/ethers';
 import _taggedTemplateLiteral from '@babel/runtime/helpers/esm/taggedTemplateLiteral';
+import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
 import _toConsumableArray from '@babel/runtime/helpers/esm/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
 
@@ -112,17 +113,18 @@ function _deployProtocolFixture() {
               allowedDepositRecipientsPolicy: new AllowedDepositRecipientsPolicy(fixture['AllowedDepositRecipientsPolicy'].address, deployer),
               allowedExternalPositionTypesPolicy: new AllowedExternalPositionTypesPolicy(fixture['AllowedExternalPositionTypesPolicy'].address, deployer),
               allowedSharesTransferRecipientsPolicy: new AllowedSharesTransferRecipientsPolicy(fixture['AllowedSharesTransferRecipientsPolicy'].address, deployer),
-              assetFinalityResolver: new AssetFinalityResolver(fixture['AssetFinalityResolver'].address, deployer),
               compoundAdapter: new CompoundAdapter(fixture['CompoundAdapter'].address, deployer),
               compoundDebtPositionLib: new CompoundDebtPositionLib(fixture['CompoundDebtPositionLib'].address, deployer),
               compoundDebtPositionParser: new CompoundDebtPositionParser(fixture['CompoundDebtPositionParser'].address, deployer),
               compoundPriceFeed: new CompoundPriceFeed(fixture['CompoundPriceFeed'].address, deployer),
               comptrollerLib: new ComptrollerLib(fixture['ComptrollerLib'].address, deployer),
+              convexCurveLpStakingAdapter: new ConvexCurveLpStakingAdapter(fixture['ConvexCurveLpStakingAdapter'].address, deployer),
+              convexCurveLpStakingWrapperFactory: new ConvexCurveLpStakingWrapperFactory(fixture['ConvexCurveLpStakingWrapperFactory'].address, deployer),
+              convexCurveLpStakingWrapperPriceFeed: new ConvexCurveLpStakingWrapperPriceFeed(fixture['ConvexCurveLpStakingWrapperPriceFeed'].address, deployer),
               cumulativeSlippageTolerancePolicy: new CumulativeSlippageTolerancePolicy(fixture['CumulativeSlippageTolerancePolicy'].address, deployer),
               curveExchangeAdapter: new CurveExchangeAdapter(fixture['CurveExchangeAdapter'].address, deployer),
               curveLiquidityAaveAdapter: new CurveLiquidityAaveAdapter(fixture['CurveLiquidityAaveAdapter'].address, deployer),
               curveLiquidityAdapter: new CurveLiquidityAdapter(fixture['CurveLiquidityAdapter'].address, deployer),
-              curveLiquidityEursAdapter: new CurveLiquidityEursAdapter(fixture['CurveLiquidityEursAdapter'].address, deployer),
               curveLiquiditySethAdapter: new CurveLiquiditySethAdapter(fixture['CurveLiquiditySethAdapter'].address, deployer),
               curveLiquidityStethAdapter: new CurveLiquidityStethAdapter(fixture['CurveLiquidityStethAdapter'].address, deployer),
               curvePriceFeed: new CurvePriceFeed(fixture['CurvePriceFeed'].address, deployer),
@@ -139,8 +141,9 @@ function _deployProtocolFixture() {
               fundValueCalculator: new FundValueCalculator(fixture['FundValueCalculator'].address, deployer),
               fundValueCalculatorRouter: new FundValueCalculatorRouter(fixture['FundValueCalculatorRouter'].address, deployer),
               fundValueCalculatorUsdWrapper: new FundValueCalculatorUsdWrapper(fixture['FundValueCalculatorUsdWrapper'].address, deployer),
+              fuseAdapter: new FuseAdapter(fixture['FuseAdapter'].address, deployer),
+              fusePriceFeed: new FusePriceFeed(fixture['FusePriceFeed'].address, deployer),
               gasRelayPaymasterFactory: new GasRelayPaymasterFactory(fixture['GasRelayPaymasterFactory'].address, deployer),
-              guaranteedRedemptionPolicy: new GuaranteedRedemptionPolicy(fixture['GuaranteedRedemptionPolicy'].address, deployer),
               idleAdapter: new IdleAdapter(fixture['IdleAdapter'].address, deployer),
               idlePriceFeed: new IdlePriceFeed(fixture['IdlePriceFeed'].address, deployer),
               integrationManager: new IntegrationManager(fixture['IntegrationManager'].address, deployer),
@@ -163,7 +166,6 @@ function _deployProtocolFixture() {
               revertingPriceFeed: new RevertingPriceFeed(fixture['RevertingPriceFeed'].address, deployer),
               stakehoundEthPriceFeed: new StakehoundEthPriceFeed(fixture['StakehoundEthPriceFeed'].address, deployer),
               synthetixAdapter: new SynthetixAdapter(fixture['SynthetixAdapter'].address, deployer),
-              synthetixPriceFeed: new SynthetixPriceFeed(fixture['SynthetixPriceFeed'].address, deployer),
               uniswapV2ExchangeAdapter: new UniswapV2ExchangeAdapter(fixture['UniswapV2ExchangeAdapter'].address, deployer),
               uniswapV2LiquidityAdapter: new UniswapV2LiquidityAdapter(fixture['UniswapV2LiquidityAdapter'].address, deployer),
               uniswapV2PoolPriceFeed: new UniswapV2PoolPriceFeed(fixture['UniswapV2PoolPriceFeed'].address, deployer),
@@ -381,13 +383,13 @@ function createFundDeployer(_x) {
 
 function _createFundDeployer() {
   _createFundDeployer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.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.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();
 
@@ -438,7 +440,7 @@ function _createFundDeployer() {
           case 31:
             nextIntegrationManager = _context.sent;
             _context.next = 34;
-            return ComptrollerLib.deploy(deployer, dispatcher, protocolFeeReserve, nextFundDeployer, valueInterpreter, nextExternalPositionManager, nextFeeManager, nextIntegrationManager, nextPolicyManager, assetFinalityResolver, gasRelayPaymasterFactory, mlnToken, wethToken);
+            return ComptrollerLib.deploy(deployer, dispatcher, protocolFeeReserve, nextFundDeployer, valueInterpreter, nextExternalPositionManager, nextFeeManager, nextIntegrationManager, nextPolicyManager, gasRelayPaymasterFactory, mlnToken, wethToken);
 
           case 34:
             nextComptrollerLib = _context.sent;
@@ -599,15 +601,15 @@ function createExternalPosition(_x2) {
 
 function _createExternalPosition() {
   _createExternalPosition = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.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.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, ExternalPositionManagerActionId.CreateExternalPosition, encodeArgs(['uint256', 'bytes'], [externalPositionTypeId, initializationData]));
+            return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, ExternalPositionManagerActionId.CreateExternalPosition, encodeArgs(['uint256', 'bytes', 'bytes'], [externalPositionTypeId, initializationData, callOnExternalPositionData]));
 
           case 3:
             receipt = _context2.sent;
@@ -936,7 +938,12 @@ function _createMockExternalPosition() {
 
           case 21:
             _context.next = 23;
-            return comptrollerProxy.connect(fundOwner).callOnExtension(externalPositionManager, ExternalPositionManagerActionId.CreateExternalPosition, encodeArgs(['uint256', 'bytes'], [typeId, '0x']));
+            return createExternalPosition({
+              comptrollerProxy: comptrollerProxy,
+              externalPositionManager: externalPositionManager,
+              externalPositionTypeId: typeId,
+              signer: fundOwner
+            });
 
           case 23:
             receipt = _context.sent;
@@ -1125,41 +1132,32 @@ function createUniswapV3LiquidityPosition(_x) {
 
 function _createUniswapV3LiquidityPosition() {
   _createUniswapV3LiquidityPosition = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.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.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 = 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: ExternalPositionType.UniswapV3LiquidityPosition,
+              signer: signer
             });
-            _context.next = 4;
-            return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, ExternalPositionManagerActionId.CreateExternalPosition, encodeArgs(['uint256', 'bytes'], [ExternalPositionType.UniswapV3LiquidityPosition, initArgs]));
-
-          case 4:
-            receipt = _context.sent;
-            _context.t0 = 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();
         }
@@ -1244,13 +1242,13 @@ function uniswapV3LiquidityPositionMint(_x4) {
 
 function _uniswapV3LiquidityPositionMint() {
   _uniswapV3LiquidityPositionMint = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.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.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 = uniswapV3LiquidityPositionMintArgs({
               amount0Desired: amount0Desired,
               amount0Min: amount0Min,
@@ -1258,7 +1256,9 @@ function _uniswapV3LiquidityPositionMint() {
               amount1Min: amount1Min,
               fee: fee,
               tickLower: tickLower,
-              tickUpper: tickUpper
+              tickUpper: tickUpper,
+              token0: token0,
+              token1: token1
             });
             callArgs = callOnExternalPositionArgs({
               actionArgs: actionArgs,
@@ -1530,19 +1530,234 @@ function _aaveRedeem() {
 
 var _templateObject$2;
 var ICompoundComptroller = 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.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.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.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 ? utils.parseEther('1') : _ref$tokenAmount, _ref$cTokenAmount = _ref.cTokenAmount, cTokenAmount = _ref$cTokenAmount === void 0 ? 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 ? utils.parseEther('1') : _ref$tokenAmount, cToken = _ref.cToken, compoundPriceFeed = _ref.compoundPriceFeed;
+            _context.t0 = 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(utils.parseEther('1')).div(rateBefore).mul(BigNumber.from('999')).div(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(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.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.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 = 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 = 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(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(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.mark(function _callee3(_ref3) {
+    var comptrollerProxy, integrationManager, fundOwner, compoundAdapter, compoundComptroller, cTokens, claimArgs, callArgs, claimRewardsTx;
+    return _regeneratorRuntime.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 = compoundClaimRewardsArgs({
+              cTokens: cTokens,
+              compoundComptroller: compoundComptroller
+            });
+            callArgs = callOnIntegrationArgs({
+              adapter: compoundAdapter,
+              encodedCallArgs: claimArgs,
+              selector: claimRewardsSelector
+            });
+            claimRewardsTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, 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.mark(function _callee4(_ref4) {
+    var comptrollerProxy, integrationManager, fundOwner, compoundAdapter, cToken, _ref4$tokenAmount, tokenAmount, _ref4$cTokenAmount, cTokenAmount, lendArgs, callArgs, lendTx;
+
+    return _regeneratorRuntime.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 ? utils.parseEther('1') : _ref4$tokenAmount, _ref4$cTokenAmount = _ref4.cTokenAmount, cTokenAmount = _ref4$cTokenAmount === void 0 ? utils.parseEther('1') : _ref4$cTokenAmount;
             lendArgs = compoundArgs({
               cToken: cToken,
               minIncomingAssetAmount: cTokenAmount,
@@ -1554,31 +1769,31 @@ function _compoundLend() {
               selector: lendSelector
             });
             lendTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, 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.mark(function _callee2(_ref2) {
-    var comptrollerProxy, integrationManager, fundOwner, compoundAdapter, cToken, _ref2$tokenAmount, tokenAmount, _ref2$cTokenAmount, cTokenAmount, redeemArgs, callArgs, redeemTx;
+  _compoundRedeem = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(_ref5) {
+    var comptrollerProxy, integrationManager, fundOwner, compoundAdapter, cToken, _ref5$tokenAmount, tokenAmount, _ref5$cTokenAmount, cTokenAmount, redeemArgs, callArgs, redeemTx;
 
-    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+    return _regeneratorRuntime.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 ? utils.parseEther('1') : _ref2$tokenAmount, _ref2$cTokenAmount = _ref2.cTokenAmount, cTokenAmount = _ref2$cTokenAmount === void 0 ? 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 ? utils.parseEther('1') : _ref5$tokenAmount, _ref5$cTokenAmount = _ref5.cTokenAmount, cTokenAmount = _ref5$cTokenAmount === void 0 ? utils.parseEther('1') : _ref5$cTokenAmount;
             redeemArgs = compoundArgs({
               cToken: resolveAddress(cToken),
               minIncomingAssetAmount: tokenAmount,
@@ -1590,14 +1805,14 @@ function _compoundRedeem() {
               selector: redeemSelector
             });
             redeemTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, 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);
 }
@@ -1651,11 +1866,11 @@ function curveClaimRewards(_ref2) {
       integrationManager = _ref2.integrationManager,
       fundOwner = _ref2.fundOwner,
       curveLiquidityAdapter = _ref2.curveLiquidityAdapter,
-      gaugeToken = _ref2.gaugeToken;
+      stakingToken = _ref2.stakingToken;
   var callArgs = callOnIntegrationArgs({
     adapter: curveLiquidityAdapter,
     encodedCallArgs: curveClaimRewardsArgs({
-      gaugeToken: gaugeToken
+      stakingToken: stakingToken
     }),
     selector: claimRewardsSelector
   });
@@ -1702,18 +1917,18 @@ function curveLendAndStake(_x3) {
 
 function _curveLendAndStake() {
   _curveLendAndStake = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_ref4) {
-    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, orderedOutgoingAssetAmounts, incomingGaugeToken, _ref4$minIncomingGaug, minIncomingGaugeTokenAmount, useUnderlyings, callArgs;
+    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, orderedOutgoingAssetAmounts, incomingStakingToken, _ref4$minIncomingStak, minIncomingStakingTokenAmount, useUnderlyings, callArgs;
 
     return _regeneratorRuntime.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, incomingGaugeToken = _ref4.incomingGaugeToken, _ref4$minIncomingGaug = _ref4.minIncomingGaugeTokenAmount, minIncomingGaugeTokenAmount = _ref4$minIncomingGaug === void 0 ? BigNumber.from(1) : _ref4$minIncomingGaug, useUnderlyings = _ref4.useUnderlyings;
+            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 ? BigNumber.from(1) : _ref4$minIncomingStak, useUnderlyings = _ref4.useUnderlyings;
             callArgs = callOnIntegrationArgs({
               adapter: curveLiquidityAdapter,
               encodedCallArgs: curveLendAndStakeArgs({
-                incomingGaugeToken: incomingGaugeToken,
-                minIncomingGaugeTokenAmount: minIncomingGaugeTokenAmount,
+                incomingStakingToken: incomingStakingToken,
+                minIncomingStakingTokenAmount: minIncomingStakingTokenAmount,
                 orderedOutgoingAssetAmounts: orderedOutgoingAssetAmounts,
                 pool: pool,
                 useUnderlyings: useUnderlyings
@@ -1773,17 +1988,17 @@ function curveStake(_x5) {
 
 function _curveStake() {
   _curveStake = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(_ref6) {
-    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, incomingGaugeToken, amount, callArgs;
+    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, incomingStakingToken, amount, callArgs;
     return _regeneratorRuntime.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, incomingGaugeToken = _ref6.incomingGaugeToken, amount = _ref6.amount;
+            comptrollerProxy = _ref6.comptrollerProxy, integrationManager = _ref6.integrationManager, signer = _ref6.signer, curveLiquidityAdapter = _ref6.curveLiquidityAdapter, pool = _ref6.pool, incomingStakingToken = _ref6.incomingStakingToken, amount = _ref6.amount;
             callArgs = callOnIntegrationArgs({
               adapter: curveLiquidityAdapter,
               encodedCallArgs: curveStakeArgs({
                 amount: amount,
-                incomingGaugeToken: incomingGaugeToken,
+                incomingStakingToken: incomingStakingToken,
                 pool: pool
               }),
               selector: stakeSelector
@@ -1806,17 +2021,17 @@ function curveUnstake(_x6) {
 
 function _curveUnstake() {
   _curveUnstake = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(_ref7) {
-    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, outgoingGaugeToken, amount, callArgs;
+    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, outgoingStakingToken, amount, callArgs;
     return _regeneratorRuntime.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, outgoingGaugeToken = _ref7.outgoingGaugeToken, amount = _ref7.amount;
+            comptrollerProxy = _ref7.comptrollerProxy, integrationManager = _ref7.integrationManager, signer = _ref7.signer, curveLiquidityAdapter = _ref7.curveLiquidityAdapter, pool = _ref7.pool, outgoingStakingToken = _ref7.outgoingStakingToken, amount = _ref7.amount;
             callArgs = callOnIntegrationArgs({
               adapter: curveLiquidityAdapter,
               encodedCallArgs: curveUnstakeArgs({
                 amount: amount,
-                outgoingGaugeToken: outgoingGaugeToken,
+                outgoingStakingToken: outgoingStakingToken,
                 pool: pool
               }),
               selector: unstakeSelector
@@ -1839,18 +2054,18 @@ function curveUnstakeAndRedeem(_x7) {
 
 function _curveUnstakeAndRedeem() {
   _curveUnstakeAndRedeem = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(_ref8) {
-    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, outgoingGaugeToken, outgoingGaugeTokenAmount, useUnderlyings, redeemType, incomingAssetData, callArgs;
+    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, outgoingStakingToken, outgoingStakingTokenAmount, useUnderlyings, redeemType, incomingAssetData, callArgs;
     return _regeneratorRuntime.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, outgoingGaugeToken = _ref8.outgoingGaugeToken, outgoingGaugeTokenAmount = _ref8.outgoingGaugeTokenAmount, useUnderlyings = _ref8.useUnderlyings, redeemType = _ref8.redeemType, incomingAssetData = _ref8.incomingAssetData;
+            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 = callOnIntegrationArgs({
               adapter: curveLiquidityAdapter,
               encodedCallArgs: curveUnstakeAndRedeemArgs({
                 incomingAssetData: incomingAssetData,
-                outgoingGaugeToken: outgoingGaugeToken,
-                outgoingGaugeTokenAmount: outgoingGaugeTokenAmount,
+                outgoingStakingToken: outgoingStakingToken,
+                outgoingStakingTokenAmount: outgoingStakingTokenAmount,
                 pool: pool,
                 redeemType: redeemType,
                 useUnderlyings: useUnderlyings
@@ -2026,72 +2241,72 @@ function curveAaveUnstake(_ref15) {
     selector: unstakeSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-} // eurs pool
+} // sETH pool
 
-function curveEursClaimRewards(_ref16) {
+function curveSethClaimRewards(_ref16) {
   var comptrollerProxy = _ref16.comptrollerProxy,
       integrationManager = _ref16.integrationManager,
       fundOwner = _ref16.fundOwner,
-      curveLiquidityEursAdapter = _ref16.curveLiquidityEursAdapter;
+      curveLiquiditySethAdapter = _ref16.curveLiquiditySethAdapter;
   var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
+    adapter: curveLiquiditySethAdapter,
     encodedCallArgs: constants.HashZero,
     selector: claimRewardsSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
-function curveEursLend(_ref17) {
+function curveSethLend(_ref17) {
   var comptrollerProxy = _ref17.comptrollerProxy,
       integrationManager = _ref17.integrationManager,
       fundOwner = _ref17.fundOwner,
-      curveLiquidityEursAdapter = _ref17.curveLiquidityEursAdapter,
-      outgoingEursAmount = _ref17.outgoingEursAmount,
-      outgoingSeurAmount = _ref17.outgoingSeurAmount,
+      curveLiquiditySethAdapter = _ref17.curveLiquiditySethAdapter,
+      outgoingWethAmount = _ref17.outgoingWethAmount,
+      outgoingSethAmount = _ref17.outgoingSethAmount,
       minIncomingLPTokenAmount = _ref17.minIncomingLPTokenAmount;
   var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: curveEursLendArgs({
+    adapter: curveLiquiditySethAdapter,
+    encodedCallArgs: curveSethLendArgs({
       minIncomingLPTokenAmount: minIncomingLPTokenAmount,
-      outgoingEursAmount: outgoingEursAmount,
-      outgoingSeurAmount: outgoingSeurAmount
+      outgoingSethAmount: outgoingSethAmount,
+      outgoingWethAmount: outgoingWethAmount
     }),
     selector: lendSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
-function curveEursLendAndStake(_ref18) {
+function curveSethLendAndStake(_ref18) {
   var comptrollerProxy = _ref18.comptrollerProxy,
       integrationManager = _ref18.integrationManager,
       fundOwner = _ref18.fundOwner,
-      curveLiquidityEursAdapter = _ref18.curveLiquidityEursAdapter,
-      outgoingEursAmount = _ref18.outgoingEursAmount,
-      outgoingSeurAmount = _ref18.outgoingSeurAmount,
+      curveLiquiditySethAdapter = _ref18.curveLiquiditySethAdapter,
+      outgoingWethAmount = _ref18.outgoingWethAmount,
+      outgoingSethAmount = _ref18.outgoingSethAmount,
       minIncomingLiquidityGaugeTokenAmount = _ref18.minIncomingLiquidityGaugeTokenAmount;
   var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: curveEursLendAndStakeArgs({
+    adapter: curveLiquiditySethAdapter,
+    encodedCallArgs: curveSethLendAndStakeArgs({
       minIncomingLiquidityGaugeTokenAmount: minIncomingLiquidityGaugeTokenAmount,
-      outgoingEursAmount: outgoingEursAmount,
-      outgoingSeurAmount: outgoingSeurAmount
+      outgoingSethAmount: outgoingSethAmount,
+      outgoingWethAmount: outgoingWethAmount
     }),
     selector: lendAndStakeSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
-function curveEursRedeem(_ref19) {
+function curveSethRedeem(_ref19) {
   var comptrollerProxy = _ref19.comptrollerProxy,
       integrationManager = _ref19.integrationManager,
       fundOwner = _ref19.fundOwner,
-      curveLiquidityEursAdapter = _ref19.curveLiquidityEursAdapter,
+      curveLiquiditySethAdapter = _ref19.curveLiquiditySethAdapter,
       outgoingLPTokenAmount = _ref19.outgoingLPTokenAmount,
-      minIncomingEursAmount = _ref19.minIncomingEursAmount,
-      minIncomingSeurAmount = _ref19.minIncomingSeurAmount,
+      minIncomingWethAmount = _ref19.minIncomingWethAmount,
+      minIncomingSethAmount = _ref19.minIncomingSethAmount,
       receiveSingleAsset = _ref19.receiveSingleAsset;
   var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: curveEursRedeemArgs({
-      minIncomingEursAmount: minIncomingEursAmount,
-      minIncomingSeurAmount: minIncomingSeurAmount,
+    adapter: curveLiquiditySethAdapter,
+    encodedCallArgs: curveSethRedeemArgs({
+      minIncomingSethAmount: minIncomingSethAmount,
+      minIncomingWethAmount: minIncomingWethAmount,
       outgoingLPTokenAmount: outgoingLPTokenAmount,
       receiveSingleAsset: receiveSingleAsset
     }),
@@ -2099,35 +2314,35 @@ function curveEursRedeem(_ref19) {
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
-function curveEursStake(_ref20) {
+function curveSethStake(_ref20) {
   var comptrollerProxy = _ref20.comptrollerProxy,
       integrationManager = _ref20.integrationManager,
       fundOwner = _ref20.fundOwner,
-      curveLiquidityEursAdapter = _ref20.curveLiquidityEursAdapter,
+      curveLiquiditySethAdapter = _ref20.curveLiquiditySethAdapter,
       outgoingLPTokenAmount = _ref20.outgoingLPTokenAmount;
   var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: curveEursStakeArgs({
+    adapter: curveLiquiditySethAdapter,
+    encodedCallArgs: curveSethStakeArgs({
       outgoingLPTokenAmount: outgoingLPTokenAmount
     }),
     selector: stakeSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
-function curveEursUnstakeAndRedeem(_ref21) {
+function curveSethUnstakeAndRedeem(_ref21) {
   var comptrollerProxy = _ref21.comptrollerProxy,
       integrationManager = _ref21.integrationManager,
       fundOwner = _ref21.fundOwner,
-      curveLiquidityEursAdapter = _ref21.curveLiquidityEursAdapter,
+      curveLiquiditySethAdapter = _ref21.curveLiquiditySethAdapter,
       outgoingLiquidityGaugeTokenAmount = _ref21.outgoingLiquidityGaugeTokenAmount,
-      minIncomingEursAmount = _ref21.minIncomingEursAmount,
-      minIncomingSeurAmount = _ref21.minIncomingSeurAmount,
+      minIncomingWethAmount = _ref21.minIncomingWethAmount,
+      minIncomingSethAmount = _ref21.minIncomingSethAmount,
       receiveSingleAsset = _ref21.receiveSingleAsset;
   var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: curveEursUnstakeAndRedeemArgs({
-      minIncomingEursAmount: minIncomingEursAmount,
-      minIncomingSeurAmount: minIncomingSeurAmount,
+    adapter: curveLiquiditySethAdapter,
+    encodedCallArgs: curveSethUnstakeAndRedeemArgs({
+      minIncomingSethAmount: minIncomingSethAmount,
+      minIncomingWethAmount: minIncomingWethAmount,
       outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount,
       receiveSingleAsset: receiveSingleAsset
     }),
@@ -2135,85 +2350,85 @@ function curveEursUnstakeAndRedeem(_ref21) {
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
-function curveEursUnstake(_ref22) {
+function curveSethUnstake(_ref22) {
   var comptrollerProxy = _ref22.comptrollerProxy,
       integrationManager = _ref22.integrationManager,
       fundOwner = _ref22.fundOwner,
-      curveLiquidityEursAdapter = _ref22.curveLiquidityEursAdapter,
+      curveLiquiditySethAdapter = _ref22.curveLiquiditySethAdapter,
       outgoingLiquidityGaugeTokenAmount = _ref22.outgoingLiquidityGaugeTokenAmount;
   var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: curveEursUnstakeArgs({
+    adapter: curveLiquiditySethAdapter,
+    encodedCallArgs: curveSethUnstakeArgs({
       outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount
     }),
     selector: unstakeSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-} // sETH pool
+} // stETH pool
 
-function curveSethClaimRewards(_ref23) {
+function curveStethClaimRewards(_ref23) {
   var comptrollerProxy = _ref23.comptrollerProxy,
       integrationManager = _ref23.integrationManager,
       fundOwner = _ref23.fundOwner,
-      curveLiquiditySethAdapter = _ref23.curveLiquiditySethAdapter;
+      curveLiquidityStethAdapter = _ref23.curveLiquidityStethAdapter;
   var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
+    adapter: curveLiquidityStethAdapter,
     encodedCallArgs: constants.HashZero,
     selector: claimRewardsSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
-function curveSethLend(_ref24) {
+function curveStethLend(_ref24) {
   var comptrollerProxy = _ref24.comptrollerProxy,
       integrationManager = _ref24.integrationManager,
       fundOwner = _ref24.fundOwner,
-      curveLiquiditySethAdapter = _ref24.curveLiquiditySethAdapter,
+      curveLiquidityStethAdapter = _ref24.curveLiquidityStethAdapter,
       outgoingWethAmount = _ref24.outgoingWethAmount,
-      outgoingSethAmount = _ref24.outgoingSethAmount,
+      outgoingStethAmount = _ref24.outgoingStethAmount,
       minIncomingLPTokenAmount = _ref24.minIncomingLPTokenAmount;
   var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: curveSethLendArgs({
+    adapter: curveLiquidityStethAdapter,
+    encodedCallArgs: curveStethLendArgs({
       minIncomingLPTokenAmount: minIncomingLPTokenAmount,
-      outgoingSethAmount: outgoingSethAmount,
+      outgoingStethAmount: outgoingStethAmount,
       outgoingWethAmount: outgoingWethAmount
     }),
     selector: lendSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
-function curveSethLendAndStake(_ref25) {
+function curveStethLendAndStake(_ref25) {
   var comptrollerProxy = _ref25.comptrollerProxy,
       integrationManager = _ref25.integrationManager,
       fundOwner = _ref25.fundOwner,
-      curveLiquiditySethAdapter = _ref25.curveLiquiditySethAdapter,
+      curveLiquidityStethAdapter = _ref25.curveLiquidityStethAdapter,
       outgoingWethAmount = _ref25.outgoingWethAmount,
-      outgoingSethAmount = _ref25.outgoingSethAmount,
+      outgoingStethAmount = _ref25.outgoingStethAmount,
       minIncomingLiquidityGaugeTokenAmount = _ref25.minIncomingLiquidityGaugeTokenAmount;
   var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: curveSethLendAndStakeArgs({
+    adapter: curveLiquidityStethAdapter,
+    encodedCallArgs: curveStethLendAndStakeArgs({
       minIncomingLiquidityGaugeTokenAmount: minIncomingLiquidityGaugeTokenAmount,
-      outgoingSethAmount: outgoingSethAmount,
+      outgoingStethAmount: outgoingStethAmount,
       outgoingWethAmount: outgoingWethAmount
     }),
     selector: lendAndStakeSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
-function curveSethRedeem(_ref26) {
+function curveStethRedeem(_ref26) {
   var comptrollerProxy = _ref26.comptrollerProxy,
       integrationManager = _ref26.integrationManager,
       fundOwner = _ref26.fundOwner,
-      curveLiquiditySethAdapter = _ref26.curveLiquiditySethAdapter,
+      curveLiquidityStethAdapter = _ref26.curveLiquidityStethAdapter,
       outgoingLPTokenAmount = _ref26.outgoingLPTokenAmount,
       minIncomingWethAmount = _ref26.minIncomingWethAmount,
-      minIncomingSethAmount = _ref26.minIncomingSethAmount,
+      minIncomingStethAmount = _ref26.minIncomingStethAmount,
       receiveSingleAsset = _ref26.receiveSingleAsset;
   var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: curveSethRedeemArgs({
-      minIncomingSethAmount: minIncomingSethAmount,
+    adapter: curveLiquidityStethAdapter,
+    encodedCallArgs: curveStethRedeemArgs({
+      minIncomingStethAmount: minIncomingStethAmount,
       minIncomingWethAmount: minIncomingWethAmount,
       outgoingLPTokenAmount: outgoingLPTokenAmount,
       receiveSingleAsset: receiveSingleAsset
@@ -2222,34 +2437,34 @@ function curveSethRedeem(_ref26) {
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
-function curveSethStake(_ref27) {
+function curveStethStake(_ref27) {
   var comptrollerProxy = _ref27.comptrollerProxy,
       integrationManager = _ref27.integrationManager,
       fundOwner = _ref27.fundOwner,
-      curveLiquiditySethAdapter = _ref27.curveLiquiditySethAdapter,
+      curveLiquidityStethAdapter = _ref27.curveLiquidityStethAdapter,
       outgoingLPTokenAmount = _ref27.outgoingLPTokenAmount;
   var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: curveSethStakeArgs({
+    adapter: curveLiquidityStethAdapter,
+    encodedCallArgs: curveStethStakeArgs({
       outgoingLPTokenAmount: outgoingLPTokenAmount
     }),
     selector: stakeSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
-function curveSethUnstakeAndRedeem(_ref28) {
+function curveStethUnstakeAndRedeem(_ref28) {
   var comptrollerProxy = _ref28.comptrollerProxy,
       integrationManager = _ref28.integrationManager,
       fundOwner = _ref28.fundOwner,
-      curveLiquiditySethAdapter = _ref28.curveLiquiditySethAdapter,
+      curveLiquidityStethAdapter = _ref28.curveLiquidityStethAdapter,
       outgoingLiquidityGaugeTokenAmount = _ref28.outgoingLiquidityGaugeTokenAmount,
       minIncomingWethAmount = _ref28.minIncomingWethAmount,
-      minIncomingSethAmount = _ref28.minIncomingSethAmount,
+      minIncomingStethAmount = _ref28.minIncomingStethAmount,
       receiveSingleAsset = _ref28.receiveSingleAsset;
   var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: curveSethUnstakeAndRedeemArgs({
-      minIncomingSethAmount: minIncomingSethAmount,
+    adapter: curveLiquidityStethAdapter,
+    encodedCallArgs: curveStethUnstakeAndRedeemArgs({
+      minIncomingStethAmount: minIncomingStethAmount,
       minIncomingWethAmount: minIncomingWethAmount,
       outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount,
       receiveSingleAsset: receiveSingleAsset
@@ -2258,135 +2473,12 @@ function curveSethUnstakeAndRedeem(_ref28) {
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
-function curveSethUnstake(_ref29) {
+function curveStethUnstake(_ref29) {
   var comptrollerProxy = _ref29.comptrollerProxy,
       integrationManager = _ref29.integrationManager,
       fundOwner = _ref29.fundOwner,
-      curveLiquiditySethAdapter = _ref29.curveLiquiditySethAdapter,
+      curveLiquidityStethAdapter = _ref29.curveLiquidityStethAdapter,
       outgoingLiquidityGaugeTokenAmount = _ref29.outgoingLiquidityGaugeTokenAmount;
-  var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: curveSethUnstakeArgs({
-      outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount
-    }),
-    selector: unstakeSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-} // stETH pool
-
-function curveStethClaimRewards(_ref30) {
-  var comptrollerProxy = _ref30.comptrollerProxy,
-      integrationManager = _ref30.integrationManager,
-      fundOwner = _ref30.fundOwner,
-      curveLiquidityStethAdapter = _ref30.curveLiquidityStethAdapter;
-  var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityStethAdapter,
-    encodedCallArgs: constants.HashZero,
-    selector: claimRewardsSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveStethLend(_ref31) {
-  var comptrollerProxy = _ref31.comptrollerProxy,
-      integrationManager = _ref31.integrationManager,
-      fundOwner = _ref31.fundOwner,
-      curveLiquidityStethAdapter = _ref31.curveLiquidityStethAdapter,
-      outgoingWethAmount = _ref31.outgoingWethAmount,
-      outgoingStethAmount = _ref31.outgoingStethAmount,
-      minIncomingLPTokenAmount = _ref31.minIncomingLPTokenAmount;
-  var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityStethAdapter,
-    encodedCallArgs: curveStethLendArgs({
-      minIncomingLPTokenAmount: minIncomingLPTokenAmount,
-      outgoingStethAmount: outgoingStethAmount,
-      outgoingWethAmount: outgoingWethAmount
-    }),
-    selector: lendSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveStethLendAndStake(_ref32) {
-  var comptrollerProxy = _ref32.comptrollerProxy,
-      integrationManager = _ref32.integrationManager,
-      fundOwner = _ref32.fundOwner,
-      curveLiquidityStethAdapter = _ref32.curveLiquidityStethAdapter,
-      outgoingWethAmount = _ref32.outgoingWethAmount,
-      outgoingStethAmount = _ref32.outgoingStethAmount,
-      minIncomingLiquidityGaugeTokenAmount = _ref32.minIncomingLiquidityGaugeTokenAmount;
-  var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityStethAdapter,
-    encodedCallArgs: curveStethLendAndStakeArgs({
-      minIncomingLiquidityGaugeTokenAmount: minIncomingLiquidityGaugeTokenAmount,
-      outgoingStethAmount: outgoingStethAmount,
-      outgoingWethAmount: outgoingWethAmount
-    }),
-    selector: lendAndStakeSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveStethRedeem(_ref33) {
-  var comptrollerProxy = _ref33.comptrollerProxy,
-      integrationManager = _ref33.integrationManager,
-      fundOwner = _ref33.fundOwner,
-      curveLiquidityStethAdapter = _ref33.curveLiquidityStethAdapter,
-      outgoingLPTokenAmount = _ref33.outgoingLPTokenAmount,
-      minIncomingWethAmount = _ref33.minIncomingWethAmount,
-      minIncomingStethAmount = _ref33.minIncomingStethAmount,
-      receiveSingleAsset = _ref33.receiveSingleAsset;
-  var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityStethAdapter,
-    encodedCallArgs: curveStethRedeemArgs({
-      minIncomingStethAmount: minIncomingStethAmount,
-      minIncomingWethAmount: minIncomingWethAmount,
-      outgoingLPTokenAmount: outgoingLPTokenAmount,
-      receiveSingleAsset: receiveSingleAsset
-    }),
-    selector: redeemSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveStethStake(_ref34) {
-  var comptrollerProxy = _ref34.comptrollerProxy,
-      integrationManager = _ref34.integrationManager,
-      fundOwner = _ref34.fundOwner,
-      curveLiquidityStethAdapter = _ref34.curveLiquidityStethAdapter,
-      outgoingLPTokenAmount = _ref34.outgoingLPTokenAmount;
-  var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityStethAdapter,
-    encodedCallArgs: curveStethStakeArgs({
-      outgoingLPTokenAmount: outgoingLPTokenAmount
-    }),
-    selector: stakeSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveStethUnstakeAndRedeem(_ref35) {
-  var comptrollerProxy = _ref35.comptrollerProxy,
-      integrationManager = _ref35.integrationManager,
-      fundOwner = _ref35.fundOwner,
-      curveLiquidityStethAdapter = _ref35.curveLiquidityStethAdapter,
-      outgoingLiquidityGaugeTokenAmount = _ref35.outgoingLiquidityGaugeTokenAmount,
-      minIncomingWethAmount = _ref35.minIncomingWethAmount,
-      minIncomingStethAmount = _ref35.minIncomingStethAmount,
-      receiveSingleAsset = _ref35.receiveSingleAsset;
-  var callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityStethAdapter,
-    encodedCallArgs: curveStethUnstakeAndRedeemArgs({
-      minIncomingStethAmount: minIncomingStethAmount,
-      minIncomingWethAmount: minIncomingWethAmount,
-      outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount,
-      receiveSingleAsset: receiveSingleAsset
-    }),
-    selector: unstakeAndRedeemSelector
-  });
-  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-function curveStethUnstake(_ref36) {
-  var comptrollerProxy = _ref36.comptrollerProxy,
-      integrationManager = _ref36.integrationManager,
-      fundOwner = _ref36.fundOwner,
-      curveLiquidityStethAdapter = _ref36.curveLiquidityStethAdapter,
-      outgoingLiquidityGaugeTokenAmount = _ref36.outgoingLiquidityGaugeTokenAmount;
   var callArgs = callOnIntegrationArgs({
     adapter: curveLiquidityStethAdapter,
     encodedCallArgs: curveStethUnstakeArgs({
@@ -2858,24 +2950,16 @@ function synthetixAssignExchangeDelegate(_x) {
 
 function _synthetixAssignExchangeDelegate() {
   _synthetixAssignExchangeDelegate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref) {
-    var comptrollerProxy, addressResolver, fundOwner, delegate, delegateApprovals;
+    var comptrollerProxy, synthetixDelegateApprovals, fundOwner, delegate;
     return _regeneratorRuntime.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, synthetixAssignExchangeDelegateSelector, encodeArgs(['address'], [delegate]));
 
           case 3:
-            delegateApprovals = _context.sent;
-            _context.next = 6;
-            return comptrollerProxy.connect(fundOwner).vaultCallOnContract(delegateApprovals, synthetixAssignExchangeDelegateSelector, encodeArgs(['address'], [delegate]));
-
-          case 6:
           case "end":
             return _context.stop();
         }
@@ -2885,42 +2969,18 @@ function _synthetixAssignExchangeDelegate() {
   return _synthetixAssignExchangeDelegate.apply(this, arguments);
 }
 
-function synthetixResolveAddress(_x2) {
-  return _synthetixResolveAddress.apply(this, arguments);
-}
-
-function _synthetixResolveAddress() {
-  _synthetixResolveAddress = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref2) {
-    var addressResolver, name;
-    return _regeneratorRuntime.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(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.mark(function _callee3(_ref3) {
+  _synthetixRedeem = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref2) {
     var comptrollerProxy, integrationManager, signer, synthetixAdapter, synths, redeemArgs, callArgs;
-    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+    return _regeneratorRuntime.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 = synthetixRedeemArgs({
               synths: synths
             });
@@ -2929,48 +2989,47 @@ function _synthetixRedeem() {
               encodedCallArgs: redeemArgs,
               selector: redeemSelector
             });
-            return _context3.abrupt("return", comptrollerProxy.connect(signer).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs));
+            return _context2.abrupt("return", comptrollerProxy.connect(signer).callOnExtension(integrationManager, 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.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.mark(function _callee3(_ref3) {
+    var comptrollerProxy, vaultProxy, integrationManager, fundOwner, synthetixAdapter, outgoingAsset, _ref3$outgoingAssetAm, outgoingAssetAmount, _ref3$minIncomingSusd, minIncomingSusdAmount, _ref3$seedFund, seedFund, takeOrderArgs, callArgs;
 
-    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+    return _regeneratorRuntime.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 ? utils.parseEther('1') : _ref4$outgoingAssetAm, incomingAsset = _ref4.incomingAsset, _ref4$minIncomingAsse = _ref4.minIncomingAssetAmount, minIncomingAssetAmount = _ref4$minIncomingAsse === void 0 ? 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 ? utils.parseEther('1') : _ref3$outgoingAssetAm, _ref3$minIncomingSusd = _ref3.minIncomingSusdAmount, minIncomingSusdAmount = _ref3$minIncomingSusd === void 0 ? 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 = synthetixTakeOrderArgs({
-              incomingAsset: incomingAsset,
-              minIncomingAssetAmount: minIncomingAssetAmount,
+              minIncomingSusdAmount: minIncomingSusdAmount,
               outgoingAsset: outgoingAsset,
               outgoingAssetAmount: outgoingAssetAmount
             });
-            _context4.next = 7;
+            _context3.next = 7;
             return callOnIntegrationArgs({
               adapter: synthetixAdapter,
               encodedCallArgs: takeOrderArgs,
@@ -2978,15 +3037,15 @@ function _synthetixTakeOrder() {
             });
 
           case 7:
-            callArgs = _context4.sent;
-            return _context4.abrupt("return", comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs));
+            callArgs = _context3.sent;
+            return _context3.abrupt("return", comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs));
 
           case 9:
           case "end":
-            return _context4.stop();
+            return _context3.stop();
         }
       }
-    }, _callee4);
+    }, _callee3);
   }));
   return _synthetixTakeOrder.apply(this, arguments);
 }
@@ -3970,17 +4029,22 @@ var whales = {
   ceth: '0x8aceab8167c80cb8b3de7fa6228b889bb1130ee8',
   cuni: '0x39d8014b4f40d2cbc441137011d32023f4f1fd87',
   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',
-  eurs: '0x98ed26de6451db36246672df78ae7c50f2c76f6d',
-  ust: '0xf584f8728b874a6a5c7a8d4d387c9aae9172d621'
+  ust: '0xf584f8728b874a6a5c7a8d4d387c9aae9172d621',
+  // Curve steth pool related
+  stecrv: '0x56c915758ad3f76fd287fff7563ee313142fb663'
 };
 /* eslint-enable sort-keys-fix/sort-keys-fix */
 
@@ -4214,4 +4278,4 @@ function assertPaymasterDidRejectForReason(receipt, reason) {
   expect(utils.toUtf8String('0x' + params.reason.substr(138))).toMatch(reason);
 }
 
-export { CurveLiquidityGaugeV2, CurveMinter, CurveRegistry, CurveSwaps, ICompoundComptroller, IUniswapV3NonFungibleTokenManager, UniswapV2Factory, UniswapV3FeeAmount, aaveLend, aaveRedeem, addNewAssetsToFund, addTrackedAssetsToVault, assertDidRelay, assertDidRelaySuccessfully, assertDidRelayWithCharge, assertDidRelayWithError, assertEvent, assertNoEvent, assertPaymasterDidReject, assertPaymasterDidRejectForReason, buyShares, buySharesFunction, calcMlnValueAndBurnAmountForSharesBuyback, callOnExtension, callOnExternalPosition, compoundDebtPositionAddCollateral, compoundDebtPositionBorrow, compoundDebtPositionClaimComp, compoundDebtPositionRemoveCollateral, compoundDebtPositionRepayBorrow, compoundLend, compoundRedeem, createCompoundDebtPosition, createComptrollerProxy, createExternalPosition, createFundDeployer, createMigrationRequest, createMockExternalPosition, createNewFund, createReconfigurationRequest, createUniswapV3LiquidityPosition, createVaultProxy, curveAaveClaimRewards, curveAaveLend, curveAaveLendAndStake, curveAaveRedeem, curveAaveStake, curveAaveUnstake, curveAaveUnstakeAndRedeem, curveClaimRewards, curveEursClaimRewards, curveEursLend, curveEursLendAndStake, curveEursRedeem, curveEursStake, curveEursUnstake, curveEursUnstakeAndRedeem, curveLend, curveLendAndStake, curveRedeem, curveSethClaimRewards, curveSethLend, curveSethLendAndStake, curveSethRedeem, curveSethStake, curveSethUnstake, curveSethUnstakeAndRedeem, curveStake, curveStethClaimRewards, curveStethLend, curveStethLendAndStake, curveStethRedeem, curveStethStake, curveStethUnstake, curveStethUnstakeAndRedeem, curveTakeOrder, curveUnstake, curveUnstakeAndRedeem, deployProtocolFixture, generateFeeManagerConfigWithMockFees, generateMockFees, generateMockPolicies, generatePolicyManagerConfigWithMockPolicies, getAssetBalances, getAssetUnit, getNamedSigner, getUnnamedSigners, idleClaimRewards, idleLend, idleRedeem, mockExternalPositionAddDebtAssets, mockExternalPositionAddManagedAssets, mockExternalPositionRemoveDebtAssets, mockExternalPositionRemoveManagedAssets, mockGenericRemoveOnlySelector, mockGenericSwap, mockGenericSwapASelector, mockGenericSwapArgs, mockGenericSwapBSelector, mockGenericSwapDirectFromVaultSelector, mockGenericSwapViaApprovalSelector, olympusV2Stake, olympusV2Unstake, paraSwapV4GenerateDummyPaths, paraSwapV4TakeOrder, paraSwapV5GenerateDummyPaths, paraSwapV5TakeOrder, poolTogetherV4ClaimRewards, poolTogetherV4Lend, poolTogetherV4Redeem, reactivateExternalPosition, redeemSharesForSpecificAssets, redeemSharesInKind, relayTransaction, removeExternalPosition, removeTrackedAssetsFromVault, setupGasRelayerPaymaster, synthetixAssignExchangeDelegate, synthetixRedeem, synthetixResolveAddress, synthetixTakeOrder, transactionTimestamp, uniswapV2Lend, uniswapV2Redeem, uniswapV2TakeOrder, uniswapV3LiquidityPositionAddLiquidity, uniswapV3LiquidityPositionCollect, uniswapV3LiquidityPositionGetMaxTick, uniswapV3LiquidityPositionGetMinTick, uniswapV3LiquidityPositionMint, uniswapV3LiquidityPositionPurge, uniswapV3LiquidityPositionRemoveLiquidity, uniswapV3OrderTokenPair, uniswapV3TakeOrder, unlockAllWhales, unlockWhale, unlockWhales, updateChainlinkAggregator, vaultCallCreateNewList, vaultCallCurveMinterMint, vaultCallCurveMinterMintMany, vaultCallCurveMinterToggleApproveMint, vaultCallStartAssetBypassTimelock, yearnVaultV2Lend, yearnVaultV2Redeem, zeroExV2TakeOrder };
+export { CurveLiquidityGaugeV2, CurveMinter, CurveRegistry, CurveSwaps, ICompoundComptroller, IUniswapV3NonFungibleTokenManager, UniswapV2Factory, UniswapV3FeeAmount, aaveLend, aaveRedeem, addNewAssetsToFund, addTrackedAssetsToVault, assertCompoundLend, assertCompoundRedeem, assertDidRelay, assertDidRelaySuccessfully, assertDidRelayWithCharge, assertDidRelayWithError, assertEvent, assertNoEvent, assertPaymasterDidReject, assertPaymasterDidRejectForReason, buyShares, buySharesFunction, calcMlnValueAndBurnAmountForSharesBuyback, callOnExtension, callOnExternalPosition, compoundClaim, compoundDebtPositionAddCollateral, compoundDebtPositionBorrow, compoundDebtPositionClaimComp, compoundDebtPositionRemoveCollateral, compoundDebtPositionRepayBorrow, compoundLend, compoundRedeem, createCompoundDebtPosition, createComptrollerProxy, createExternalPosition, createFundDeployer, createMigrationRequest, createMockExternalPosition, createNewFund, createReconfigurationRequest, createUniswapV3LiquidityPosition, createVaultProxy, curveAaveClaimRewards, curveAaveLend, curveAaveLendAndStake, curveAaveRedeem, curveAaveStake, curveAaveUnstake, curveAaveUnstakeAndRedeem, curveClaimRewards, curveLend, curveLendAndStake, curveRedeem, curveSethClaimRewards, curveSethLend, curveSethLendAndStake, curveSethRedeem, curveSethStake, curveSethUnstake, curveSethUnstakeAndRedeem, curveStake, curveStethClaimRewards, curveStethLend, curveStethLendAndStake, curveStethRedeem, curveStethStake, curveStethUnstake, curveStethUnstakeAndRedeem, curveTakeOrder, curveUnstake, curveUnstakeAndRedeem, deployProtocolFixture, generateFeeManagerConfigWithMockFees, generateMockFees, generateMockPolicies, generatePolicyManagerConfigWithMockPolicies, getAssetBalances, getAssetUnit, getNamedSigner, getUnnamedSigners, idleClaimRewards, idleLend, idleRedeem, mockExternalPositionAddDebtAssets, mockExternalPositionAddManagedAssets, mockExternalPositionRemoveDebtAssets, mockExternalPositionRemoveManagedAssets, mockGenericRemoveOnlySelector, mockGenericSwap, mockGenericSwapASelector, mockGenericSwapArgs, mockGenericSwapBSelector, mockGenericSwapDirectFromVaultSelector, mockGenericSwapViaApprovalSelector, olympusV2Stake, olympusV2Unstake, paraSwapV4GenerateDummyPaths, paraSwapV4TakeOrder, paraSwapV5GenerateDummyPaths, paraSwapV5TakeOrder, poolTogetherV4ClaimRewards, poolTogetherV4Lend, poolTogetherV4Redeem, reactivateExternalPosition, redeemSharesForSpecificAssets, redeemSharesInKind, relayTransaction, removeExternalPosition, removeTrackedAssetsFromVault, setupGasRelayerPaymaster, synthetixAssignExchangeDelegate, synthetixRedeem, synthetixTakeOrder, transactionTimestamp, uniswapV2Lend, uniswapV2Redeem, uniswapV2TakeOrder, uniswapV3LiquidityPositionAddLiquidity, uniswapV3LiquidityPositionCollect, uniswapV3LiquidityPositionGetMaxTick, uniswapV3LiquidityPositionGetMinTick, uniswapV3LiquidityPositionMint, uniswapV3LiquidityPositionPurge, uniswapV3LiquidityPositionRemoveLiquidity, uniswapV3OrderTokenPair, uniswapV3TakeOrder, unlockAllWhales, unlockWhale, unlockWhales, updateChainlinkAggregator, vaultCallCreateNewList, vaultCallCurveMinterMint, vaultCallCurveMinterMintMany, vaultCallCurveMinterToggleApproveMint, vaultCallStartAssetBypassTimelock, yearnVaultV2Lend, yearnVaultV2Redeem, zeroExV2TakeOrder };