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

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');
 
@@ -120,17 +121,18 @@ 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),
               curveLiquidityAdapter: new protocol.CurveLiquidityAdapter(fixture['CurveLiquidityAdapter'].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),
               curvePriceFeed: new protocol.CurvePriceFeed(fixture['CurvePriceFeed'].address, deployer),
@@ -147,8 +149,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),
@@ -171,7 +174,6 @@ function _deployProtocolFixture() {
               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),
@@ -389,13 +391,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();
 
@@ -446,7 +448,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;
@@ -607,15 +609,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;
@@ -944,7 +946,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;
@@ -1133,41 +1140,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();
         }
@@ -1252,13 +1250,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,
@@ -1266,7 +1264,9 @@ function _uniswapV3LiquidityPositionMint() {
               amount1Min: amount1Min,
               fee: fee,
               tickLower: tickLower,
-              tickUpper: tickUpper
+              tickUpper: tickUpper,
+              token0: token0,
+              token1: token1
             });
             callArgs = protocol.callOnExternalPositionArgs({
               actionArgs: actionArgs,
@@ -1538,19 +1538,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,
@@ -1562,31 +1777,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,
@@ -1598,14 +1813,14 @@ 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);
 }
@@ -1659,11 +1874,11 @@ function curveClaimRewards(_ref2) {
       integrationManager = _ref2.integrationManager,
       fundOwner = _ref2.fundOwner,
       curveLiquidityAdapter = _ref2.curveLiquidityAdapter,
-      gaugeToken = _ref2.gaugeToken;
+      stakingToken = _ref2.stakingToken;
   var callArgs = protocol.callOnIntegrationArgs({
     adapter: curveLiquidityAdapter,
     encodedCallArgs: protocol.curveClaimRewardsArgs({
-      gaugeToken: gaugeToken
+      stakingToken: stakingToken
     }),
     selector: protocol.claimRewardsSelector
   });
@@ -1710,18 +1925,18 @@ function curveLendAndStake(_x3) {
 
 function _curveLendAndStake() {
   _curveLendAndStake = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].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__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, incomingGaugeToken = _ref4.incomingGaugeToken, _ref4$minIncomingGaug = _ref4.minIncomingGaugeTokenAmount, minIncomingGaugeTokenAmount = _ref4$minIncomingGaug === void 0 ? ethers.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 ? ethers.BigNumber.from(1) : _ref4$minIncomingStak, useUnderlyings = _ref4.useUnderlyings;
             callArgs = protocol.callOnIntegrationArgs({
               adapter: curveLiquidityAdapter,
               encodedCallArgs: protocol.curveLendAndStakeArgs({
-                incomingGaugeToken: incomingGaugeToken,
-                minIncomingGaugeTokenAmount: minIncomingGaugeTokenAmount,
+                incomingStakingToken: incomingStakingToken,
+                minIncomingStakingTokenAmount: minIncomingStakingTokenAmount,
                 orderedOutgoingAssetAmounts: orderedOutgoingAssetAmounts,
                 pool: pool,
                 useUnderlyings: useUnderlyings
@@ -1781,17 +1996,17 @@ function curveStake(_x5) {
 
 function _curveStake() {
   _curveStake = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee5(_ref6) {
-    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, incomingGaugeToken, amount, callArgs;
+    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, 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 = protocol.callOnIntegrationArgs({
               adapter: curveLiquidityAdapter,
               encodedCallArgs: protocol.curveStakeArgs({
                 amount: amount,
-                incomingGaugeToken: incomingGaugeToken,
+                incomingStakingToken: incomingStakingToken,
                 pool: pool
               }),
               selector: protocol.stakeSelector
@@ -1814,17 +2029,17 @@ function curveUnstake(_x6) {
 
 function _curveUnstake() {
   _curveUnstake = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee6(_ref7) {
-    var comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, outgoingGaugeToken, amount, callArgs;
+    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, 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 = protocol.callOnIntegrationArgs({
               adapter: curveLiquidityAdapter,
               encodedCallArgs: protocol.curveUnstakeArgs({
                 amount: amount,
-                outgoingGaugeToken: outgoingGaugeToken,
+                outgoingStakingToken: outgoingStakingToken,
                 pool: pool
               }),
               selector: protocol.unstakeSelector
@@ -1847,18 +2062,18 @@ function curveUnstakeAndRedeem(_x7) {
 
 function _curveUnstakeAndRedeem() {
   _curveUnstakeAndRedeem = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].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__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, 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 = protocol.callOnIntegrationArgs({
               adapter: curveLiquidityAdapter,
               encodedCallArgs: protocol.curveUnstakeAndRedeemArgs({
                 incomingAssetData: incomingAssetData,
-                outgoingGaugeToken: outgoingGaugeToken,
-                outgoingGaugeTokenAmount: outgoingGaugeTokenAmount,
+                outgoingStakingToken: outgoingStakingToken,
+                outgoingStakingTokenAmount: outgoingStakingTokenAmount,
                 pool: pool,
                 redeemType: redeemType,
                 useUnderlyings: useUnderlyings
@@ -2034,72 +2249,72 @@ function curveAaveUnstake(_ref15) {
     selector: protocol.unstakeSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.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 = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
+    adapter: curveLiquiditySethAdapter,
     encodedCallArgs: ethers.constants.HashZero,
     selector: protocol.claimRewardsSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.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 = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: protocol.curveEursLendArgs({
+    adapter: curveLiquiditySethAdapter,
+    encodedCallArgs: protocol.curveSethLendArgs({
       minIncomingLPTokenAmount: minIncomingLPTokenAmount,
-      outgoingEursAmount: outgoingEursAmount,
-      outgoingSeurAmount: outgoingSeurAmount
+      outgoingSethAmount: outgoingSethAmount,
+      outgoingWethAmount: outgoingWethAmount
     }),
     selector: protocol.lendSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.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 = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: protocol.curveEursLendAndStakeArgs({
+    adapter: curveLiquiditySethAdapter,
+    encodedCallArgs: protocol.curveSethLendAndStakeArgs({
       minIncomingLiquidityGaugeTokenAmount: minIncomingLiquidityGaugeTokenAmount,
-      outgoingEursAmount: outgoingEursAmount,
-      outgoingSeurAmount: outgoingSeurAmount
+      outgoingSethAmount: outgoingSethAmount,
+      outgoingWethAmount: outgoingWethAmount
     }),
     selector: protocol.lendAndStakeSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.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 = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: protocol.curveEursRedeemArgs({
-      minIncomingEursAmount: minIncomingEursAmount,
-      minIncomingSeurAmount: minIncomingSeurAmount,
+    adapter: curveLiquiditySethAdapter,
+    encodedCallArgs: protocol.curveSethRedeemArgs({
+      minIncomingSethAmount: minIncomingSethAmount,
+      minIncomingWethAmount: minIncomingWethAmount,
       outgoingLPTokenAmount: outgoingLPTokenAmount,
       receiveSingleAsset: receiveSingleAsset
     }),
@@ -2107,35 +2322,35 @@ function curveEursRedeem(_ref19) {
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.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 = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: protocol.curveEursStakeArgs({
+    adapter: curveLiquiditySethAdapter,
+    encodedCallArgs: protocol.curveSethStakeArgs({
       outgoingLPTokenAmount: outgoingLPTokenAmount
     }),
     selector: protocol.stakeSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.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 = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: protocol.curveEursUnstakeAndRedeemArgs({
-      minIncomingEursAmount: minIncomingEursAmount,
-      minIncomingSeurAmount: minIncomingSeurAmount,
+    adapter: curveLiquiditySethAdapter,
+    encodedCallArgs: protocol.curveSethUnstakeAndRedeemArgs({
+      minIncomingSethAmount: minIncomingSethAmount,
+      minIncomingWethAmount: minIncomingWethAmount,
       outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount,
       receiveSingleAsset: receiveSingleAsset
     }),
@@ -2143,85 +2358,85 @@ function curveEursUnstakeAndRedeem(_ref21) {
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.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 = protocol.callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    encodedCallArgs: protocol.curveEursUnstakeArgs({
+    adapter: curveLiquiditySethAdapter,
+    encodedCallArgs: protocol.curveSethUnstakeArgs({
       outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount
     }),
     selector: protocol.unstakeSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.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 = protocol.callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
+    adapter: curveLiquidityStethAdapter,
     encodedCallArgs: ethers.constants.HashZero,
     selector: protocol.claimRewardsSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.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 = protocol.callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: protocol.curveSethLendArgs({
+    adapter: curveLiquidityStethAdapter,
+    encodedCallArgs: protocol.curveStethLendArgs({
       minIncomingLPTokenAmount: minIncomingLPTokenAmount,
-      outgoingSethAmount: outgoingSethAmount,
+      outgoingStethAmount: outgoingStethAmount,
       outgoingWethAmount: outgoingWethAmount
     }),
     selector: protocol.lendSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.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 = protocol.callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: protocol.curveSethLendAndStakeArgs({
+    adapter: curveLiquidityStethAdapter,
+    encodedCallArgs: protocol.curveStethLendAndStakeArgs({
       minIncomingLiquidityGaugeTokenAmount: minIncomingLiquidityGaugeTokenAmount,
-      outgoingSethAmount: outgoingSethAmount,
+      outgoingStethAmount: outgoingStethAmount,
       outgoingWethAmount: outgoingWethAmount
     }),
     selector: protocol.lendAndStakeSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.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 = protocol.callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: protocol.curveSethRedeemArgs({
-      minIncomingSethAmount: minIncomingSethAmount,
+    adapter: curveLiquidityStethAdapter,
+    encodedCallArgs: protocol.curveStethRedeemArgs({
+      minIncomingStethAmount: minIncomingStethAmount,
       minIncomingWethAmount: minIncomingWethAmount,
       outgoingLPTokenAmount: outgoingLPTokenAmount,
       receiveSingleAsset: receiveSingleAsset
@@ -2230,34 +2445,34 @@ function curveSethRedeem(_ref26) {
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.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 = protocol.callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: protocol.curveSethStakeArgs({
+    adapter: curveLiquidityStethAdapter,
+    encodedCallArgs: protocol.curveStethStakeArgs({
       outgoingLPTokenAmount: outgoingLPTokenAmount
     }),
     selector: protocol.stakeSelector
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.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 = protocol.callOnIntegrationArgs({
-    adapter: curveLiquiditySethAdapter,
-    encodedCallArgs: protocol.curveSethUnstakeAndRedeemArgs({
-      minIncomingSethAmount: minIncomingSethAmount,
+    adapter: curveLiquidityStethAdapter,
+    encodedCallArgs: protocol.curveStethUnstakeAndRedeemArgs({
+      minIncomingStethAmount: minIncomingStethAmount,
       minIncomingWethAmount: minIncomingWethAmount,
       outgoingLiquidityGaugeTokenAmount: outgoingLiquidityGaugeTokenAmount,
       receiveSingleAsset: receiveSingleAsset
@@ -2266,135 +2481,12 @@ function curveSethUnstakeAndRedeem(_ref28) {
   });
   return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, protocol.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 = 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(_ref30) {
-  var comptrollerProxy = _ref30.comptrollerProxy,
-      integrationManager = _ref30.integrationManager,
-      fundOwner = _ref30.fundOwner,
-      curveLiquidityStethAdapter = _ref30.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 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 = 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 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 = 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 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 = 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 curveStethStake(_ref34) {
-  var comptrollerProxy = _ref34.comptrollerProxy,
-      integrationManager = _ref34.integrationManager,
-      fundOwner = _ref34.fundOwner,
-      curveLiquidityStethAdapter = _ref34.curveLiquidityStethAdapter,
-      outgoingLPTokenAmount = _ref34.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 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 = 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 curveStethUnstake(_ref36) {
-  var comptrollerProxy = _ref36.comptrollerProxy,
-      integrationManager = _ref36.integrationManager,
-      fundOwner = _ref36.fundOwner,
-      curveLiquidityStethAdapter = _ref36.curveLiquidityStethAdapter,
-      outgoingLiquidityGaugeTokenAmount = _ref36.outgoingLiquidityGaugeTokenAmount;
   var callArgs = protocol.callOnIntegrationArgs({
     adapter: curveLiquidityStethAdapter,
     encodedCallArgs: protocol.curveStethUnstakeArgs({
@@ -2866,24 +2958,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();
         }
@@ -2893,42 +2977,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
             });
@@ -2937,48 +2997,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,
@@ -2986,15 +3045,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);
 }
@@ -3978,17 +4037,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 */
 
@@ -4233,6 +4297,8 @@ 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;
@@ -4246,6 +4312,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;
@@ -4271,13 +4338,6 @@ exports.curveAaveStake = curveAaveStake;
 exports.curveAaveUnstake = curveAaveUnstake;
 exports.curveAaveUnstakeAndRedeem = curveAaveUnstakeAndRedeem;
 exports.curveClaimRewards = curveClaimRewards;
-exports.curveEursClaimRewards = curveEursClaimRewards;
-exports.curveEursLend = curveEursLend;
-exports.curveEursLendAndStake = curveEursLendAndStake;
-exports.curveEursRedeem = curveEursRedeem;
-exports.curveEursStake = curveEursStake;
-exports.curveEursUnstake = curveEursUnstake;
-exports.curveEursUnstakeAndRedeem = curveEursUnstakeAndRedeem;
 exports.curveLend = curveLend;
 exports.curveLendAndStake = curveLendAndStake;
 exports.curveRedeem = curveRedeem;
@@ -4340,7 +4400,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;