@enzymefinance/testutils 4.0.0 → 4.0.3

package/src/assertions.ts

@@ -1,23 +0,0 @@
-import type { ContractReceipt } from '@enzymefinance/ethers';
-import { extractEvent } from '@enzymefinance/ethers';
-import type { 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;
-
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  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

@@ -1,280 +0,0 @@
-import {
-  AaveAdapter,
-  AaveDebtPositionLib,
-  AaveDebtPositionParser,
-  AavePriceFeed,
-  AddressListRegistry,
-  AllowedAdapterIncomingAssetsPolicy,
-  AllowedAdaptersPolicy,
-  AllowedAssetsForRedemptionPolicy,
-  AllowedDepositRecipientsPolicy,
-  AllowedExternalPositionTypesPolicy,
-  AllowedSharesTransferRecipientsPolicy,
-  CompoundAdapter,
-  CompoundDebtPositionLib,
-  CompoundDebtPositionParser,
-  CompoundPriceFeed,
-  ComptrollerLib,
-  ConvexCurveLpStakingAdapter,
-  ConvexCurveLpStakingWrapperFactory,
-  ConvexCurveLpStakingWrapperPriceFeed,
-  CumulativeSlippageTolerancePolicy,
-  CurveExchangeAdapter,
-  CurveLiquidityAdapter,
-  CurvePriceFeed,
-  DepositWrapper,
-  Dispatcher,
-  EntranceRateBurnFee,
-  EntranceRateDirectFee,
-  ExitRateBurnFee,
-  ExitRateDirectFee,
-  ExternalPositionFactory,
-  ExternalPositionManager,
-  FeeManager,
-  FundDeployer,
-  FundValueCalculator,
-  FundValueCalculatorRouter,
-  FundValueCalculatorUsdWrapper,
-  FuseAdapter,
-  FusePriceFeed,
-  GasRelayPaymasterFactory,
-  IdleAdapter,
-  IdlePriceFeed,
-  IntegrationManager,
-  LidoStethPriceFeed,
-  ManagementFee,
-  MinAssetBalancesPostRedemptionPolicy,
-  MinMaxInvestmentPolicy,
-  OlympusV2Adapter,
-  OnlyRemoveDustExternalPositionPolicy,
-  OnlyUntrackDustOrPricelessAssetsPolicy,
-  ParaSwapV5Adapter,
-  PerformanceFee,
-  PolicyManager,
-  PoolTogetherV4Adapter,
-  PoolTogetherV4PriceFeed,
-  ProtocolFeeReserveLib,
-  ProtocolFeeTracker,
-  RevertingPriceFeed,
-  SynthetixAdapter,
-  UniswapV2ExchangeAdapter,
-  UniswapV2LiquidityAdapter,
-  UniswapV2PoolPriceFeed,
-  UniswapV3Adapter,
-  UnpermissionedActionsWrapper,
-  UsdEthSimulatedAggregator,
-  ValueInterpreter,
-  VaultLib,
-  YearnVaultV2Adapter,
-  YearnVaultV2PriceFeed,
-  ZeroExV2Adapter,
-} from '@enzymefinance/protocol';
-
-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 = {
-    aaveAdapter: new AaveAdapter(fixture['AaveAdapter'].address, deployer),
-    aaveDebtPositionLib: new AaveDebtPositionLib(fixture['AaveDebtPositionLib'].address, deployer),
-    aaveDebtPositionParser: new AaveDebtPositionParser(fixture['AaveDebtPositionParser'].address, deployer),
-    aavePriceFeed: new AavePriceFeed(fixture['AavePriceFeed'].address, deployer),
-    addressListRegistry: new AddressListRegistry(fixture['AddressListRegistry'].address, deployer),
-    allowedAdapterIncomingAssetsPolicy: new AllowedAdapterIncomingAssetsPolicy(fixture['AllowedAdapterIncomingAssetsPolicy'].address, deployer),
-    allowedAdaptersPolicy: new AllowedAdaptersPolicy(fixture['AllowedAdaptersPolicy'].address, deployer),
-    allowedAssetsForRedemptionPolicy: new AllowedAssetsForRedemptionPolicy(fixture['AllowedAssetsForRedemptionPolicy'].address, deployer),
-    allowedDepositRecipientsPolicy: new AllowedDepositRecipientsPolicy(fixture['AllowedDepositRecipientsPolicy'].address, deployer),
-    allowedExternalPositionTypesPolicy: new AllowedExternalPositionTypesPolicy(fixture['AllowedExternalPositionTypesPolicy'].address, deployer),
-    allowedSharesTransferRecipientsPolicy: new AllowedSharesTransferRecipientsPolicy(fixture['AllowedSharesTransferRecipientsPolicy'].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),
-    curveLiquidityAdapter: new CurveLiquidityAdapter(fixture['CurveLiquidityAdapter'].address, deployer),
-    curvePriceFeed: new CurvePriceFeed(fixture['CurvePriceFeed'].address, deployer),
-    depositWrapper: new DepositWrapper(fixture['DepositWrapper'].address, deployer),
-    dispatcher: new Dispatcher(fixture['Dispatcher'].address, deployer),
-    entranceRateBurnFee: new EntranceRateBurnFee(fixture['EntranceRateBurnFee'].address, deployer),
-    entranceRateDirectFee: new EntranceRateDirectFee(fixture['EntranceRateDirectFee'].address, deployer),
-    exitRateBurnFee: new ExitRateBurnFee(fixture['ExitRateBurnFee'].address, deployer),
-    exitRateDirectFee: new ExitRateDirectFee(fixture['ExitRateDirectFee'].address, deployer),
-    externalPositionFactory: new ExternalPositionFactory(fixture['ExternalPositionFactory'].address, deployer),
-    externalPositionManager: new ExternalPositionManager(fixture['ExternalPositionManager'].address, deployer),
-    feeManager: new FeeManager(fixture['FeeManager'].address, deployer),
-    fundDeployer: new FundDeployer(fixture['FundDeployer'].address, deployer),
-    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),
-    idleAdapter: new IdleAdapter(fixture['IdleAdapter'].address, deployer),
-    idlePriceFeed: new IdlePriceFeed(fixture['IdlePriceFeed'].address, deployer),
-    integrationManager: new IntegrationManager(fixture['IntegrationManager'].address, deployer),
-    lidoStethPriceFeed: new LidoStethPriceFeed(fixture['LidoStethPriceFeed'].address, deployer),
-    managementFee: new ManagementFee(fixture['ManagementFee'].address, deployer),
-    minAssetBalancesPostRedemptionPolicy: new MinAssetBalancesPostRedemptionPolicy(fixture['MinAssetBalancesPostRedemptionPolicy'].address, deployer),
-    minMaxInvestmentPolicy: new MinMaxInvestmentPolicy(fixture['MinMaxInvestmentPolicy'].address, deployer),
-    olympusV2Adapter: new OlympusV2Adapter(fixture['OlympusV2Adapter'].address, deployer),
-    onlyRemoveDustExternalPositionPolicy: new OnlyRemoveDustExternalPositionPolicy(fixture['OnlyRemoveDustExternalPositionPolicy'].address, deployer),
-    onlyUntrackDustOrPricelessAssetsPolicy: new OnlyUntrackDustOrPricelessAssetsPolicy(fixture['OnlyUntrackDustOrPricelessAssetsPolicy'].address, deployer),
-    paraSwapV5Adapter: new ParaSwapV5Adapter(fixture['ParaSwapV5Adapter'].address, deployer),
-    performanceFee: new PerformanceFee(fixture['PerformanceFee'].address, deployer),
-    policyManager: new PolicyManager(fixture['PolicyManager'].address, deployer),
-    poolTogetherV4Adapter: new PoolTogetherV4Adapter(fixture['PoolTogetherV4Adapter'].address, deployer),
-    poolTogetherV4PriceFeed: new PoolTogetherV4PriceFeed(fixture['PoolTogetherV4PriceFeed'].address, deployer),
-    protocolFeeReserveLib: new ProtocolFeeReserveLib(fixture['ProtocolFeeReserveLib'].address, deployer),
-    protocolFeeReserveProxy: new ProtocolFeeReserveLib(fixture['ProtocolFeeReserveProxy'].address, deployer),
-    protocolFeeTracker: new ProtocolFeeTracker(fixture['ProtocolFeeTracker'].address, deployer),
-    revertingPriceFeed: new RevertingPriceFeed(fixture['RevertingPriceFeed'].address, deployer),
-    synthetixAdapter: new SynthetixAdapter(fixture['SynthetixAdapter'].address, deployer),
-    uniswapV2ExchangeAdapter: new UniswapV2ExchangeAdapter(fixture['UniswapV2ExchangeAdapter'].address, deployer),
-    uniswapV2LiquidityAdapter: new UniswapV2LiquidityAdapter(fixture['UniswapV2LiquidityAdapter'].address, deployer),
-    uniswapV2PoolPriceFeed: new UniswapV2PoolPriceFeed(fixture['UniswapV2PoolPriceFeed'].address, deployer),
-    uniswapV3Adapter: new UniswapV3Adapter(fixture['UniswapV3Adapter'].address, deployer),
-    unpermissionedActionsWrapper: new UnpermissionedActionsWrapper(fixture['UnpermissionedActionsWrapper'].address, deployer),
-    usdEthSimulatedAggregator: new UsdEthSimulatedAggregator(fixture['UsdEthSimulatedAggregator'].address, deployer),
-    valueInterpreter: new ValueInterpreter(fixture['ValueInterpreter'].address, deployer),
-    vaultLib: new VaultLib(fixture['VaultLib'].address, deployer),
-    yearnVaultV2Adapter: new YearnVaultV2Adapter(fixture['YearnVaultV2Adapter'].address, deployer),
-    yearnVaultV2PriceFeed: new YearnVaultV2PriceFeed(fixture['YearnVaultV2PriceFeed'].address, deployer),
-    zeroExV2Adapter: new ZeroExV2Adapter(fixture['ZeroExV2Adapter'].address, deployer),
-  } as const;
-
-  return {
-    accounts,
-    config,
-    deployer,
-    deployment,
-  } as const;
-}
-
-type Resolve<T extends () => any> = ReturnType<T> extends Promise<infer U> ? U : ReturnType<T>;
-
-export type ProtocolDeployment = Resolve<typeof deployProtocolFixture>;
-
-import type { ChainlinkRateAsset } from '@enzymefinance/protocol';
-
-export interface DeploymentConfig {
-  feeBps: number;
-  feeToken: string;
-  feeTokenBurn: {
-    burnFromVault: boolean;
-    sendToProtocolFeeReserve: boolean;
-    externalBurnerAddress: string;
-  };
-  weth: string;
-  wrappedNativeAsset: string;
-  primitives: Record<string, string>;
-  gsn: {
-    relayHub: string;
-    relayWorker: string;
-    trustedForwarder: string;
-  };
-  chainlink: {
-    ethusd: string;
-    aggregators: Record<string, readonly [string, ChainlinkRateAsset]>;
-  };
-  synthetix: {
-    snx: string;
-    susd: string;
-    delegateApprovals: string;
-    originator: string;
-    redeemer: string;
-    trackingCode: string;
-  };
-  convex: {
-    booster: string;
-    crvToken: string;
-    cvxToken: string;
-  };
-  curve: {
-    addressProvider: string;
-    minter: string;
-    pools: Record<string, { pool: string; lpToken: string; liquidityGaugeToken: string; invariantProxyAsset: string }>;
-  };
-  aave: {
-    incentivesController: string;
-    lendingPoolAddressProvider: string;
-    protocolDataProvider: string;
-    atokens: Record<string, [string, string]>;
-  };
-  compound: {
-    ceth: string;
-    comptroller: string;
-    ctokens: Record<string, string>;
-  };
-  fuse: {
-    fetherTokens: Record<string, string>;
-    ftokens: Record<string, string>;
-  };
-  idle: {
-    bestYieldIdleDai: string;
-    bestYieldIdleUsdc: string;
-    bestYieldIdleUsdt: string;
-    bestYieldIdleSusd: string;
-    bestYieldIdleTusd: string;
-    bestYieldIdleWbtc: string;
-    riskAdjustedIdleDai: string;
-    riskAdjustedIdleUsdc: string;
-    riskAdjustedIdleUsdt: string;
-  };
-  lido: {
-    steth: string;
-  };
-  olympusV2: {
-    stakingContract: string;
-  };
-  paraSwapV5: {
-    augustusSwapper: string;
-    tokenTransferProxy: string;
-  };
-  poolTogetherV4: {
-    ptTokens: Record<string, [string, string]>;
-  };
-  positionsLimit: number;
-  unsupportedAssets: Record<string, string>;
-  uniswap: {
-    factory: string;
-    router: string;
-    pools: Record<string, string>;
-  };
-  uniswapV3: {
-    router: string;
-    nonFungiblePositionManager: string;
-  };
-  yearn: {
-    vaultV2: {
-      registry: string;
-      yVaults: Record<string, string>;
-    };
-  };
-  zeroex: {
-    exchange: string;
-    allowedMakers: string[];
-  };
-}

package/src/gasRelayer.ts

@@ -1,95 +0,0 @@
-import type { ContractReceipt } from '@enzymefinance/ethers';
-import type { CreateSignedRelayRequestOptions } from '@enzymefinance/protocol';
-import { createSignedRelayRequest, IGsnRelayHub, isTypedDataSigner } from '@enzymefinance/protocol';
-import type { BigNumberish } from 'ethers';
-import { BigNumber, utils } from 'ethers';
-
-import { assertEvent } from './assertions';
-
-export interface RelayTransactionOptions extends CreateSignedRelayRequestOptions {
-  relayHub: string;
-}
-
-export async function relayTransaction(options: RelayTransactionOptions) {
-  const signer = options.sendFunction.contract.signer;
-  if (!(signer && isTypedDataSigner(signer))) {
-    throw new Error('Missing or invalid signer');
-  }
-
-  const { relayData, relayRequest, signedRelayRequest } = await createSignedRelayRequest(options);
-
-  // NOTE: In the real implementation, we fetch these from the relayer.
-  const defaultGasLimit = 12450000;
-  const defaultMaxAcceptance = BigNumber.from(150000);
-
-  // NOTE: There is an inconsistency between how the typed data object shape and the relayCall argument.
-  const mergedRelayRequest = {
-    relayData,
-    request: relayRequest,
-  };
-
-  const relayHub = new IGsnRelayHub(options.relayHub, provider.getSigner(options.relayWorker));
-
-  return relayHub.relayCall
-    .args(defaultMaxAcceptance, mergedRelayRequest, signedRelayRequest, '0x', defaultGasLimit)
-    .gas(defaultGasLimit, relayData.gasPrice)
-    .send();
-}
-
-const relayed = utils.EventFragment.fromString(
-  'TransactionRelayed(address indexed relayManager, address indexed relayWorker, address indexed from, address to, address paymaster, bytes4 selector, uint8 status, uint256 charge)',
-);
-
-const rejected = utils.EventFragment.fromString(
-  'TransactionRejectedByPaymaster(address indexed relayManager, address indexed paymaster, address indexed from, address to, address relayWorker, bytes4 selector, uint256 innerGasUsed, bytes reason)',
-);
-
-export function assertDidRelay(receipt: ContractReceipt<any>) {
-  return assertEvent(receipt, relayed, {
-    charge: expect.anything(),
-    from: expect.any(String),
-    paymaster: expect.any(String),
-    relayManager: expect.any(String),
-    relayWorker: expect.any(String),
-    selector: expect.any(String),
-    status: expect.anything(),
-    to: expect.any(String),
-  });
-}
-
-export function assertDidRelaySuccessfully(receipt: ContractReceipt<any>) {
-  const result = assertDidRelay(receipt);
-  expect(result.status).toEqBigNumber(0);
-}
-
-export function assertDidRelayWithError(receipt: ContractReceipt<any>) {
-  const result = assertDidRelay(receipt);
-  expect(result.status).toEqBigNumber(1);
-}
-
-export function assertDidRelayWithCharge(
-  receipt: ContractReceipt<any>,
-  amount: BigNumberish,
-  tolerance?: BigNumberish,
-) {
-  const result = assertDidRelay(receipt);
-  expect(result.charge).toBeAroundBigNumber(amount, tolerance);
-}
-
-export function assertPaymasterDidReject(receipt: ContractReceipt<any>) {
-  return assertEvent(receipt, rejected, {
-    from: expect.any(String),
-    innerGasUsed: expect.anything(),
-    paymaster: expect.any(String),
-    reason: expect.any(String),
-    relayManager: expect.any(String),
-    relayWorker: expect.any(String),
-    selector: expect.any(String),
-    to: expect.any(String),
-  });
-}
-
-export function assertPaymasterDidRejectForReason(receipt: ContractReceipt<any>, reason: string) {
-  const params = assertPaymasterDidReject(receipt);
-  expect(utils.toUtf8String('0x' + params.reason.substr(138))).toMatch(reason);
-}

package/src/helpers.ts

@@ -1,39 +0,0 @@
-import type { AddressLike, ContractReceipt } from '@enzymefinance/ethers';
-import type { ValueInterpreter } from '@enzymefinance/protocol';
-import type { BigNumberish } from 'ethers';
-import { BigNumber, utils } from 'ethers';
-
-export async function transactionTimestamp(receipt: ContractReceipt<any>) {
-  const block = await provider.getBlock(receipt.blockNumber);
-
-  return block.timestamp;
-}
-
-export async function calcMlnValueAndBurnAmountForSharesBuyback({
-  valueInterpreter,
-  mln,
-  denominationAsset,
-  sharesSupply,
-  gav,
-  buybackSharesAmount,
-}: {
-  valueInterpreter: ValueInterpreter;
-  mln: AddressLike;
-  denominationAsset: AddressLike;
-  sharesSupply: BigNumberish;
-  gav: BigNumberish;
-  buybackSharesAmount: BigNumberish;
-}) {
-  // Calculate expected mlnValue of shares to buyback
-  // TODO: calcGrossShareValue can also be a helper util
-  const grossShareValue = BigNumber.from(gav).mul(utils.parseEther('1')).div(sharesSupply);
-  const denominationAssetValueOfBuyback = grossShareValue.mul(buybackSharesAmount).div(utils.parseEther('1'));
-  const mlnValueOfBuyback = await valueInterpreter.calcCanonicalAssetValue
-    .args(denominationAsset, denominationAssetValueOfBuyback, mln)
-    .call();
-
-  // 50% discount
-  const mlnAmountToBurn = mlnValueOfBuyback.div(2);
-
-  return { mlnAmountToBurn, mlnValue: mlnValueOfBuyback };
-}

package/src/index.ts

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

package/src/scaffolding/assets.ts

@@ -1,37 +0,0 @@
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type { ComptrollerLib, IntegrationManager, StandardToken } from '@enzymefinance/protocol';
-import type { BigNumberish } from 'ethers';
-
-import { addTrackedAssetsToVault } from './extensions/integrations/trackedAssets';
-
-export async function addNewAssetsToFund({
-  signer,
-  comptrollerProxy,
-  integrationManager,
-  assets,
-  amounts = new Array(assets.length).fill(1),
-}: {
-  signer: SignerWithAddress;
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  assets: StandardToken[];
-  amounts?: BigNumberish[];
-}) {
-  // First, add tracked assets
-  const receipt = addTrackedAssetsToVault({
-    assets,
-    comptrollerProxy,
-    integrationManager,
-    signer,
-  });
-
-  // Then seed the vault with balances as necessary
-  const vaultProxy = await comptrollerProxy.getVaultProxy();
-  for (const i in assets) {
-    if (amounts[i] > 0) {
-      await assets[i].transfer(vaultProxy, amounts[i]);
-    }
-  }
-
-  return receipt;
-}

package/src/scaffolding/chainlink.ts

@@ -1,8 +0,0 @@
-import type { MockChainlinkPriceSource } from '@enzymefinance/protocol';
-import type { BigNumberish } from 'ethers';
-
-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

@@ -1,11 +0,0 @@
-import type { AddressLike } from '@enzymefinance/ethers';
-import { StandardToken } from '@enzymefinance/protocol';
-import { utils } from 'ethers';
-
-export async function getAssetBalances({ account, assets }: { account: AddressLike; assets: AddressLike[] }) {
-  return Promise.all(assets.map((asset) => new StandardToken(asset, provider).balanceOf(account)));
-}
-
-export async function getAssetUnit(asset: StandardToken) {
-  return utils.parseUnits('1', await asset.decimals());
-}

package/src/scaffolding/core.ts

@@ -1,103 +0,0 @@
-import type { Dispatcher, GasRelayPaymasterFactory, ValueInterpreter } from '@enzymefinance/protocol';
-import {
-  ComptrollerLib,
-  ExternalPositionManager,
-  FeeManager,
-  FundDeployer,
-  IntegrationManager,
-  PolicyManager,
-  ProtocolFeeTracker,
-  VaultLib,
-} from '@enzymefinance/protocol';
-import type { Signer } from 'ethers';
-
-// TODO: Should refactor this function to take all deployment contracts and set up everything by default,
-// unless overrides are passed-in
-export async function createFundDeployer({
-  deployer,
-  externalPositionManager,
-  dispatcher,
-  gasRelayPaymasterFactory,
-  valueInterpreter,
-  vaultLib,
-  setOnDispatcher = true,
-  setReleaseLive = true,
-}: {
-  deployer: Signer;
-  externalPositionManager: ExternalPositionManager;
-  dispatcher: Dispatcher;
-  feeManager: FeeManager;
-  gasRelayPaymasterFactory: GasRelayPaymasterFactory;
-  integrationManager: IntegrationManager;
-  policyManager: PolicyManager;
-  valueInterpreter: ValueInterpreter;
-  vaultLib: VaultLib;
-  setOnDispatcher?: boolean;
-  setReleaseLive?: boolean;
-}) {
-  const mlnToken = await vaultLib.getMlnToken();
-  const wethToken = await vaultLib.getWethToken();
-
-  // TODO: Shortcut for now, can pass in param later
-  const protocolFeeReserve = await vaultLib.getProtocolFeeReserve();
-
-  const nextFundDeployer = await FundDeployer.deploy(deployer, dispatcher, gasRelayPaymasterFactory);
-
-  // Re-deploy extensions with new FundDeployer
-  const nextPolicyManager = await PolicyManager.deploy(deployer, nextFundDeployer, gasRelayPaymasterFactory);
-  const nextExternalPositionManager = await ExternalPositionManager.deploy(
-    deployer,
-    nextFundDeployer,
-    await externalPositionManager.getExternalPositionFactory(),
-    nextPolicyManager,
-  );
-  const nextFeeManager = await FeeManager.deploy(deployer, nextFundDeployer);
-  const nextIntegrationManager = await IntegrationManager.deploy(
-    deployer,
-    nextFundDeployer,
-    nextPolicyManager,
-    valueInterpreter,
-  );
-
-  const nextComptrollerLib = await ComptrollerLib.deploy(
-    deployer,
-    dispatcher,
-    protocolFeeReserve,
-    nextFundDeployer,
-    valueInterpreter,
-    nextExternalPositionManager,
-    nextFeeManager,
-    nextIntegrationManager,
-    nextPolicyManager,
-    gasRelayPaymasterFactory,
-    mlnToken,
-    wethToken,
-  );
-
-  await nextFundDeployer.setComptrollerLib(nextComptrollerLib);
-
-  const nextProtocolFeeTracker = await ProtocolFeeTracker.deploy(deployer, nextFundDeployer);
-  await nextFundDeployer.setProtocolFeeTracker(nextProtocolFeeTracker);
-
-  const nextVaultLib = await VaultLib.deploy(
-    deployer,
-    externalPositionManager,
-    await vaultLib.getGasRelayPaymasterFactory(),
-    await vaultLib.getProtocolFeeReserve(),
-    nextProtocolFeeTracker,
-    await vaultLib.getMlnToken(),
-    await vaultLib.getMlnBurner(),
-    await vaultLib.getWethToken(),
-    await vaultLib.getPositionsLimit(),
-  );
-  await nextFundDeployer.setVaultLib(nextVaultLib);
-
-  if (setReleaseLive) {
-    await nextFundDeployer.setReleaseLive();
-  }
-  if (setOnDispatcher) {
-    await dispatcher.setCurrentFundDeployer(nextFundDeployer);
-  }
-
-  return nextFundDeployer;
-}

package/src/scaffolding/extensions/common.ts

@@ -1,30 +0,0 @@
-import type { AddressLike } from '@enzymefinance/ethers';
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type { ComptrollerLib } from '@enzymefinance/protocol';
-import type { 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;
-}