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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enzymefinance/testutils",
-  "version": "4.0.0-next.6",
+  "version": "4.0.0-next.7",
   "main": "dist/enzymefinance-testutils.cjs.js",
   "module": "dist/enzymefinance-testutils.esm.js",
   "browser": {
@@ -8,10 +8,10 @@
     "./dist/enzymefinance-testutils.esm.js": "./dist/enzymefinance-testutils.browser.esm.js"
   },
   "dependencies": {
-    "@babel/runtime": "^7.15.4",
-    "@enzymefinance/ethers": "^1.0.11",
-    "@enzymefinance/hardhat": "^1.0.12",
-    "@enzymefinance/protocol": "^4.0.0-next.6",
-    "ethers": "^5.5.3"
+    "@babel/runtime": "^7.16.7",
+    "@enzymefinance/ethers": "^1.0.16",
+    "@enzymefinance/hardhat": "^1.0.16",
+    "@enzymefinance/protocol": "^4.0.0-next.7",
+    "ethers": "^5.5.4"
   }
 }

package/src/deployment.ts

@@ -8,17 +8,18 @@ import {
   AllowedDepositRecipientsPolicy,
   AllowedExternalPositionTypesPolicy,
   AllowedSharesTransferRecipientsPolicy,
-  AssetFinalityResolver,
   CompoundAdapter,
   CompoundDebtPositionLib,
   CompoundDebtPositionParser,
   CompoundPriceFeed,
   ComptrollerLib,
+  ConvexCurveLpStakingAdapter,
+  ConvexCurveLpStakingWrapperFactory,
+  ConvexCurveLpStakingWrapperPriceFeed,
   CumulativeSlippageTolerancePolicy,
   CurveExchangeAdapter,
   CurveLiquidityAaveAdapter,
   CurveLiquidityAdapter,
-  CurveLiquidityEursAdapter,
   CurveLiquiditySethAdapter,
   CurveLiquidityStethAdapter,
   CurvePriceFeed,
@@ -35,8 +36,9 @@ import {
   FundValueCalculator,
   FundValueCalculatorRouter,
   FundValueCalculatorUsdWrapper,
+  FuseAdapter,
+  FusePriceFeed,
   GasRelayPaymasterFactory,
-  GuaranteedRedemptionPolicy,
   IdleAdapter,
   IdlePriceFeed,
   IntegrationManager,
@@ -58,7 +60,6 @@ import {
   RevertingPriceFeed,
   StakehoundEthPriceFeed,
   SynthetixAdapter,
-  SynthetixPriceFeed,
   UniswapV2ExchangeAdapter,
   UniswapV2LiquidityAdapter,
   UniswapV2PoolPriceFeed,
@@ -103,17 +104,18 @@ export async 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),
@@ -130,8 +132,9 @@ export async 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),
@@ -154,7 +157,6 @@ export async 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),
@@ -203,13 +205,16 @@ export interface DeploymentConfig {
   synthetix: {
     snx: string;
     susd: string;
-    synths: Record<string, string>;
-    addressResolver: string;
     delegateApprovals: string;
     originator: string;
     redeemer: string;
     trackingCode: string;
   };
+  convex: {
+    booster: string;
+    crvToken: string;
+    cvxToken: string;
+  };
   curve: {
     addressProvider: string;
     minter: string;
@@ -225,6 +230,10 @@ export interface DeploymentConfig {
     comptroller: string;
     ctokens: Record<string, string>;
   };
+  fuse: {
+    fetherTokens: Record<string, string>;
+    ftokens: Record<string, string>;
+  };
   idle: {
     bestYieldIdleDai: string;
     bestYieldIdleUsdc: string;
@@ -277,9 +286,4 @@ export interface DeploymentConfig {
     exchange: string;
     allowedMakers: string[];
   };
-  policies: {
-    guaranteedRedemption: {
-      redemptionWindowBuffer: number;
-    };
-  };
 }

package/src/scaffolding/core.ts

@@ -1,9 +1,4 @@
-import type {
-  AssetFinalityResolver,
-  Dispatcher,
-  GasRelayPaymasterFactory,
-  ValueInterpreter,
-} from '@enzymefinance/protocol';
+import type { Dispatcher, GasRelayPaymasterFactory, ValueInterpreter } from '@enzymefinance/protocol';
 import {
   ComptrollerLib,
   ExternalPositionManager,
@@ -20,7 +15,6 @@ import type { Signer } from 'ethers';
 // unless overrides are passed-in
 export async function createFundDeployer({
   deployer,
-  assetFinalityResolver,
   externalPositionManager,
   dispatcher,
   gasRelayPaymasterFactory,
@@ -30,7 +24,6 @@ export async function createFundDeployer({
   setReleaseLive = true,
 }: {
   deployer: Signer;
-  assetFinalityResolver: AssetFinalityResolver;
   externalPositionManager: ExternalPositionManager;
   dispatcher: Dispatcher;
   feeManager: FeeManager;
@@ -76,7 +69,6 @@ export async function createFundDeployer({
     nextFeeManager,
     nextIntegrationManager,
     nextPolicyManager,
-    assetFinalityResolver,
     gasRelayPaymasterFactory,
     mlnToken,
     wethToken,

package/src/scaffolding/extensions/external-positions/actions.ts

@@ -44,19 +44,24 @@ export async function createExternalPosition({
   externalPositionManager,
   externalPositionTypeId,
   initializationData = '0x',
+  callOnExternalPositionData = '0x',
 }: {
   signer: SignerWithAddress;
   comptrollerProxy: ComptrollerLib;
   externalPositionManager: ExternalPositionManager;
   externalPositionTypeId: BigNumberish;
   initializationData?: BytesLike;
+  callOnExternalPositionData?: BytesLike;
 }) {
   const receipt = await comptrollerProxy
     .connect(signer)
     .callOnExtension(
       externalPositionManager,
       ExternalPositionManagerActionId.CreateExternalPosition,
-      encodeArgs(['uint256', 'bytes'], [externalPositionTypeId, initializationData]),
+      encodeArgs(
+        ['uint256', 'bytes', 'bytes'],
+        [externalPositionTypeId, initializationData, callOnExternalPositionData],
+      ),
     );
 
   const event = extractEvent(receipt, externalPositionManager.abi.getEvent('ExternalPositionDeployedForFund'));

package/src/scaffolding/extensions/external-positions/mocks.ts

@@ -2,8 +2,6 @@ import type { AddressLike } from '@enzymefinance/ethers';
 import type { SignerWithAddress } from '@enzymefinance/hardhat';
 import type { ComptrollerLib, ExternalPositionFactory, ExternalPositionManager } from '@enzymefinance/protocol';
 import {
-  encodeArgs,
-  ExternalPositionManagerActionId,
   mockGenericExternalPositionActionArgs,
   MockGenericExternalPositionActionId,
   MockGenericExternalPositionLib,
@@ -12,7 +10,7 @@ import {
 } from '@enzymefinance/protocol';
 import type { BigNumberish } from 'ethers';
 
-import { callOnExternalPosition } from './actions';
+import { callOnExternalPosition, createExternalPosition } from './actions';
 
 export async function createMockExternalPosition({
   comptrollerProxy,
@@ -54,13 +52,12 @@ export async function createMockExternalPosition({
     [mockExternalPositionParser],
   );
 
-  const receipt = await comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(
-      externalPositionManager,
-      ExternalPositionManagerActionId.CreateExternalPosition,
-      encodeArgs(['uint256', 'bytes'], [typeId, '0x']),
-    );
+  const receipt = await createExternalPosition({
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: typeId,
+    signer: fundOwner,
+  });
 
   const externalPositionProxy = (await vaultProxy.getActiveExternalPositions())[0];
 

package/src/scaffolding/extensions/external-positions/uniswap-v3-liquidity.ts

@@ -4,20 +4,19 @@ import type { SignerWithAddress } from '@enzymefinance/hardhat';
 import type { ComptrollerLib, ExternalPositionManager } from '@enzymefinance/protocol';
 import {
   callOnExternalPositionArgs,
-  encodeArgs,
   ExternalPositionManagerActionId,
   ExternalPositionType,
   UniswapV3LiquidityPositionActionId,
   uniswapV3LiquidityPositionAddLiquidityArgs,
   uniswapV3LiquidityPositionCollectArgs,
-  uniswapV3LiquidityPositionInitArgs,
   UniswapV3LiquidityPositionLib,
   uniswapV3LiquidityPositionMintArgs,
   uniswapV3LiquidityPositionPurgeArgs,
   uniswapV3LiquidityPositionRemoveLiquidityArgs,
-  VaultLib,
 } from '@enzymefinance/protocol';
-import type { BigNumber, BigNumberish } from 'ethers';
+import type { BigNumber, BigNumberish, BytesLike } from 'ethers';
+
+import { createExternalPosition } from './actions';
 
 export enum UniswapV3FeeAmount {
   LOW = 500,
@@ -58,33 +57,22 @@ export async function createUniswapV3LiquidityPosition({
   signer,
   comptrollerProxy,
   externalPositionManager,
-  token0,
-  token1,
+  callOnExternalPositionData = '0x',
 }: {
   signer: SignerWithAddress;
   comptrollerProxy: ComptrollerLib;
   externalPositionManager: ExternalPositionManager;
-  token0: AddressLike;
-  token1: AddressLike;
+  callOnExternalPositionData?: BytesLike;
 }) {
-  const initArgs = uniswapV3LiquidityPositionInitArgs({
-    token0,
-    token1,
+  const { externalPositionProxy: externalPositionProxyContract, receipt } = await createExternalPosition({
+    callOnExternalPositionData,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: ExternalPositionType.UniswapV3LiquidityPosition,
+    signer,
   });
 
-  const receipt = await comptrollerProxy
-    .connect(signer)
-    .callOnExtension(
-      externalPositionManager,
-      ExternalPositionManagerActionId.CreateExternalPosition,
-      encodeArgs(['uint256', 'bytes'], [ExternalPositionType.UniswapV3LiquidityPosition, initArgs]),
-    );
-
-  const vaultProxy = new VaultLib(await comptrollerProxy.getVaultProxy(), signer);
-  const externalPositions = await vaultProxy.getActiveExternalPositions.call();
-  const externalPositionProxyAddress = externalPositions[externalPositions.length - 1];
-
-  return { externalPositionProxyAddress, receipt };
+  return { externalPositionProxyAddress: externalPositionProxyContract.address, receipt };
 }
 
 export async function uniswapV3LiquidityPositionAddLiquidity({
@@ -160,6 +148,8 @@ export async function uniswapV3LiquidityPositionMint({
   comptrollerProxy,
   externalPositionManager,
   externalPositionProxy,
+  token0,
+  token1,
   fee,
   tickLower,
   tickUpper,
@@ -172,6 +162,8 @@ export async function uniswapV3LiquidityPositionMint({
   comptrollerProxy: ComptrollerLib;
   externalPositionManager: ExternalPositionManager;
   externalPositionProxy: AddressLike;
+  token0: AddressLike;
+  token1: AddressLike;
   fee: BigNumberish;
   tickLower: BigNumberish;
   tickUpper: BigNumberish;
@@ -188,6 +180,8 @@ export async function uniswapV3LiquidityPositionMint({
     fee,
     tickLower,
     tickUpper,
+    token0,
+    token1,
   });
 
   const callArgs = callOnExternalPositionArgs({

package/src/scaffolding/extensions/integrations/compound.ts

@@ -1,16 +1,28 @@
 import type { AddressLike, Contract, Send } from '@enzymefinance/ethers';
 import { contract, resolveAddress } from '@enzymefinance/ethers';
 import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type { CompoundAdapter, ComptrollerLib, IntegrationManager, VaultLib } from '@enzymefinance/protocol';
+import type {
+  CompoundAdapter,
+  CompoundPriceFeed,
+  ComptrollerLib,
+  ICERC20,
+  IntegrationManager,
+  VaultLib,
+} from '@enzymefinance/protocol';
 import {
   callOnIntegrationArgs,
+  claimRewardsSelector,
   compoundArgs,
+  compoundClaimRewardsArgs,
   IntegrationManagerActionId,
   lendSelector,
   redeemSelector,
+  StandardToken,
 } from '@enzymefinance/protocol';
 import type { BigNumberish } from 'ethers';
-import { utils } from 'ethers';
+import { BigNumber, utils } from 'ethers';
+
+import { getAssetBalances } from '../../common';
 
 export interface ICompoundComptroller extends Contract<ICompoundComptroller> {
   claimComp: Send<(_account: AddressLike) => void>;
@@ -20,6 +32,155 @@ export const ICompoundComptroller = contract<ICompoundComptroller>()`
   function claimComp(address)
 `;
 
+export async function assertCompoundLend({
+  tokenWhale,
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  fundOwner,
+  compoundAdapter,
+  tokenAmount = utils.parseEther('1'),
+  cToken,
+  compoundPriceFeed,
+}: {
+  tokenWhale: SignerWithAddress;
+  comptrollerProxy: ComptrollerLib;
+  vaultProxy: VaultLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  compoundAdapter: CompoundAdapter;
+  tokenAmount?: BigNumber;
+  cToken: ICERC20;
+  compoundPriceFeed: CompoundPriceFeed;
+}) {
+  const token = new StandardToken(await compoundPriceFeed.getTokenFromCToken.args(cToken).call(), tokenWhale);
+  await token.connect(tokenWhale).transfer(vaultProxy, tokenAmount);
+  const rateBefore = await cToken.exchangeRateStored.call();
+
+  // Exchange rate stored can have a small deviation from exchangeRateStored
+  const minIncomingCTokenAmount = tokenAmount
+    .mul(utils.parseEther('1'))
+    .div(rateBefore)
+    .mul(BigNumber.from('999'))
+    .div(BigNumber.from('1000'));
+
+  const [preTxIncomingAssetBalance, preTxOutgoingAssetBalance] = await getAssetBalances({
+    account: vaultProxy,
+    assets: [cToken as any, token],
+  });
+
+  const lendReceipt = await compoundLend({
+    cToken,
+    cTokenAmount: minIncomingCTokenAmount,
+    compoundAdapter,
+    comptrollerProxy,
+    fundOwner,
+    integrationManager,
+    tokenAmount,
+  });
+
+  // Get exchange rate after tx (the rate is updated right after)
+  const rate = await cToken.exchangeRateStored();
+  const [postTxIncomingAssetBalance, postTxOutgoingAssetBalance] = await getAssetBalances({
+    account: vaultProxy,
+    assets: [cToken as any, token],
+  });
+
+  const expectedCTokenAmount = tokenAmount.mul(utils.parseEther('1')).div(rate);
+  expect(postTxIncomingAssetBalance).toEqBigNumber(preTxIncomingAssetBalance.add(expectedCTokenAmount));
+  expect(postTxOutgoingAssetBalance).toEqBigNumber(preTxOutgoingAssetBalance.sub(tokenAmount));
+
+  return lendReceipt;
+}
+
+export async function assertCompoundRedeem({
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  fundOwner,
+  compoundAdapter,
+  cToken,
+  compoundPriceFeed,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  vaultProxy: VaultLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  compoundAdapter: CompoundAdapter;
+  cToken: ICERC20;
+  compoundPriceFeed: CompoundPriceFeed;
+}) {
+  const cTokenAmount = utils.parseUnits('1', await cToken.decimals());
+  await cToken.transfer(vaultProxy, cTokenAmount);
+
+  const token = new StandardToken(await compoundPriceFeed.getTokenFromCToken.args(cToken).call(), provider);
+  const [preTxIncomingAssetBalance, preTxOutgoingAssetBalance] = await getAssetBalances({
+    account: vaultProxy,
+    assets: [token, cToken as any],
+  });
+
+  const rateBefore = await cToken.exchangeRateStored();
+  const minIncomingTokenAmount = cTokenAmount.mul(rateBefore).div(utils.parseEther('1'));
+
+  const redeemReceipt = await compoundRedeem({
+    cToken,
+    cTokenAmount,
+    compoundAdapter,
+    comptrollerProxy,
+    fundOwner,
+    integrationManager,
+    tokenAmount: minIncomingTokenAmount,
+    vaultProxy,
+  });
+
+  const [postTxIncomingAssetBalance, postTxOutgoingAssetBalance] = await getAssetBalances({
+    account: vaultProxy,
+    assets: [token, cToken as any],
+  });
+
+  // Get exchange rate after tx (the rate is updated right after)
+  const rate = await cToken.exchangeRateStored();
+  const expectedTokenAmount = cTokenAmount.mul(rate).div(utils.parseEther('1'));
+
+  expect(postTxIncomingAssetBalance).toEqBigNumber(preTxIncomingAssetBalance.add(expectedTokenAmount));
+  expect(postTxOutgoingAssetBalance).toEqBigNumber(preTxOutgoingAssetBalance.sub(cTokenAmount));
+
+  return redeemReceipt;
+}
+
+export async function compoundClaim({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  compoundAdapter,
+  compoundComptroller,
+  cTokens,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  compoundAdapter: CompoundAdapter;
+  compoundComptroller: AddressLike;
+  cTokens: AddressLike[];
+}) {
+  const claimArgs = compoundClaimRewardsArgs({
+    cTokens,
+    compoundComptroller,
+  });
+
+  const callArgs = callOnIntegrationArgs({
+    adapter: compoundAdapter,
+    encodedCallArgs: claimArgs,
+    selector: claimRewardsSelector,
+  });
+
+  const claimRewardsTx = comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+  return claimRewardsTx;
+}
+
 export async function compoundLend({
   comptrollerProxy,
   integrationManager,