@enzymefinance/testutils 3.0.0

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@enzymefinance/testutils",
+  "version": "3.0.0",
+  "main": "dist/enzymefinance-testutils.cjs.js",
+  "module": "dist/enzymefinance-testutils.esm.js",
+  "browser": {
+    "./dist/enzymefinance-testutils.cjs.js": "./dist/enzymefinance-testutils.browser.cjs.js",
+    "./dist/enzymefinance-testutils.esm.js": "./dist/enzymefinance-testutils.browser.esm.js"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.15.4",
+    "@enzymefinance/ethers": "^1.0.0",
+    "@enzymefinance/hardhat": "^1.0.0",
+    "@enzymefinance/protocol": "^3.0.0",
+    "ethers": "^5.4.6",
+    "ethers-eip712": "^0.2.0"
+  }
+}

package/src/assertions.ts

@@ -0,0 +1,20 @@
+import { ContractReceipt, extractEvent } from '@enzymefinance/ethers';
+import { utils } from 'ethers';
+
+export function assertEvent<TResult = any>(
+  receipt: ContractReceipt<any>,
+  event: string | utils.EventFragment,
+  match?: TResult,
+) {
+  const events = extractEvent(receipt, event);
+  expect(events.length).toBe(1);
+  expect(receipt).toHaveEmittedWith(event, match);
+
+  const args = events.shift()?.args;
+  return (args as unknown as typeof match)!;
+}
+
+export function assertNoEvent(receipt: ContractReceipt<any>, event: string | utils.EventFragment) {
+  const events = extractEvent(receipt, event);
+  expect(events.length).toBe(0);
+}

package/src/deployment.ts

@@ -0,0 +1,169 @@
+import { Contract } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import {
+  Dispatcher,
+  VaultLib,
+  FundDeployer,
+  PolicyManager,
+  AavePriceFeed,
+  AlphaHomoraV1PriceFeed,
+  ChainlinkPriceFeed,
+  CompoundPriceFeed,
+  CurvePriceFeed,
+  IdlePriceFeed,
+  LidoStethPriceFeed,
+  RevertingPriceFeed,
+  StakehoundEthPriceFeed,
+  SynthetixPriceFeed,
+  WdgldPriceFeed,
+  YearnVaultV2PriceFeed,
+  AggregatedDerivativePriceFeed,
+  ValueInterpreter,
+  UniswapV2PoolPriceFeed,
+  IntegrationManager,
+  AaveAdapter,
+  AlphaHomoraV1Adapter,
+  CurveLiquidityAaveAdapter,
+  CurveLiquidityEursAdapter,
+  CurveLiquiditySethAdapter,
+  CurveLiquidityStethAdapter,
+  IdleAdapter,
+  ParaSwapV4Adapter,
+  SynthetixAdapter,
+  YearnVaultV2Adapter,
+  ZeroExV2Adapter,
+  CompoundAdapter,
+  UniswapV2Adapter,
+  TrackedAssetsAdapter,
+  UniswapV3Adapter,
+  CurveExchangeAdapter,
+  KyberAdapter,
+  FeeManager,
+  ComptrollerLib,
+  EntranceRateBurnFee,
+  EntranceRateDirectFee,
+  ManagementFee,
+  PerformanceFee,
+  AuthUserExecutedSharesRequestorLib,
+  AuthUserExecutedSharesRequestorFactory,
+  FundActionsWrapper,
+  AdapterBlacklist,
+  AdapterWhitelist,
+  AssetBlacklist,
+  AssetWhitelist,
+  BuySharesCallerWhitelist,
+  MaxConcentration,
+  MinMaxInvestment,
+  InvestorWhitelist,
+  GuaranteedRedemption,
+} from '@enzymefinance/protocol';
+
+import { DeploymentConfig } from '../../../deploy/utils/config';
+
+export async function getNamedSigner(name: string) {
+  const accounts = await hre.getNamedAccounts();
+  if (!accounts[name]) {
+    throw new Error(`Missing account with name ${name}`);
+  }
+
+  return provider.getSignerWithAddress(accounts[name]);
+}
+
+export async function getUnnamedSigners() {
+  const accounts = await hre.getUnnamedAccounts();
+  return Promise.all(accounts.map((account) => provider.getSignerWithAddress(account)));
+}
+
+export async function deployProtocolFixture() {
+  const fixture = await hre.deployments.fixture();
+  const deployer = await getNamedSigner('deployer');
+  const accounts = await getUnnamedSigners();
+  const config = fixture['Config'].linkedData as DeploymentConfig;
+
+  // prettier-ignore
+  const deployment = {
+    dispatcher: new Dispatcher(fixture['Dispatcher'].address, deployer),
+    vaultLib: new VaultLib(fixture['VaultLib'].address, deployer),
+    fundDeployer: new FundDeployer(fixture['FundDeployer'].address, deployer),
+    policyManager: new PolicyManager(fixture['PolicyManager'].address, deployer),
+    aavePriceFeed: new AavePriceFeed(fixture['AavePriceFeed'].address, deployer),
+    alphaHomoraV1PriceFeed: new AlphaHomoraV1PriceFeed(fixture['AlphaHomoraV1PriceFeed'].address, deployer),
+    chainlinkPriceFeed: new ChainlinkPriceFeed(fixture['ChainlinkPriceFeed'].address, deployer),
+    compoundPriceFeed: new CompoundPriceFeed(fixture['CompoundPriceFeed'].address, deployer),
+    curvePriceFeed: new CurvePriceFeed(fixture['CurvePriceFeed'].address, deployer),
+    idlePriceFeed: new IdlePriceFeed(fixture['IdlePriceFeed'].address, deployer),
+    lidoStethPriceFeed: new LidoStethPriceFeed(fixture['LidoStethPriceFeed'].address, deployer),
+    revertingPriceFeed: new RevertingPriceFeed(fixture['RevertingPriceFeed'].address, deployer),
+    synthetixPriceFeed: new SynthetixPriceFeed(fixture['SynthetixPriceFeed'].address, deployer),
+    stakehoundEthPriceFeed: new StakehoundEthPriceFeed(fixture['StakehoundEthPriceFeed'].address, deployer),
+    wdgldPriceFeed: new WdgldPriceFeed(fixture['WdgldPriceFeed'].address, deployer),
+    yearnVaultV2PriceFeed: new YearnVaultV2PriceFeed(fixture['YearnVaultV2PriceFeed'].address, deployer),
+    aggregatedDerivativePriceFeed: new AggregatedDerivativePriceFeed(fixture['AggregatedDerivativePriceFeed'].address, deployer),
+    valueInterpreter: new ValueInterpreter(fixture['ValueInterpreter'].address, deployer),
+    uniswapV2PoolPriceFeed: new UniswapV2PoolPriceFeed(fixture['UniswapV2PoolPriceFeed'].address, deployer),
+    integrationManager: new IntegrationManager(fixture['IntegrationManager'].address, deployer),
+    curveLiquidityAaveAdapter: new CurveLiquidityAaveAdapter(fixture['CurveLiquidityAaveAdapter'].address, deployer),
+    curveLiquidityEursAdapter: new CurveLiquidityEursAdapter(fixture['CurveLiquidityEursAdapter'].address, deployer),
+    curveLiquiditySethAdapter: new CurveLiquiditySethAdapter(fixture['CurveLiquiditySethAdapter'].address, deployer),
+    curveLiquidityStethAdapter: new CurveLiquidityStethAdapter(fixture['CurveLiquidityStethAdapter'].address, deployer),
+    aaveAdapter: new AaveAdapter(fixture['AaveAdapter'].address, deployer),
+    alphaHomoraV1Adapter: new AlphaHomoraV1Adapter(fixture['AlphaHomoraV1Adapter'].address, deployer),
+    idleAdapter: new IdleAdapter(fixture['IdleAdapter'].address, deployer),
+    paraSwapV4Adapter: new ParaSwapV4Adapter(fixture['ParaSwapV4Adapter'].address, deployer),
+    synthetixAdapter: new SynthetixAdapter(fixture['SynthetixAdapter'].address, deployer),
+    yearnVaultV2Adapter: new YearnVaultV2Adapter(fixture['YearnVaultV2Adapter'].address, deployer),
+    zeroExV2Adapter: new ZeroExV2Adapter(fixture['ZeroExV2Adapter'].address, deployer),
+    compoundAdapter: new CompoundAdapter(fixture['CompoundAdapter'].address, deployer),
+    uniswapV2Adapter: new UniswapV2Adapter(fixture['UniswapV2Adapter'].address, deployer),
+    trackedAssetsAdapter: new TrackedAssetsAdapter(fixture['TrackedAssetsAdapter'].address, deployer),
+    uniswapV3Adapter: new UniswapV3Adapter(fixture['UniswapV3Adapter'].address, deployer),
+    curveExchangeAdapter: new CurveExchangeAdapter(fixture['CurveExchangeAdapter'].address, deployer),
+    kyberAdapter: new KyberAdapter(fixture['KyberAdapter'].address, deployer),
+    feeManager: new FeeManager(fixture['FeeManager'].address, deployer),
+    comptrollerLib: new ComptrollerLib(fixture['ComptrollerLib'].address, deployer),
+    entranceRateBurnFee: new EntranceRateBurnFee(fixture['EntranceRateBurnFee'].address, deployer),
+    entranceRateDirectFee: new EntranceRateDirectFee(fixture['EntranceRateDirectFee'].address, deployer),
+    managementFee: new ManagementFee(fixture['ManagementFee'].address, deployer),
+    performanceFee: new PerformanceFee(fixture['PerformanceFee'].address, deployer),
+    authUserExecutedSharesRequestorLib: new AuthUserExecutedSharesRequestorLib(fixture['AuthUserExecutedSharesRequestorLib'].address, deployer),
+    authUserExecutedSharesRequestorFactory: new AuthUserExecutedSharesRequestorFactory(fixture['AuthUserExecutedSharesRequestorFactory'].address, deployer),
+    fundActionsWrapper: new FundActionsWrapper(fixture['FundActionsWrapper'].address, deployer),
+    adapterBlacklist: new AdapterBlacklist(fixture['AdapterBlacklist'].address, deployer),
+    adapterWhitelist: new AdapterWhitelist(fixture['AdapterWhitelist'].address, deployer),
+    assetBlacklist: new AssetBlacklist(fixture['AssetBlacklist'].address, deployer),
+    assetWhitelist: new AssetWhitelist(fixture['AssetWhitelist'].address, deployer),
+    buySharesCallerWhitelist: new BuySharesCallerWhitelist(fixture['BuySharesCallerWhitelist'].address, deployer),
+    maxConcentration: new MaxConcentration(fixture['MaxConcentration'].address, deployer),
+    minMaxInvestment: new MinMaxInvestment(fixture['MinMaxInvestment'].address, deployer),
+    investorWhitelist: new InvestorWhitelist(fixture['InvestorWhitelist'].address, deployer),
+    guaranteedRedemption: new GuaranteedRedemption(fixture['GuaranteedRedemption'].address, deployer),
+  } as const;
+
+  return {
+    deployer,
+    deployment,
+    accounts,
+    config,
+  } as const;
+}
+
+type Resolve<T extends () => any> = ReturnType<T> extends Promise<infer U> ? U : ReturnType<T>;
+type ContractMap = Record<string, Contract>;
+
+export interface DeploymentFixtureWithoutConfig<T extends ContractMap> {
+  deployer: SignerWithAddress;
+  deployment: T;
+  accounts: SignerWithAddress[];
+}
+
+export interface DeploymentFixtureWithConfig<T extends ContractMap> extends DeploymentFixtureWithoutConfig<T> {
+  config: DeploymentConfig;
+}
+
+export type ProtocolDeployment = Resolve<typeof deployProtocolFixture>;
+
+// TODO: Remove this.
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export async function defaultTestDeployment(_: any): Promise<any> {
+  throw new Error('Removed');
+}

package/src/helpers.ts

@@ -0,0 +1,6 @@
+import { ContractReceipt } from '@enzymefinance/ethers';
+
+export async function transactionTimestamp(receipt: ContractReceipt<any>) {
+  const block = await provider.getBlock(receipt.blockNumber);
+  return block.timestamp;
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './deployment';
+export * from './scaffolding';
+export * from './assertions';
+export * from './helpers';
+export * from './whales';

package/src/scaffolding/assets.ts

@@ -0,0 +1,39 @@
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import {
+  ComptrollerLib,
+  IntegrationManager,
+  StandardToken,
+  TrackedAssetsAdapter,
+  VaultLib,
+} from '@enzymefinance/protocol';
+import { BigNumberish } from 'ethers';
+import { addTrackedAssets } from './extensions/integrations/trackedAssets';
+
+export async function addNewAssetsToFund({
+  fundOwner,
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  trackedAssetsAdapter,
+  assets,
+  amounts = new Array(assets.length).fill(1),
+}: {
+  fundOwner: SignerWithAddress;
+  comptrollerProxy: ComptrollerLib;
+  vaultProxy: VaultLib;
+  integrationManager: IntegrationManager;
+  trackedAssetsAdapter: TrackedAssetsAdapter;
+  assets: StandardToken[];
+  amounts?: BigNumberish[];
+}) {
+  for (const i in assets) {
+    await assets[i].transfer(vaultProxy, amounts[i]);
+  }
+  return addTrackedAssets({
+    comptrollerProxy,
+    integrationManager,
+    fundOwner,
+    trackedAssetsAdapter,
+    incomingAssets: assets,
+  });
+}

package/src/scaffolding/chainlink.ts

@@ -0,0 +1,8 @@
+import { BigNumberish } from 'ethers';
+import { MockChainlinkPriceSource } from '@enzymefinance/protocol';
+
+export async function updateChainlinkAggregator(aggregator: MockChainlinkPriceSource, price?: BigNumberish) {
+  const answer = price ?? (await aggregator.latestAnswer());
+  const block = await aggregator.provider.getBlock('latest');
+  await aggregator.setLatestAnswer(answer, block.timestamp);
+}

package/src/scaffolding/common.ts

@@ -0,0 +1,6 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { StandardToken } from '@enzymefinance/protocol';
+
+export async function getAssetBalances({ account, assets }: { account: AddressLike; assets: StandardToken[] }) {
+  return Promise.all(assets.map((asset) => asset.balanceOf(account)));
+}

package/src/scaffolding/core.ts

@@ -0,0 +1,77 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import {
+  ChainlinkPriceFeed,
+  ComptrollerLib,
+  Dispatcher,
+  FeeManager,
+  FundDeployer,
+  IntegrationManager,
+  PolicyManager,
+  ReleaseStatusTypes,
+  SynthetixPriceFeed,
+  ValueInterpreter,
+  VaultLib,
+} from '@enzymefinance/protocol';
+import { BytesLike, Signer } from 'ethers';
+
+export async function createFundDeployer({
+  deployer,
+  chainlinkPriceFeed,
+  dispatcher,
+  feeManager,
+  integrationManager,
+  policyManager,
+  synthetixAddressResolverAddress,
+  synthetixPriceFeed,
+  valueInterpreter,
+  vaultLib,
+  vaultCallContracts = [],
+  vaultCallSelectors = [],
+  setOnDispatcher = true,
+  setReleaseStatusLive = true,
+}: {
+  deployer: Signer;
+  chainlinkPriceFeed: ChainlinkPriceFeed;
+  dispatcher: Dispatcher;
+  feeManager: FeeManager;
+  integrationManager: IntegrationManager;
+  policyManager: PolicyManager;
+  synthetixAddressResolverAddress: AddressLike;
+  synthetixPriceFeed: SynthetixPriceFeed;
+  valueInterpreter: ValueInterpreter;
+  vaultLib: VaultLib;
+  vaultCallContracts?: AddressLike[];
+  vaultCallSelectors?: BytesLike[];
+  setOnDispatcher?: boolean;
+  setReleaseStatusLive?: boolean;
+}) {
+  const nextFundDeployer = await FundDeployer.deploy(
+    deployer,
+    dispatcher,
+    vaultLib,
+    vaultCallContracts,
+    vaultCallSelectors,
+  );
+  const nextComptrollerLib = await ComptrollerLib.deploy(
+    deployer,
+    dispatcher,
+    nextFundDeployer,
+    valueInterpreter,
+    feeManager,
+    integrationManager,
+    policyManager,
+    chainlinkPriceFeed,
+    synthetixPriceFeed,
+    synthetixAddressResolverAddress,
+  );
+  await nextFundDeployer.setComptrollerLib(nextComptrollerLib);
+
+  if (setReleaseStatusLive) {
+    await nextFundDeployer.setReleaseStatus(ReleaseStatusTypes.Live);
+  }
+  if (setOnDispatcher) {
+    await dispatcher.setCurrentFundDeployer(nextFundDeployer);
+  }
+
+  return nextFundDeployer;
+}

package/src/scaffolding/extensions/common.ts

@@ -0,0 +1,30 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib } from '@enzymefinance/protocol';
+import { BigNumberish, BytesLike } from 'ethers';
+
+export async function callOnExtension({
+  comptrollerProxy,
+  extension,
+  actionId,
+  callArgs = '0x',
+  signer,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  extension: AddressLike;
+  actionId: BigNumberish;
+  callArgs?: BytesLike;
+  signer?: SignerWithAddress;
+}) {
+  let callOnExtensionTx: any;
+
+  if (signer) {
+    callOnExtensionTx = comptrollerProxy.connect(signer).callOnExtension(extension, actionId, callArgs);
+  } else {
+    callOnExtensionTx = comptrollerProxy.callOnExtension(extension, actionId, callArgs);
+  }
+
+  await expect(callOnExtensionTx).resolves.toBeReceipt();
+
+  return callOnExtensionTx;
+}

package/src/scaffolding/extensions/fees.ts

@@ -0,0 +1,87 @@
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { FeeHook, FeeManager, feeManagerConfigArgs, FeeSettlementType, IFee } from '@enzymefinance/protocol';
+import { constants, utils } from 'ethers';
+
+export async function generateFeeManagerConfigWithMockFees({
+  deployer,
+  feeManager,
+}: {
+  deployer: SignerWithAddress;
+  feeManager: FeeManager;
+}) {
+  const fees = await generateRegisteredMockFees({
+    deployer,
+    feeManager,
+  });
+
+  const feeManagerSettingsData = [utils.randomBytes(10), '0x', utils.randomBytes(2)];
+
+  return feeManagerConfigArgs({
+    fees: Object.values(fees),
+    settings: feeManagerSettingsData,
+  });
+}
+
+export async function generateRegisteredMockFees({
+  deployer,
+  feeManager,
+}: {
+  deployer: SignerWithAddress;
+  feeManager: FeeManager;
+}) {
+  // Create mock fees
+  const mockContinuousFeeSettleOnly = await IFee.mock(deployer);
+  const mockContinuousFeeWithGavAndUpdates = await IFee.mock(deployer);
+  const mockPostBuySharesFee = await IFee.mock(deployer);
+
+  // Initialize mock fee return values
+  await Promise.all([
+    // Continuous fee the mimics ManagementFee
+    mockContinuousFeeSettleOnly.identifier.returns(`MOCK_CONTINUOUS_1`),
+    mockContinuousFeeSettleOnly.settle.returns(FeeSettlementType.None, constants.AddressZero, 0),
+    mockContinuousFeeSettleOnly.payout.returns(false),
+    mockContinuousFeeSettleOnly.addFundSettings.returns(undefined),
+    mockContinuousFeeSettleOnly.activateForFund.returns(undefined),
+    mockContinuousFeeSettleOnly.update.returns(undefined),
+    mockContinuousFeeSettleOnly.implementedHooks.returns(
+      [FeeHook.Continuous, FeeHook.PreBuyShares, FeeHook.PreRedeemShares],
+      [],
+      false,
+      false,
+    ),
+    // Continuous fee the mimics PerformanceFee
+    mockContinuousFeeWithGavAndUpdates.identifier.returns(`MOCK_CONTINUOUS_2`),
+    mockContinuousFeeWithGavAndUpdates.settle.returns(FeeSettlementType.None, constants.AddressZero, 0),
+    mockContinuousFeeWithGavAndUpdates.payout.returns(false),
+    mockContinuousFeeWithGavAndUpdates.addFundSettings.returns(undefined),
+    mockContinuousFeeWithGavAndUpdates.activateForFund.returns(undefined),
+    mockContinuousFeeWithGavAndUpdates.update.returns(undefined),
+    mockContinuousFeeWithGavAndUpdates.implementedHooks.returns(
+      [FeeHook.Continuous, FeeHook.PreBuyShares, FeeHook.PreRedeemShares],
+      [FeeHook.Continuous, FeeHook.PostBuyShares, FeeHook.PreRedeemShares],
+      true,
+      true,
+    ),
+    // PostBuyShares fee
+    mockPostBuySharesFee.identifier.returns(`MOCK_POST_BUY_SHARES`),
+    mockPostBuySharesFee.settle.returns(FeeSettlementType.None, constants.AddressZero, 0),
+    mockPostBuySharesFee.payout.returns(false),
+    mockPostBuySharesFee.addFundSettings.returns(undefined),
+    mockPostBuySharesFee.activateForFund.returns(undefined),
+    mockPostBuySharesFee.update.returns(undefined),
+    mockPostBuySharesFee.implementedHooks.returns([FeeHook.PostBuyShares], [], false, false),
+  ]);
+
+  // Register all mock fees
+  await feeManager.registerFees([
+    mockContinuousFeeSettleOnly,
+    mockContinuousFeeWithGavAndUpdates,
+    mockPostBuySharesFee,
+  ]);
+
+  return {
+    mockContinuousFeeSettleOnly,
+    mockContinuousFeeWithGavAndUpdates,
+    mockPostBuySharesFee,
+  };
+}