@enzymefinance/testutils 3.0.0

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

@@ -0,0 +1,45 @@
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import {
+  ComptrollerLib,
+  IntegrationManager,
+  ZeroExV2Adapter,
+  VaultLib,
+  SignedZeroExV2Order,
+  callOnIntegrationArgs,
+  takeOrderSelector,
+  zeroExV2TakeOrderArgs,
+  IntegrationManagerActionId,
+} from '@enzymefinance/protocol';
+import { BigNumberish } from 'ethers';
+
+export async function zeroExV2TakeOrder({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  zeroExV2Adapter,
+  signedOrder,
+  takerAssetFillAmount,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  vaultProxy: VaultLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  zeroExV2Adapter: ZeroExV2Adapter;
+  signedOrder: SignedZeroExV2Order;
+  takerAssetFillAmount: BigNumberish;
+}) {
+  const takeOrderArgs = zeroExV2TakeOrderArgs({
+    signedOrder,
+    takerAssetFillAmount,
+  });
+
+  const callArgs = callOnIntegrationArgs({
+    adapter: zeroExV2Adapter,
+    selector: takeOrderSelector,
+    encodedCallArgs: takeOrderArgs,
+  });
+
+  return comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+}

package/src/scaffolding/extensions/policies.ts

@@ -0,0 +1,85 @@
+import { IPolicy, PolicyHook, PolicyManager, policyManagerConfigArgs } from '@enzymefinance/protocol';
+import { constants, Signer, utils } from 'ethers';
+
+// Policy Manager
+
+export async function generatePolicyManagerConfigWithMockPolicies({
+  deployer,
+  policyManager,
+}: {
+  deployer: Signer;
+  policyManager: PolicyManager;
+}) {
+  const policies = await generateRegisteredMockPolicies({
+    deployer,
+    policyManager,
+  });
+
+  const policiesSettingsData = [utils.randomBytes(10), constants.HashZero, constants.HashZero, utils.randomBytes(2)];
+
+  return policyManagerConfigArgs({
+    policies: Object.values(policies),
+    settings: policiesSettingsData,
+  });
+}
+
+export async function generateRegisteredMockPolicies({
+  deployer,
+  policyManager,
+}: {
+  deployer: Signer;
+  policyManager: PolicyManager;
+}) {
+  // Create mock policies
+  const mockPreBuySharesPolicy = await IPolicy.mock(deployer);
+  const mockPostBuySharesPolicy = await IPolicy.mock(deployer);
+  const mockPreCoIPolicy = await IPolicy.mock(deployer);
+  const mockPostCoIPolicy = await IPolicy.mock(deployer);
+
+  // Initialize mock policy return values
+  await Promise.all([
+    // PreBuyShares
+    mockPreBuySharesPolicy.identifier.returns(`MOCK_PRE_BUY_SHARES`),
+    mockPreBuySharesPolicy.addFundSettings.returns(undefined),
+    mockPreBuySharesPolicy.activateForFund.returns(undefined),
+    mockPreBuySharesPolicy.validateRule.returns(true),
+    mockPreBuySharesPolicy.implementedHooks.returns([PolicyHook.PreBuyShares]),
+    mockPreBuySharesPolicy.updateFundSettings.returns(undefined),
+    // PostBuyShares
+    mockPostBuySharesPolicy.identifier.returns(`MOCK_POST_BUY_SHARES`),
+    mockPostBuySharesPolicy.addFundSettings.returns(undefined),
+    mockPostBuySharesPolicy.activateForFund.returns(undefined),
+    mockPostBuySharesPolicy.validateRule.returns(true),
+    mockPostBuySharesPolicy.implementedHooks.returns([PolicyHook.PostBuyShares]),
+    mockPostBuySharesPolicy.updateFundSettings.returns(undefined),
+    // PreCallOnIntegration
+    mockPreCoIPolicy.identifier.returns(`MOCK_PRE_CALL_ON_INTEGRATION`),
+    mockPreCoIPolicy.addFundSettings.returns(undefined),
+    mockPreCoIPolicy.activateForFund.returns(undefined),
+    mockPreCoIPolicy.validateRule.returns(true),
+    mockPreCoIPolicy.implementedHooks.returns([PolicyHook.PreCallOnIntegration]),
+    mockPreCoIPolicy.updateFundSettings.returns(undefined),
+    // PostCallOnIntegration
+    mockPostCoIPolicy.identifier.returns(`MOCK_POST_CALL_ON_INTEGRATION`),
+    mockPostCoIPolicy.addFundSettings.returns(undefined),
+    mockPostCoIPolicy.activateForFund.returns(undefined),
+    mockPostCoIPolicy.validateRule.returns(true),
+    mockPostCoIPolicy.implementedHooks.returns([PolicyHook.PostCallOnIntegration]),
+    mockPostCoIPolicy.updateFundSettings.returns(undefined),
+  ]);
+
+  // Register all mock policies
+  await policyManager.registerPolicies([
+    mockPreBuySharesPolicy,
+    mockPostBuySharesPolicy,
+    mockPreCoIPolicy,
+    mockPostCoIPolicy,
+  ]);
+
+  return {
+    mockPreBuySharesPolicy,
+    mockPostBuySharesPolicy,
+    mockPreCoIPolicy,
+    mockPostCoIPolicy,
+  };
+}

package/src/scaffolding/index.ts

@@ -0,0 +1,9 @@
+export * from './assets';
+export * from './chainlink';
+export * from './common';
+export * from './core';
+export * from './extensions';
+export * from './peripheral';
+export * from './setup';
+export * from './shares';
+export * from './vaultCalls';

package/src/scaffolding/peripheral/index.ts

@@ -0,0 +1 @@
+export * from './sharesRequestors';

package/src/scaffolding/peripheral/sharesRequestors.ts

@@ -0,0 +1,53 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import {
+  AuthUserExecutedSharesRequestorFactory,
+  AuthUserExecutedSharesRequestorLib,
+  StandardToken,
+} from '@enzymefinance/protocol';
+import { BigNumberish, utils } from 'ethers';
+import { assertEvent } from '../../assertions';
+
+export async function createAuthUserExecutedSharesRequestorProxy({
+  signer,
+  authUserExecutedSharesRequestorFactory,
+  comptrollerProxy,
+}: {
+  signer: SignerWithAddress;
+  authUserExecutedSharesRequestorFactory: AuthUserExecutedSharesRequestorFactory;
+  comptrollerProxy: AddressLike;
+}) {
+  const receipt = await authUserExecutedSharesRequestorFactory
+    .connect(signer)
+    .deploySharesRequestorProxy(comptrollerProxy);
+
+  const sharesRequestorProxyDeployedArgs = assertEvent(receipt, 'SharesRequestorProxyDeployed', {
+    comptrollerProxy,
+    sharesRequestorProxy: expect.any(String) as string,
+  });
+
+  return {
+    authUserExecutedSharesRequestorProxy: new AuthUserExecutedSharesRequestorLib(
+      sharesRequestorProxyDeployedArgs.sharesRequestorProxy,
+      signer,
+    ),
+    receipt,
+  };
+}
+
+export async function createAuthUserExecutedSharesRequest({
+  buyer,
+  authUserExecutedSharesRequestorProxy,
+  denominationAsset,
+  investmentAmount = utils.parseEther('1'),
+  minSharesQuantity = investmentAmount,
+}: {
+  buyer: SignerWithAddress;
+  authUserExecutedSharesRequestorProxy: AuthUserExecutedSharesRequestorLib;
+  denominationAsset: StandardToken;
+  investmentAmount?: BigNumberish;
+  minSharesQuantity?: BigNumberish;
+}) {
+  await denominationAsset.connect(buyer).approve(authUserExecutedSharesRequestorProxy, investmentAmount);
+  return authUserExecutedSharesRequestorProxy.connect(buyer).createRequest(investmentAmount, minSharesQuantity);
+}

package/src/scaffolding/setup.ts

@@ -0,0 +1,135 @@
+import { AddressLike, randomAddress } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib, ComptrollerProxy, encodeFunctionData, FundDeployer, VaultLib } from '@enzymefinance/protocol';
+import { BigNumber, BigNumberish, BytesLike, utils } from 'ethers';
+import { assertEvent } from '../assertions';
+import { buyShares, BuySharesParams, DenominationAssetInterface } from './shares';
+
+export type InitialInvestmentParams = Omit<BuySharesParams, 'comptrollerProxy' | 'denominationAsset'>;
+
+export interface CreateMigratedFundConfigParams {
+  signer: SignerWithAddress;
+  fundDeployer: FundDeployer;
+  denominationAsset: DenominationAssetInterface;
+  sharesActionTimelock?: BigNumberish;
+  feeManagerConfigData?: BytesLike;
+  policyManagerConfigData?: BytesLike;
+}
+
+export interface CreateNewFundParams {
+  signer: SignerWithAddress;
+  fundDeployer: FundDeployer;
+  denominationAsset: DenominationAssetInterface;
+  sharesActionTimelock?: BigNumberish;
+  fundOwner?: AddressLike;
+  fundName?: string;
+  feeManagerConfig?: BytesLike;
+  policyManagerConfig?: BytesLike;
+  investment?: InitialInvestmentParams;
+}
+
+export async function createComptrollerProxy({
+  signer,
+  comptrollerLib,
+  denominationAsset,
+  sharesActionTimelock = 0,
+}: {
+  signer: SignerWithAddress;
+  comptrollerLib: ComptrollerLib;
+  denominationAsset: AddressLike;
+  sharesActionTimelock?: BigNumberish;
+}) {
+  const constructData = encodeFunctionData(comptrollerLib.init.fragment, [denominationAsset, sharesActionTimelock]);
+
+  const comptrollerProxyContract = await ComptrollerProxy.deploy(signer, constructData, comptrollerLib);
+
+  return {
+    comptrollerProxy: new ComptrollerLib(comptrollerProxyContract, signer),
+    receipt: comptrollerProxyContract.deployment!,
+  };
+}
+
+export async function createMigratedFundConfig({
+  signer,
+  fundDeployer,
+  denominationAsset,
+  sharesActionTimelock = 0,
+  feeManagerConfigData = '0x',
+  policyManagerConfigData = '0x',
+}: CreateMigratedFundConfigParams) {
+  const receipt = await fundDeployer
+    .connect(signer)
+    .createMigratedFundConfig(denominationAsset, sharesActionTimelock, feeManagerConfigData, policyManagerConfigData);
+
+  const comptrollerDeployedArgs = assertEvent(receipt, 'ComptrollerProxyDeployed', {
+    creator: signer,
+    comptrollerProxy: expect.any(String) as string,
+    denominationAsset,
+    sharesActionTimelock: BigNumber.from(sharesActionTimelock),
+    feeManagerConfigData: utils.hexlify(feeManagerConfigData),
+    policyManagerConfigData: utils.hexlify(policyManagerConfigData),
+    forMigration: true,
+  });
+
+  return {
+    receipt,
+    comptrollerProxy: new ComptrollerLib(comptrollerDeployedArgs.comptrollerProxy, signer),
+  };
+}
+
+// TODO: should we pass in the fundOwner as a signer also so we can connect comptroller proxy and vault proxy to that acct instead?
+export async function createNewFund({
+  signer,
+  fundDeployer,
+  denominationAsset,
+  sharesActionTimelock = 0,
+  fundOwner = randomAddress(),
+  fundName = 'My Fund',
+  feeManagerConfig = '0x',
+  policyManagerConfig = '0x',
+  investment,
+}: CreateNewFundParams) {
+  const receipt = await fundDeployer
+    .connect(signer)
+    .createNewFund(fundOwner, fundName, denominationAsset, sharesActionTimelock, feeManagerConfig, policyManagerConfig);
+
+  const comptrollerDeployedArgs = assertEvent(receipt, 'ComptrollerProxyDeployed', {
+    creator: signer,
+    comptrollerProxy: expect.any(String) as string,
+    denominationAsset,
+    sharesActionTimelock: BigNumber.from(sharesActionTimelock),
+    feeManagerConfigData: utils.hexlify(feeManagerConfig),
+    policyManagerConfigData: utils.hexlify(policyManagerConfig),
+    forMigration: false,
+  });
+
+  const comptrollerProxy = new ComptrollerLib(comptrollerDeployedArgs.comptrollerProxy, signer);
+
+  const newFundDeployedArgs = assertEvent(receipt, 'NewFundCreated', {
+    creator: signer,
+    comptrollerProxy,
+    vaultProxy: expect.any(String) as string,
+    fundOwner,
+    fundName,
+    denominationAsset,
+    sharesActionTimelock: BigNumber.from(sharesActionTimelock),
+    feeManagerConfigData: utils.hexlify(feeManagerConfig),
+    policyManagerConfigData: utils.hexlify(policyManagerConfig),
+  });
+
+  const vaultProxy = new VaultLib(newFundDeployedArgs.vaultProxy, signer);
+
+  if (investment != null) {
+    await buyShares({
+      comptrollerProxy,
+      denominationAsset,
+      ...investment,
+    });
+  }
+
+  return {
+    comptrollerProxy,
+    receipt,
+    vaultProxy,
+  };
+}

package/src/scaffolding/shares.ts

@@ -0,0 +1,63 @@
+import { AddressLike, Contract, Send } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib } from '@enzymefinance/protocol';
+import { BigNumber, BigNumberish, constants, utils } from 'ethers';
+
+// prettier-ignore
+export interface DenominationAssetInterface extends Contract<any> {
+  approve: Send<(spender: AddressLike, amount: BigNumberish) => boolean, any>;
+}
+
+export interface BuySharesParams {
+  comptrollerProxy: ComptrollerLib;
+  signer: SignerWithAddress;
+  buyers: AddressLike[];
+  denominationAsset: DenominationAssetInterface;
+  investmentAmounts?: BigNumberish[];
+  minSharesAmounts?: BigNumberish[];
+}
+
+export interface RedeemSharesParams {
+  comptrollerProxy: ComptrollerLib;
+  signer: SignerWithAddress;
+  quantity?: BigNumberish;
+  additionalAssets?: AddressLike[];
+  assetsToSkip?: AddressLike[];
+}
+
+export async function buyShares({
+  comptrollerProxy,
+  signer,
+  buyers,
+  denominationAsset,
+  investmentAmounts = new Array(buyers.length).fill(utils.parseEther('1')),
+  minSharesAmounts = investmentAmounts,
+}: BuySharesParams) {
+  const totalInvestmentAmount = investmentAmounts.reduce(
+    (total: BigNumber, amount) => total.add(amount),
+    constants.Zero,
+  );
+
+  const callerDenominationAsset = denominationAsset.connect(signer);
+  await callerDenominationAsset.approve(comptrollerProxy, totalInvestmentAmount);
+
+  const callerComptrollerProxy = comptrollerProxy.connect(signer);
+  return callerComptrollerProxy.buyShares(buyers, investmentAmounts, minSharesAmounts);
+}
+
+export async function redeemShares({
+  comptrollerProxy,
+  signer,
+  quantity,
+  additionalAssets = [],
+  assetsToSkip = [],
+}: RedeemSharesParams) {
+  if (quantity == undefined) {
+    if (additionalAssets.length > 0 || assetsToSkip.length > 0) {
+      throw 'Must specify shares quantity if specifying additional assets or assets to skip';
+    }
+    return comptrollerProxy.connect(signer).redeemShares();
+  } else {
+    return comptrollerProxy.connect(signer).redeemSharesDetailed(quantity, additionalAssets, assetsToSkip);
+  }
+}

package/src/scaffolding/vaultCalls.ts

@@ -0,0 +1,58 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import {
+  ComptrollerLib,
+  curveMinterMintManySelector,
+  curveMinterMintSelector,
+  curveMinterToggleApproveMintSelector,
+  encodeArgs,
+} from '@enzymefinance/protocol';
+import { constants } from 'ethers';
+
+export function vaultCallCurveMinterMint({
+  comptrollerProxy,
+  minter,
+  gauge,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  minter: AddressLike;
+  gauge: AddressLike;
+}) {
+  return comptrollerProxy.vaultCallOnContract(minter, curveMinterMintSelector, encodeArgs(['address'], [gauge]));
+}
+
+export function vaultCallCurveMinterMintMany({
+  comptrollerProxy,
+  minter,
+  gauges,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  minter: AddressLike;
+  gauges: AddressLike[];
+}) {
+  const gaugesFormatted = new Array(8).fill(constants.AddressZero);
+  for (const i in gauges) {
+    gaugesFormatted[i] = gauges[i];
+  }
+
+  return comptrollerProxy.vaultCallOnContract(
+    minter,
+    curveMinterMintManySelector,
+    encodeArgs(['address[8]'], [gaugesFormatted]),
+  );
+}
+
+export function vaultCallCurveMinterToggleApproveMint({
+  comptrollerProxy,
+  minter,
+  account,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  minter: AddressLike;
+  account: AddressLike;
+}) {
+  return comptrollerProxy.vaultCallOnContract(
+    minter,
+    curveMinterToggleApproveMintSelector,
+    encodeArgs(['address'], [account]),
+  );
+}