@enzymefinance/testutils 4.0.0-next.7 → 4.0.2

package/dist/index.mjs

@@ -0,0 +1,3352 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/accounts.ts
+import { resolveAddress } from "@enzymefinance/ethers";
+
+// src/helpers.ts
+import { SelfDestructEthPayer } from "@enzymefinance/protocol";
+import { BigNumber, utils } from "ethers";
+import { MerkleTree } from "merkletreejs";
+async function calcMlnValueAndBurnAmountForSharesBuyback({
+  valueInterpreter,
+  mln,
+  denominationAsset,
+  sharesSupply,
+  gav,
+  buybackSharesAmount
+}) {
+  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();
+  const mlnAmountToBurn = mlnValueOfBuyback.div(2);
+  return { mlnAmountToBurn, mlnValue: mlnValueOfBuyback };
+}
+function generateMerkleTreeForContractProof({
+  itemArrays,
+  itemTypes
+}) {
+  const leaves = itemArrays.map((itemArray) => utils.solidityKeccak256(itemTypes, itemArray));
+  const tree = new MerkleTree(leaves, utils.keccak256, { sort: true });
+  const root = tree.getHexRoot();
+  return { leaves, root, tree };
+}
+async function sendEthBySelfDestruct({
+  signer,
+  recipient,
+  amount = utils.parseEther("1")
+}) {
+  const selfDestructEthPayer = await SelfDestructEthPayer.deploy(signer);
+  await selfDestructEthPayer.destructTo.args(recipient).value(amount).send();
+}
+async function transactionTimestamp(receipt) {
+  const block = await provider.getBlock(receipt.blockNumber);
+  return block.timestamp;
+}
+
+// src/accounts.ts
+async function impersonateContractSigner({
+  contractAddress,
+  ethSeeder,
+  provider: provider2
+}) {
+  await sendEthBySelfDestruct({ recipient: contractAddress, signer: ethSeeder });
+  return impersonateSigner({
+    provider: provider2,
+    signerAddress: contractAddress
+  });
+}
+async function impersonateSigner({
+  signerAddress,
+  provider: provider2
+}) {
+  await provider2.send("hardhat_impersonateAccount", [signerAddress]);
+  return provider2.getSignerWithAddress(resolveAddress(signerAddress));
+}
+
+// src/assertions.ts
+import { extractEvent } from "@enzymefinance/ethers";
+function assertEvent(receipt, event, match) {
+  var _a;
+  const events = extractEvent(receipt, event);
+  expect(events.length).toBe(1);
+  expect(receipt).toHaveEmittedWith(event, match);
+  const args = (_a = events.shift()) == null ? void 0 : _a.args;
+  return args;
+}
+function assertNoEvent(receipt, event) {
+  const events = extractEvent(receipt, event);
+  expect(events.length).toBe(0);
+}
+
+// src/deployment.ts
+import {
+  AaveAdapter,
+  AaveDebtPositionLib,
+  AaveDebtPositionParser,
+  AavePriceFeed,
+  AddressListRegistry,
+  AllowedAdapterIncomingAssetsPolicy,
+  AllowedAdaptersPolicy,
+  AllowedAssetsForRedemptionPolicy,
+  AllowedDepositRecipientsPolicy,
+  AllowedExternalPositionTypesPolicy,
+  AllowedSharesTransferRecipientsPolicy,
+  CompoundAdapter,
+  CompoundDebtPositionLib,
+  CompoundDebtPositionParser,
+  CompoundPriceFeed,
+  ComptrollerLib,
+  ConvexCurveLpStakingAdapter,
+  ConvexCurveLpStakingWrapperFactory,
+  ConvexCurveLpStakingWrapperPriceFeed,
+  ConvexVotingPositionLib,
+  ConvexVotingPositionParser,
+  CumulativeSlippageTolerancePolicy,
+  CurveExchangeAdapter,
+  CurveLiquidityAdapter,
+  CurvePriceFeed,
+  DepositWrapper,
+  Dispatcher,
+  EntranceRateBurnFee,
+  EntranceRateDirectFee,
+  ExitRateBurnFee,
+  ExitRateDirectFee,
+  ExternalPositionFactory,
+  ExternalPositionManager,
+  FeeManager,
+  FundDeployer,
+  FundValueCalculator,
+  FundValueCalculatorRouter,
+  FundValueCalculatorUsdWrapper,
+  FuseAdapter,
+  FusePriceFeed,
+  GasRelayPaymasterFactory,
+  GlobalConfigLib,
+  IdleAdapter,
+  IdlePriceFeed,
+  IntegrationManager,
+  LidoStethPriceFeed,
+  LiquityDebtPositionLib,
+  LiquityDebtPositionParser,
+  ManagementFee,
+  MapleLiquidityPositionLib,
+  MapleLiquidityPositionParser,
+  MinAssetBalancesPostRedemptionPolicy,
+  MinMaxInvestmentPolicy,
+  OlympusV2Adapter,
+  OnlyRemoveDustExternalPositionPolicy,
+  OnlyUntrackDustOrPricelessAssetsPolicy,
+  ParaSwapV5Adapter,
+  PerformanceFee,
+  PolicyManager,
+  PoolTogetherV4Adapter,
+  PoolTogetherV4PriceFeed,
+  ProtocolFeeReserveLib,
+  ProtocolFeeTracker,
+  RevertingPriceFeed,
+  SharesSplitterFactory,
+  SynthetixAdapter,
+  UniswapV2ExchangeAdapter,
+  UniswapV2LiquidityAdapter,
+  UniswapV2PoolPriceFeed,
+  UniswapV3Adapter,
+  UnpermissionedActionsWrapper,
+  UsdEthSimulatedAggregator,
+  ValueInterpreter,
+  VaultLib,
+  YearnVaultV2Adapter,
+  YearnVaultV2PriceFeed,
+  ZeroExV2Adapter
+} from "@enzymefinance/protocol";
+async function getNamedSigner(name) {
+  const accounts = await hre.getNamedAccounts();
+  if (!accounts[name]) {
+    throw new Error(`Missing account with name ${name}`);
+  }
+  return provider.getSignerWithAddress(accounts[name]);
+}
+async function getUnnamedSigners() {
+  const accounts = await hre.getUnnamedAccounts();
+  return Promise.all(accounts.map((account) => provider.getSignerWithAddress(account)));
+}
+async function deployProtocolFixture() {
+  const fixture = await hre.deployments.fixture();
+  const deployer = await getNamedSigner("deployer");
+  const accounts = await getUnnamedSigners();
+  const config = fixture.Config.linkedData;
+  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),
+    convexVotingPositionLib: new ConvexVotingPositionLib(fixture.ConvexVotingPositionLib.address, deployer),
+    convexVotingPositionParser: new ConvexVotingPositionParser(fixture.ConvexVotingPositionParser.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),
+    globalConfigLib: new GlobalConfigLib(fixture.GlobalConfigLib.address, deployer),
+    globalConfigProxy: new GlobalConfigLib(fixture.GlobalConfigProxy.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),
+    liquityDebtPositionLib: new LiquityDebtPositionLib(fixture.LiquityDebtPositionLib.address, deployer),
+    liquityDebtPositionParser: new LiquityDebtPositionParser(fixture.LiquityDebtPositionParser.address, deployer),
+    managementFee: new ManagementFee(fixture.ManagementFee.address, deployer),
+    mapleLiquidityPositionLib: new MapleLiquidityPositionLib(fixture.MapleLiquidityPositionLib.address, deployer),
+    mapleLiquidityPositionParser: new MapleLiquidityPositionParser(fixture.MapleLiquidityPositionParser.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),
+    sharesSplitterFactory: new SharesSplitterFactory(fixture.SharesSplitterFactory.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)
+  };
+  return {
+    accounts,
+    config,
+    deployer,
+    deployment
+  };
+}
+
+// src/gasRelayer.ts
+import { createSignedRelayRequest, IGsnRelayHub, isTypedDataSigner } from "@enzymefinance/protocol";
+import { BigNumber as BigNumber2, utils as utils2 } from "ethers";
+async function relayTransaction(options) {
+  const signer = options.sendFunction.contract.signer;
+  if (!(signer && isTypedDataSigner(signer))) {
+    throw new Error("Missing or invalid signer");
+  }
+  const { relayData, relayRequest, signedRelayRequest } = await createSignedRelayRequest(options);
+  const defaultGasLimit = 1245e4;
+  const defaultMaxAcceptance = BigNumber2.from(15e4);
+  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();
+}
+var relayed = utils2.EventFragment.fromString("TransactionRelayed(address indexed relayManager, address indexed relayWorker, address indexed from, address to, address paymaster, bytes4 selector, uint8 status, uint256 charge)");
+var rejected = utils2.EventFragment.fromString("TransactionRejectedByPaymaster(address indexed relayManager, address indexed paymaster, address indexed from, address to, address relayWorker, bytes4 selector, uint256 innerGasUsed, bytes reason)");
+function assertDidRelay(receipt) {
+  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)
+  });
+}
+function assertDidRelaySuccessfully(receipt) {
+  const result = assertDidRelay(receipt);
+  expect(result.status).toEqBigNumber(0);
+}
+function assertDidRelayWithError(receipt) {
+  const result = assertDidRelay(receipt);
+  expect(result.status).toEqBigNumber(1);
+}
+function assertDidRelayWithCharge(receipt, amount, tolerance) {
+  const result = assertDidRelay(receipt);
+  expect(result.charge).toBeAroundBigNumber(amount, tolerance);
+}
+function assertPaymasterDidReject(receipt) {
+  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)
+  });
+}
+function assertPaymasterDidRejectForReason(receipt, reason) {
+  const params = assertPaymasterDidReject(receipt);
+  expect(utils2.toUtf8String(`0x${params.reason.substr(138)}`)).toMatch(reason);
+}
+
+// src/scaffolding/extensions/integrations/trackedAssets.ts
+import {
+  addTrackedAssetsToVaultArgs,
+  IntegrationManagerActionId,
+  removeTrackedAssetsFromVaultArgs
+} from "@enzymefinance/protocol";
+function addTrackedAssetsToVault({
+  signer,
+  comptrollerProxy,
+  integrationManager,
+  assets
+}) {
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, IntegrationManagerActionId.AddTrackedAssetsToVault, addTrackedAssetsToVaultArgs({ assets }));
+}
+function removeTrackedAssetsFromVault({
+  signer,
+  comptrollerProxy,
+  integrationManager,
+  assets
+}) {
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, IntegrationManagerActionId.RemoveTrackedAssetsFromVault, removeTrackedAssetsFromVaultArgs({ assets }));
+}
+
+// src/scaffolding/assets.ts
+async function addNewAssetsToFund({
+  signer,
+  comptrollerProxy,
+  integrationManager,
+  assets,
+  amounts = new Array(assets.length).fill(1)
+}) {
+  const receipt = addTrackedAssetsToVault({
+    assets,
+    comptrollerProxy,
+    integrationManager,
+    signer
+  });
+  const vaultProxy = await comptrollerProxy.getVaultProxy();
+  for (const i in assets) {
+    if (amounts[i] > 0) {
+      await assets[i].transfer(vaultProxy, amounts[i]);
+    }
+  }
+  return receipt;
+}
+
+// src/scaffolding/chainlink.ts
+async function updateChainlinkAggregator(aggregator, price) {
+  const answer = price != null ? price : await aggregator.latestAnswer();
+  const block = await aggregator.provider.getBlock("latest");
+  await aggregator.setLatestAnswer(answer, block.timestamp);
+}
+
+// src/scaffolding/common.ts
+import { StandardToken } from "@enzymefinance/protocol";
+import { utils as utils3 } from "ethers";
+async function getAssetBalances({ account, assets }) {
+  return Promise.all(assets.map((asset) => new StandardToken(asset, provider).balanceOf(account)));
+}
+async function getAssetUnit(asset) {
+  return utils3.parseUnits("1", await asset.decimals());
+}
+
+// src/scaffolding/core.ts
+import {
+  ComptrollerLib as ComptrollerLib2,
+  ExternalPositionManager as ExternalPositionManager2,
+  FeeManager as FeeManager2,
+  FundDeployer as FundDeployer2,
+  IntegrationManager as IntegrationManager2,
+  PolicyManager as PolicyManager2,
+  ProtocolFeeTracker as ProtocolFeeTracker2,
+  VaultLib as VaultLib2
+} from "@enzymefinance/protocol";
+async function createFundDeployer({
+  deployer,
+  externalPositionManager,
+  dispatcher,
+  gasRelayPaymasterFactory,
+  valueInterpreter,
+  vaultLib,
+  setOnDispatcher = true,
+  setReleaseLive = true
+}) {
+  const mlnToken = await vaultLib.getMlnToken();
+  const wethToken = await vaultLib.getWethToken();
+  const protocolFeeReserve = await vaultLib.getProtocolFeeReserve();
+  const nextFundDeployer = await FundDeployer2.deploy(deployer, dispatcher, gasRelayPaymasterFactory);
+  const nextPolicyManager = await PolicyManager2.deploy(deployer, nextFundDeployer, gasRelayPaymasterFactory);
+  const nextExternalPositionManager = await ExternalPositionManager2.deploy(deployer, nextFundDeployer, await externalPositionManager.getExternalPositionFactory(), nextPolicyManager);
+  const nextFeeManager = await FeeManager2.deploy(deployer, nextFundDeployer);
+  const nextIntegrationManager = await IntegrationManager2.deploy(deployer, nextFundDeployer, nextPolicyManager, valueInterpreter);
+  const nextComptrollerLib = await ComptrollerLib2.deploy(deployer, dispatcher, protocolFeeReserve, nextFundDeployer, valueInterpreter, nextExternalPositionManager, nextFeeManager, nextIntegrationManager, nextPolicyManager, gasRelayPaymasterFactory, mlnToken, wethToken);
+  await nextFundDeployer.setComptrollerLib(nextComptrollerLib);
+  const nextProtocolFeeTracker = await ProtocolFeeTracker2.deploy(deployer, nextFundDeployer);
+  await nextFundDeployer.setProtocolFeeTracker(nextProtocolFeeTracker);
+  const nextVaultLib = await VaultLib2.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;
+}
+
+// src/scaffolding/extensions/common.ts
+async function callOnExtension({
+  comptrollerProxy,
+  extension,
+  actionId,
+  callArgs = "0x",
+  signer
+}) {
+  let callOnExtensionTx;
+  if (signer) {
+    callOnExtensionTx = comptrollerProxy.connect(signer).callOnExtension(extension, actionId, callArgs);
+  } else {
+    callOnExtensionTx = comptrollerProxy.callOnExtension(extension, actionId, callArgs);
+  }
+  await expect(callOnExtensionTx).resolves.toBeReceipt();
+  return callOnExtensionTx;
+}
+
+// src/scaffolding/extensions/external-positions/aave-debt.ts
+import {
+  AaveDebtPositionActionId,
+  aaveDebtPositionAddCollateralArgs,
+  aaveDebtPositionBorrowArgs,
+  aaveDebtPositionClaimRewardsArgs,
+  aaveDebtPositionRemoveCollateralArgs,
+  aaveDebtPositionRepayBorrowArgs,
+  ExternalPositionType
+} from "@enzymefinance/protocol";
+
+// src/scaffolding/extensions/external-positions/actions.ts
+import { extractEvent as extractEvent2 } from "@enzymefinance/ethers";
+import {
+  callOnExternalPositionArgs,
+  encodeArgs,
+  ExternalPositionManagerActionId,
+  externalPositionReactivateArgs,
+  externalPositionRemoveArgs,
+  IExternalPositionProxy
+} from "@enzymefinance/protocol";
+async function callOnExternalPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  actionId,
+  actionArgs
+}) {
+  const callArgs = callOnExternalPositionArgs({
+    actionArgs,
+    actionId,
+    externalPositionProxy
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, ExternalPositionManagerActionId.CallOnExternalPosition, callArgs);
+}
+async function createExternalPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionTypeId,
+  initializationData = "0x",
+  callOnExternalPositionData = "0x"
+}) {
+  const receipt = await comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, ExternalPositionManagerActionId.CreateExternalPosition, encodeArgs(["uint256", "bytes", "bytes"], [externalPositionTypeId, initializationData, callOnExternalPositionData]));
+  const event = extractEvent2(receipt, externalPositionManager.abi.getEvent("ExternalPositionDeployedForFund"));
+  const externalPositionProxy = new IExternalPositionProxy(event[0].args.externalPosition, signer);
+  return { externalPositionProxy, receipt };
+}
+async function reactivateExternalPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy
+}) {
+  const callArgs = externalPositionReactivateArgs({ externalPositionProxy });
+  return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, ExternalPositionManagerActionId.ReactivateExternalPosition, callArgs);
+}
+async function removeExternalPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy
+}) {
+  const callArgs = externalPositionRemoveArgs({ externalPositionProxy });
+  return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, ExternalPositionManagerActionId.RemoveExternalPosition, callArgs);
+}
+
+// src/scaffolding/extensions/external-positions/aave-debt.ts
+async function aaveDebtPositionAddCollateral({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  aTokens,
+  amounts,
+  externalPositionProxy
+}) {
+  const actionArgs = aaveDebtPositionAddCollateralArgs({
+    aTokens,
+    amounts
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: AaveDebtPositionActionId.AddCollateralAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function aaveDebtPositionBorrow({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  tokens,
+  amounts,
+  externalPositionProxy
+}) {
+  const actionArgs = aaveDebtPositionBorrowArgs({
+    amounts,
+    tokens
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: AaveDebtPositionActionId.BorrowAsset,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function aaveDebtPositionClaimRewards({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  assets,
+  externalPositionProxy
+}) {
+  const actionArgs = aaveDebtPositionClaimRewardsArgs({
+    assets
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: AaveDebtPositionActionId.ClaimRewards,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function aaveDebtPositionRemoveCollateral({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  aTokens,
+  amounts,
+  externalPositionProxy
+}) {
+  const actionArgs = aaveDebtPositionRemoveCollateralArgs({
+    aTokens,
+    amounts
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: AaveDebtPositionActionId.RemoveCollateralAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function aaveDebtPositionRepayBorrow({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  tokens,
+  amounts,
+  externalPositionProxy
+}) {
+  const actionArgs = aaveDebtPositionRepayBorrowArgs({
+    amounts,
+    tokens
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: AaveDebtPositionActionId.RepayBorrowedAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function createAaveDebtPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager
+}) {
+  return createExternalPosition({
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: ExternalPositionType.AaveDebtPosition,
+    signer
+  });
+}
+
+// src/scaffolding/extensions/external-positions/compound.ts
+import {
+  CompoundDebtPositionActionId,
+  compoundExternalPositionActionArgs,
+  encodeArgs as encodeArgs2,
+  ExternalPositionType as ExternalPositionType2
+} from "@enzymefinance/protocol";
+async function compoundDebtPositionAddCollateral({
+  comptrollerProxy,
+  externalPositionManager,
+  fundOwner,
+  assets,
+  amounts,
+  externalPositionProxy,
+  cTokens
+}) {
+  const actionArgs = compoundExternalPositionActionArgs({
+    amounts,
+    assets,
+    data: encodeArgs2(["address[]"], [cTokens])
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: CompoundDebtPositionActionId.AddCollateralAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer: fundOwner
+  });
+}
+async function compoundDebtPositionBorrow({
+  comptrollerProxy,
+  externalPositionManager,
+  fundOwner,
+  externalPositionProxy,
+  assets,
+  amounts,
+  cTokens
+}) {
+  const actionArgs = compoundExternalPositionActionArgs({
+    amounts,
+    assets,
+    data: encodeArgs2(["address[]"], [cTokens])
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: CompoundDebtPositionActionId.BorrowAsset,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer: fundOwner
+  });
+}
+async function compoundDebtPositionClaimComp({
+  comptrollerProxy,
+  externalPositionManager,
+  fundOwner,
+  externalPositionProxy
+}) {
+  const actionArgs = compoundExternalPositionActionArgs({
+    amounts: [],
+    assets: [],
+    data: "0x"
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: CompoundDebtPositionActionId.ClaimComp,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer: fundOwner
+  });
+}
+async function compoundDebtPositionRemoveCollateral({
+  comptrollerProxy,
+  externalPositionManager,
+  fundOwner,
+  assets,
+  amounts,
+  externalPositionProxy,
+  cTokens
+}) {
+  const actionArgs = compoundExternalPositionActionArgs({
+    amounts,
+    assets,
+    data: encodeArgs2(["address[]"], [cTokens])
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: CompoundDebtPositionActionId.RemoveCollateralAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer: fundOwner
+  });
+}
+async function compoundDebtPositionRepayBorrow({
+  comptrollerProxy,
+  externalPositionManager,
+  fundOwner,
+  assets,
+  amounts,
+  externalPositionProxy,
+  cTokens
+}) {
+  const actionArgs = compoundExternalPositionActionArgs({
+    amounts,
+    assets,
+    data: encodeArgs2(["address[]"], [cTokens])
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: CompoundDebtPositionActionId.RepayBorrowedAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer: fundOwner
+  });
+}
+async function createCompoundDebtPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager
+}) {
+  return createExternalPosition({
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: ExternalPositionType2.CompoundDebtPosition,
+    signer
+  });
+}
+
+// src/scaffolding/extensions/external-positions/convex-voting.ts
+import {
+  ConvexVotingPositionActionId,
+  convexVotingPositionClaimRewardsArgs,
+  convexVotingPositionDelegateArgs,
+  convexVotingPositionLockArgs,
+  ExternalPositionType as ExternalPositionType3
+} from "@enzymefinance/protocol";
+import { BigNumber as BigNumber3 } from "ethers";
+function createConvexVotingPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager
+}) {
+  return createExternalPosition({
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: ExternalPositionType3.ConvexVotingPosition,
+    signer
+  });
+}
+function convexVotingPositionClaimRewards({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  externalPositionProxy,
+  claimLockerRewards,
+  extraRewardTokens,
+  votiumClaims,
+  unstakeCvxCrv,
+  allTokensToTransfer
+}) {
+  const actionArgs = convexVotingPositionClaimRewardsArgs({
+    allTokensToTransfer,
+    claimLockerRewards,
+    extraRewardTokens,
+    unstakeCvxCrv,
+    votiumClaims
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: ConvexVotingPositionActionId.ClaimRewards,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+function convexVotingPositionDelegate({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  externalPositionProxy,
+  delegatee
+}) {
+  const actionArgs = convexVotingPositionDelegateArgs({
+    delegatee
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: ConvexVotingPositionActionId.Delegate,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+function convexVotingPositionLock({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  externalPositionProxy,
+  amount,
+  spendRatio = BigNumber3.from(0)
+}) {
+  const actionArgs = convexVotingPositionLockArgs({
+    amount,
+    spendRatio
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: ConvexVotingPositionActionId.Lock,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+function convexVotingPositionRelock({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  externalPositionProxy
+}) {
+  return callOnExternalPosition({
+    actionArgs: "0x",
+    actionId: ConvexVotingPositionActionId.Relock,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+function convexVotingPositionWithdraw({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  externalPositionProxy
+}) {
+  return callOnExternalPosition({
+    actionArgs: "0x",
+    actionId: ConvexVotingPositionActionId.Withdraw,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+
+// src/scaffolding/extensions/external-positions/liquity-debt.ts
+import { contract } from "@enzymefinance/ethers";
+import {
+  ExternalPositionType as ExternalPositionType4,
+  LiquityDebtPositionActionId,
+  liquityDebtPositionAddCollateralArgs,
+  liquityDebtPositionBorrowArgs,
+  liquityDebtPositionOpenTroveArgs,
+  liquityDebtPositionRemoveCollateralArgs,
+  liquityDebtPositionRepayBorrowArgs
+} from "@enzymefinance/protocol";
+import { BigNumber as BigNumber4, utils as utils4 } from "ethers";
+var ILiquityTroveManager = contract()`
+  function getBorrowingFee(uint256) external returns (uint256)
+`;
+var ILiquityHintHelper = contract()`
+  function getApproxHint(uint256, uint256, uint256) external returns (address, uint256, uint256)
+`;
+var ILiquitySortedTroves = contract()`
+  function findInsertPosition(uint256, address, address) external view returns (address, address)
+`;
+async function createLiquityDebtPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager
+}) {
+  return createExternalPosition({
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: ExternalPositionType4.LiquityDebtPosition,
+    signer
+  });
+}
+async function liquityCalcHints({
+  collateralAmount,
+  debtAmount,
+  numTrials = BigNumber4.from("100"),
+  liquitySortedTroves,
+  liquityHintHelper,
+  inputRandomSeed = BigNumber4.from("4")
+}) {
+  const nicr = collateralAmount.mul(utils4.parseEther("100")).div(debtAmount);
+  const approxHint = await liquityHintHelper.getApproxHint.args(nicr, numTrials, inputRandomSeed).call();
+  const [upperHint, lowerHint] = await liquitySortedTroves.findInsertPosition.args(nicr, approxHint[0], approxHint[0]).call();
+  return { lowerHint, upperHint };
+}
+async function liquityDebtPositionAddCollateral({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  collateralAmount,
+  upperHint,
+  lowerHint,
+  externalPositionProxy
+}) {
+  const actionArgs = liquityDebtPositionAddCollateralArgs({
+    collateralAmount,
+    lowerHint,
+    upperHint
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: LiquityDebtPositionActionId.AddCollateral,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function liquityDebtPositionBorrow({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  maxFeePercentage,
+  lusdAmount,
+  upperHint,
+  lowerHint,
+  externalPositionProxy
+}) {
+  const actionArgs = liquityDebtPositionBorrowArgs({
+    lowerHint,
+    lusdAmount,
+    maxFeePercentage,
+    upperHint
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: LiquityDebtPositionActionId.Borrow,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function liquityDebtPositionCloseTrove({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  externalPositionProxy
+}) {
+  const actionArgs = "0x";
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: LiquityDebtPositionActionId.CloseTrove,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function liquityDebtPositionOpenTrove({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  maxFeePercentage,
+  collateralAmount,
+  lusdAmount,
+  upperHint,
+  lowerHint,
+  externalPositionProxy
+}) {
+  const actionArgs = liquityDebtPositionOpenTroveArgs({
+    collateralAmount,
+    lowerHint,
+    lusdAmount,
+    maxFeePercentage,
+    upperHint
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: LiquityDebtPositionActionId.OpenTrove,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function liquityDebtPositionRemoveCollateral({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  collateralAmount,
+  upperHint,
+  lowerHint,
+  externalPositionProxy
+}) {
+  const actionArgs = liquityDebtPositionRemoveCollateralArgs({
+    collateralAmount,
+    lowerHint,
+    upperHint
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: LiquityDebtPositionActionId.RemoveCollateral,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function liquityDebtPositionRepay({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  lusdAmount,
+  upperHint,
+  lowerHint,
+  externalPositionProxy
+}) {
+  const actionArgs = liquityDebtPositionRepayBorrowArgs({
+    lowerHint,
+    lusdAmount,
+    upperHint
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: LiquityDebtPositionActionId.Repay,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+
+// src/scaffolding/extensions/external-positions/maple-liquidity.ts
+import {
+  ExternalPositionType as ExternalPositionType5,
+  MapleLiquidityPositionActionId,
+  mapleLiquidityPositionClaimInterestArgs,
+  mapleLiquidityPositionClaimRewardsArgs,
+  mapleLiquidityPositionIntendToRedeemArgs,
+  mapleLiquidityPositionLendAndStakeArgs,
+  mapleLiquidityPositionLendArgs,
+  mapleLiquidityPositionRedeemArgs,
+  mapleLiquidityPositionStakeArgs,
+  mapleLiquidityPositionUnstakeAndRedeemArgs,
+  mapleLiquidityPositionUnstakeArgs
+} from "@enzymefinance/protocol";
+async function createMapleLiquidityPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager
+}) {
+  return createExternalPosition({
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: ExternalPositionType5.MapleLiquidityPosition,
+    signer
+  });
+}
+async function mapleLiquidityPositionClaimInterest({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  pool,
+  externalPositionProxy
+}) {
+  const actionArgs = mapleLiquidityPositionClaimInterestArgs({
+    pool
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: MapleLiquidityPositionActionId.ClaimInterest,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionClaimRewards({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  rewardsContract,
+  externalPositionProxy
+}) {
+  const actionArgs = mapleLiquidityPositionClaimRewardsArgs({
+    rewardsContract
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: MapleLiquidityPositionActionId.ClaimRewards,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionIntendToRedeem({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  pool,
+  externalPositionProxy
+}) {
+  const actionArgs = mapleLiquidityPositionIntendToRedeemArgs({
+    pool
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: MapleLiquidityPositionActionId.IntendToRedeem,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionLend({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  liquidityAssetAmount,
+  pool,
+  externalPositionProxy
+}) {
+  const actionArgs = mapleLiquidityPositionLendArgs({
+    liquidityAssetAmount,
+    pool
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: MapleLiquidityPositionActionId.Lend,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionLendAndStake({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  liquidityAssetAmount,
+  pool,
+  rewardsContract,
+  externalPositionProxy
+}) {
+  const actionArgs = mapleLiquidityPositionLendAndStakeArgs({
+    liquidityAssetAmount,
+    pool,
+    rewardsContract
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: MapleLiquidityPositionActionId.LendAndStake,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionRedeem({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  liquidityAssetAmount,
+  pool,
+  externalPositionProxy
+}) {
+  const actionArgs = mapleLiquidityPositionRedeemArgs({
+    liquidityAssetAmount,
+    pool
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: MapleLiquidityPositionActionId.Redeem,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionStake({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  poolTokenAmount,
+  pool,
+  rewardsContract,
+  externalPositionProxy
+}) {
+  const actionArgs = mapleLiquidityPositionStakeArgs({
+    pool,
+    poolTokenAmount,
+    rewardsContract
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: MapleLiquidityPositionActionId.Stake,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionUnstake({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  poolTokenAmount,
+  rewardsContract,
+  externalPositionProxy
+}) {
+  const actionArgs = mapleLiquidityPositionUnstakeArgs({
+    poolTokenAmount,
+    rewardsContract
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: MapleLiquidityPositionActionId.Unstake,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionUnstakeAndRedeem({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  pool,
+  poolTokenAmount,
+  rewardsContract,
+  externalPositionProxy
+}) {
+  const actionArgs = mapleLiquidityPositionUnstakeAndRedeemArgs({
+    pool,
+    poolTokenAmount,
+    rewardsContract
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: MapleLiquidityPositionActionId.UnstakeAndRedeem,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+
+// src/scaffolding/extensions/external-positions/mocks.ts
+import {
+  mockGenericExternalPositionActionArgs,
+  MockGenericExternalPositionActionId,
+  MockGenericExternalPositionLib,
+  MockGenericExternalPositionParser,
+  VaultLib as VaultLib3
+} from "@enzymefinance/protocol";
+async function createMockExternalPosition({
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionFactory,
+  defaultActionAssetsToTransfer,
+  defaultActionAmountsToTransfer,
+  defaultActionAssetsToReceive,
+  fundOwner,
+  deployer
+}) {
+  const vaultProxy = new VaultLib3(await comptrollerProxy.getVaultProxy(), deployer);
+  const typeId = await externalPositionFactory.getPositionTypeCounter();
+  await externalPositionFactory.addNewPositionTypes(["TEST"]);
+  const mockGenericExternalPositionLib = await MockGenericExternalPositionLib.deploy(deployer);
+  const mockExternalPositionParser = await MockGenericExternalPositionParser.deploy(deployer);
+  mockExternalPositionParser.setAssetsForAction(0, defaultActionAssetsToTransfer, defaultActionAmountsToTransfer, defaultActionAssetsToReceive);
+  await externalPositionManager.updateExternalPositionTypesInfo([typeId], [mockGenericExternalPositionLib], [mockExternalPositionParser]);
+  const receipt = await createExternalPosition({
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: typeId,
+    signer: fundOwner
+  });
+  const externalPositionProxy = (await vaultProxy.getActiveExternalPositions())[0];
+  return {
+    externalPositionProxy,
+    mockExternalPositionParser,
+    mockGenericExternalPositionLib,
+    receipt,
+    typeId
+  };
+}
+async function mockExternalPositionAddDebtAssets({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  assets,
+  amounts
+}) {
+  const actionArgs = mockGenericExternalPositionActionArgs({
+    amounts,
+    assets
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: MockGenericExternalPositionActionId.AddDebtAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mockExternalPositionAddManagedAssets({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  assets,
+  amounts
+}) {
+  const actionArgs = mockGenericExternalPositionActionArgs({
+    amounts,
+    assets
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: MockGenericExternalPositionActionId.AddManagedAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mockExternalPositionRemoveDebtAssets({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  assets,
+  amounts
+}) {
+  const actionArgs = mockGenericExternalPositionActionArgs({
+    amounts,
+    assets
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: MockGenericExternalPositionActionId.RemoveDebtAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mockExternalPositionRemoveManagedAssets({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  assets,
+  amounts
+}) {
+  const actionArgs = mockGenericExternalPositionActionArgs({
+    amounts,
+    assets
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: MockGenericExternalPositionActionId.RemoveManagedAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+
+// src/scaffolding/extensions/external-positions/the-graph-delegation.ts
+import {
+  ExternalPositionType as ExternalPositionType6,
+  TheGraphDelegationPositionActionId,
+  theGraphDelegationPositionDelegateArgs,
+  theGraphDelegationPositionUndelegateArgs,
+  theGraphDelegationPositionWithdrawArgs
+} from "@enzymefinance/protocol";
+async function theGraphDelegationPositionDelegate({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  indexer,
+  tokens,
+  externalPositionProxy
+}) {
+  const actionArgs = theGraphDelegationPositionDelegateArgs({
+    indexer,
+    tokens
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: TheGraphDelegationPositionActionId.Delegate,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function theGraphDelegationPositionUndelegate({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  indexer,
+  shares,
+  externalPositionProxy
+}) {
+  const actionArgs = theGraphDelegationPositionUndelegateArgs({
+    indexer,
+    shares
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: TheGraphDelegationPositionActionId.Undelegate,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function theGraphDelegationPositionWithdraw({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  indexer,
+  nextIndexer,
+  externalPositionProxy
+}) {
+  const actionArgs = theGraphDelegationPositionWithdrawArgs({
+    indexer,
+    nextIndexer
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: TheGraphDelegationPositionActionId.Withdraw,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function createTheGraphDelegationPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager
+}) {
+  return createExternalPosition({
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: ExternalPositionType6.TheGraphDelegationPosition,
+    signer
+  });
+}
+
+// src/scaffolding/extensions/external-positions/uniswap-v3-liquidity.ts
+import { contract as contract2, extractEvent as extractEvent3, resolveAddress as resolveAddress2 } from "@enzymefinance/ethers";
+import {
+  callOnExternalPositionArgs as callOnExternalPositionArgs2,
+  ExternalPositionManagerActionId as ExternalPositionManagerActionId2,
+  ExternalPositionType as ExternalPositionType7,
+  UniswapV3LiquidityPositionActionId,
+  uniswapV3LiquidityPositionAddLiquidityArgs,
+  uniswapV3LiquidityPositionCollectArgs,
+  UniswapV3LiquidityPositionLib,
+  uniswapV3LiquidityPositionMintArgs,
+  uniswapV3LiquidityPositionPurgeArgs,
+  uniswapV3LiquidityPositionRemoveLiquidityArgs
+} from "@enzymefinance/protocol";
+var UniswapV3FeeAmount = /* @__PURE__ */ ((UniswapV3FeeAmount2) => {
+  UniswapV3FeeAmount2[UniswapV3FeeAmount2["LOW"] = 500] = "LOW";
+  UniswapV3FeeAmount2[UniswapV3FeeAmount2["MEDIUM"] = 3e3] = "MEDIUM";
+  UniswapV3FeeAmount2[UniswapV3FeeAmount2["HIGH"] = 1e4] = "HIGH";
+  return UniswapV3FeeAmount2;
+})(UniswapV3FeeAmount || {});
+var uniswapV3LiquidityPositionGetMinTick = (tickSpacing) => Math.ceil(-887272 / tickSpacing) * tickSpacing;
+var uniswapV3LiquidityPositionGetMaxTick = (tickSpacing) => Math.floor(887272 / tickSpacing) * tickSpacing;
+var IUniswapV3NonFungibleTokenManager = contract2()`
+  function positions(uint256 tokenId) view returns (uint96 nonce, address operator, address token0, address token1, uint24 fee, int24 tickLower, int24 tickUpper, uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, uint128 tokensOwed0, uint128 tokensOwed1)
+`;
+async function createUniswapV3LiquidityPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  callOnExternalPositionData = "0x"
+}) {
+  const { externalPositionProxy: externalPositionProxyContract, receipt } = await createExternalPosition({
+    callOnExternalPositionData,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: ExternalPositionType7.UniswapV3LiquidityPosition,
+    signer
+  });
+  return { externalPositionProxyAddress: externalPositionProxyContract.address, receipt };
+}
+async function uniswapV3LiquidityPositionAddLiquidity({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  nftId,
+  amount0Desired,
+  amount1Desired,
+  amount0Min = 0,
+  amount1Min = 0
+}) {
+  const actionArgs = uniswapV3LiquidityPositionAddLiquidityArgs({
+    amount0Desired,
+    amount0Min,
+    amount1Desired,
+    amount1Min,
+    nftId
+  });
+  const callArgs = callOnExternalPositionArgs2({
+    actionArgs,
+    actionId: UniswapV3LiquidityPositionActionId.AddLiquidity,
+    externalPositionProxy
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, ExternalPositionManagerActionId2.CallOnExternalPosition, callArgs);
+}
+async function uniswapV3LiquidityPositionCollect({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  nftId
+}) {
+  const actionArgs = uniswapV3LiquidityPositionCollectArgs({
+    nftId
+  });
+  const callArgs = callOnExternalPositionArgs2({
+    actionArgs,
+    actionId: UniswapV3LiquidityPositionActionId.Collect,
+    externalPositionProxy
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, ExternalPositionManagerActionId2.CallOnExternalPosition, callArgs);
+}
+async function uniswapV3LiquidityPositionMint({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  token0,
+  token1,
+  fee,
+  tickLower,
+  tickUpper,
+  amount0Desired,
+  amount1Desired,
+  amount0Min = 0,
+  amount1Min = 0
+}) {
+  const actionArgs = uniswapV3LiquidityPositionMintArgs({
+    amount0Desired,
+    amount0Min,
+    amount1Desired,
+    amount1Min,
+    fee,
+    tickLower,
+    tickUpper,
+    token0,
+    token1
+  });
+  const callArgs = callOnExternalPositionArgs2({
+    actionArgs,
+    actionId: UniswapV3LiquidityPositionActionId.Mint,
+    externalPositionProxy
+  });
+  const receipt = await comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, ExternalPositionManagerActionId2.CallOnExternalPosition, callArgs);
+  const externalPosition = new UniswapV3LiquidityPositionLib(externalPositionProxy, provider);
+  const nftId = extractEvent3(receipt, externalPosition.abi.getEvent("NFTPositionAdded"))[0].args.tokenId;
+  return { nftId, receipt };
+}
+async function uniswapV3LiquidityPositionPurge({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  nftId,
+  liquidity,
+  amount0Min = 0,
+  amount1Min = 0
+}) {
+  const actionArgs = uniswapV3LiquidityPositionPurgeArgs({
+    amount0Min,
+    amount1Min,
+    liquidity,
+    nftId
+  });
+  const callArgs = callOnExternalPositionArgs2({
+    actionArgs,
+    actionId: UniswapV3LiquidityPositionActionId.Purge,
+    externalPositionProxy
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, ExternalPositionManagerActionId2.CallOnExternalPosition, callArgs);
+}
+async function uniswapV3LiquidityPositionRemoveLiquidity({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  nftId,
+  liquidity,
+  amount0Min = 0,
+  amount1Min = 0
+}) {
+  const actionArgs = uniswapV3LiquidityPositionRemoveLiquidityArgs({
+    amount0Min,
+    amount1Min,
+    liquidity,
+    nftId
+  });
+  const callArgs = callOnExternalPositionArgs2({
+    actionArgs,
+    actionId: UniswapV3LiquidityPositionActionId.RemoveLiquidity,
+    externalPositionProxy
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, ExternalPositionManagerActionId2.CallOnExternalPosition, callArgs);
+}
+function uniswapV3OrderTokenPair({ tokenA, tokenB }) {
+  const tokenAAddress = resolveAddress2(tokenA);
+  const tokenBAddress = resolveAddress2(tokenB);
+  return tokenAAddress < tokenBAddress ? { token0: tokenAAddress, token1: tokenBAddress } : { token0: tokenBAddress, token1: tokenAAddress };
+}
+
+// src/scaffolding/extensions/fees.ts
+import { FeeHook, feeManagerConfigArgs, FeeSettlementType, IFee } from "@enzymefinance/protocol";
+import { constants, utils as utils5 } from "ethers";
+async function generateFeeManagerConfigWithMockFees({ deployer }) {
+  const fees = await generateMockFees({
+    deployer
+  });
+  const feeManagerSettingsData = [utils5.randomBytes(10), "0x", utils5.randomBytes(2)];
+  return feeManagerConfigArgs({
+    fees: Object.values(fees),
+    settings: feeManagerSettingsData
+  });
+}
+async function generateMockFees({ deployer }) {
+  const mockContinuousFeeSettleOnly = await IFee.mock(deployer);
+  const mockContinuousFeeWithGavAndUpdates = await IFee.mock(deployer);
+  const mockPostBuySharesFee = await IFee.mock(deployer);
+  await Promise.all([
+    mockContinuousFeeSettleOnly.getRecipientForFund.returns(constants.AddressZero),
+    mockContinuousFeeSettleOnly.settle.returns(FeeSettlementType.None, constants.AddressZero, 0),
+    mockContinuousFeeSettleOnly.payout.returns(false),
+    mockContinuousFeeSettleOnly.addFundSettings.returns(void 0),
+    mockContinuousFeeSettleOnly.activateForFund.returns(void 0),
+    mockContinuousFeeSettleOnly.update.returns(void 0),
+    mockContinuousFeeSettleOnly.settlesOnHook.returns(false, false),
+    mockContinuousFeeSettleOnly.settlesOnHook.given(FeeHook.Continuous).returns(true, false),
+    mockContinuousFeeSettleOnly.settlesOnHook.given(FeeHook.PreBuyShares).returns(true, false),
+    mockContinuousFeeSettleOnly.settlesOnHook.given(FeeHook.PreRedeemShares).returns(true, false),
+    mockContinuousFeeSettleOnly.updatesOnHook.returns(false, false),
+    mockContinuousFeeWithGavAndUpdates.getRecipientForFund.returns(constants.AddressZero),
+    mockContinuousFeeWithGavAndUpdates.settle.returns(FeeSettlementType.None, constants.AddressZero, 0),
+    mockContinuousFeeWithGavAndUpdates.payout.returns(false),
+    mockContinuousFeeWithGavAndUpdates.addFundSettings.returns(void 0),
+    mockContinuousFeeWithGavAndUpdates.activateForFund.returns(void 0),
+    mockContinuousFeeWithGavAndUpdates.update.returns(void 0),
+    mockContinuousFeeWithGavAndUpdates.settlesOnHook.returns(false, false),
+    mockContinuousFeeWithGavAndUpdates.settlesOnHook.given(FeeHook.Continuous).returns(true, true),
+    mockContinuousFeeWithGavAndUpdates.settlesOnHook.given(FeeHook.PreBuyShares).returns(true, true),
+    mockContinuousFeeWithGavAndUpdates.settlesOnHook.given(FeeHook.PreRedeemShares).returns(true, true),
+    mockContinuousFeeWithGavAndUpdates.updatesOnHook.returns(false, false),
+    mockContinuousFeeWithGavAndUpdates.updatesOnHook.given(FeeHook.Continuous).returns(true, true),
+    mockContinuousFeeWithGavAndUpdates.updatesOnHook.given(FeeHook.PostBuyShares).returns(true, true),
+    mockContinuousFeeWithGavAndUpdates.updatesOnHook.given(FeeHook.PreRedeemShares).returns(true, true),
+    mockPostBuySharesFee.getRecipientForFund.returns(constants.AddressZero),
+    mockPostBuySharesFee.settle.returns(FeeSettlementType.None, constants.AddressZero, 0),
+    mockPostBuySharesFee.payout.returns(false),
+    mockPostBuySharesFee.addFundSettings.returns(void 0),
+    mockPostBuySharesFee.activateForFund.returns(void 0),
+    mockPostBuySharesFee.update.returns(void 0),
+    mockPostBuySharesFee.settlesOnHook.returns(false, false),
+    mockPostBuySharesFee.settlesOnHook.given(FeeHook.PostBuyShares).returns(true, false),
+    mockPostBuySharesFee.updatesOnHook.returns(false, false)
+  ]);
+  return {
+    mockContinuousFeeSettleOnly,
+    mockContinuousFeeWithGavAndUpdates,
+    mockPostBuySharesFee
+  };
+}
+
+// src/scaffolding/extensions/integrations/aave.ts
+import {
+  aaveLendArgs,
+  aaveRedeemArgs,
+  callOnIntegrationArgs,
+  IntegrationManagerActionId as IntegrationManagerActionId2,
+  lendSelector,
+  redeemSelector
+} from "@enzymefinance/protocol";
+import { utils as utils6 } from "ethers";
+async function aaveLend({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  aaveAdapter,
+  aToken,
+  amount = utils6.parseEther("1")
+}) {
+  const lendArgs = aaveLendArgs({
+    aToken,
+    amount
+  });
+  const callArgs = callOnIntegrationArgs({
+    adapter: aaveAdapter,
+    encodedCallArgs: lendArgs,
+    selector: lendSelector
+  });
+  const lendTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId2.CallOnIntegration, callArgs);
+  return lendTx;
+}
+async function aaveRedeem({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  aaveAdapter,
+  aToken,
+  amount = utils6.parseEther("1")
+}) {
+  const redeemArgs = aaveRedeemArgs({
+    aToken,
+    amount
+  });
+  const callArgs = callOnIntegrationArgs({
+    adapter: aaveAdapter,
+    encodedCallArgs: redeemArgs,
+    selector: redeemSelector
+  });
+  const redeemTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId2.CallOnIntegration, callArgs);
+  return redeemTx;
+}
+
+// src/scaffolding/extensions/integrations/compound.ts
+import { contract as contract3, resolveAddress as resolveAddress3 } from "@enzymefinance/ethers";
+import {
+  callOnIntegrationArgs as callOnIntegrationArgs2,
+  claimRewardsSelector,
+  compoundArgs,
+  compoundClaimRewardsArgs,
+  IntegrationManagerActionId as IntegrationManagerActionId3,
+  lendSelector as lendSelector2,
+  redeemSelector as redeemSelector2,
+  StandardToken as StandardToken2
+} from "@enzymefinance/protocol";
+import { BigNumber as BigNumber5, utils as utils7 } from "ethers";
+var ICompoundComptroller = contract3()`
+  function claimComp(address)
+`;
+async function assertCompoundLend({
+  tokenWhale,
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  fundOwner,
+  compoundAdapter,
+  tokenAmount = utils7.parseEther("1"),
+  cToken,
+  compoundPriceFeed
+}) {
+  const token = new StandardToken2(await compoundPriceFeed.getTokenFromCToken.args(cToken).call(), tokenWhale);
+  await token.connect(tokenWhale).transfer(vaultProxy, tokenAmount);
+  const rateBefore = await cToken.exchangeRateStored.call();
+  const minIncomingCTokenAmount = tokenAmount.mul(utils7.parseEther("1")).div(rateBefore).mul(BigNumber5.from("999")).div(BigNumber5.from("1000"));
+  const [preTxIncomingAssetBalance, preTxOutgoingAssetBalance] = await getAssetBalances({
+    account: vaultProxy,
+    assets: [cToken, token]
+  });
+  const lendReceipt = await compoundLend({
+    cToken,
+    cTokenAmount: minIncomingCTokenAmount,
+    compoundAdapter,
+    comptrollerProxy,
+    fundOwner,
+    integrationManager,
+    tokenAmount
+  });
+  const rate = await cToken.exchangeRateStored();
+  const [postTxIncomingAssetBalance, postTxOutgoingAssetBalance] = await getAssetBalances({
+    account: vaultProxy,
+    assets: [cToken, token]
+  });
+  const expectedCTokenAmount = tokenAmount.mul(utils7.parseEther("1")).div(rate);
+  expect(postTxIncomingAssetBalance).toEqBigNumber(preTxIncomingAssetBalance.add(expectedCTokenAmount));
+  expect(postTxOutgoingAssetBalance).toEqBigNumber(preTxOutgoingAssetBalance.sub(tokenAmount));
+  return lendReceipt;
+}
+async function assertCompoundRedeem({
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  fundOwner,
+  compoundAdapter,
+  cToken,
+  compoundPriceFeed
+}) {
+  const cTokenAmount = utils7.parseUnits("1", await cToken.decimals());
+  await cToken.transfer(vaultProxy, cTokenAmount);
+  const token = new StandardToken2(await compoundPriceFeed.getTokenFromCToken.args(cToken).call(), provider);
+  const [preTxIncomingAssetBalance, preTxOutgoingAssetBalance] = await getAssetBalances({
+    account: vaultProxy,
+    assets: [token, cToken]
+  });
+  const rateBefore = await cToken.exchangeRateStored();
+  const minIncomingTokenAmount = cTokenAmount.mul(rateBefore).div(utils7.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]
+  });
+  const rate = await cToken.exchangeRateStored();
+  const expectedTokenAmount = cTokenAmount.mul(rate).div(utils7.parseEther("1"));
+  expect(postTxIncomingAssetBalance).toEqBigNumber(preTxIncomingAssetBalance.add(expectedTokenAmount));
+  expect(postTxOutgoingAssetBalance).toEqBigNumber(preTxOutgoingAssetBalance.sub(cTokenAmount));
+  return redeemReceipt;
+}
+async function compoundClaim({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  compoundAdapter,
+  compoundComptroller,
+  cTokens
+}) {
+  const claimArgs = compoundClaimRewardsArgs({
+    cTokens,
+    compoundComptroller
+  });
+  const callArgs = callOnIntegrationArgs2({
+    adapter: compoundAdapter,
+    encodedCallArgs: claimArgs,
+    selector: claimRewardsSelector
+  });
+  const claimRewardsTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId3.CallOnIntegration, callArgs);
+  return claimRewardsTx;
+}
+async function compoundLend({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  compoundAdapter,
+  cToken,
+  tokenAmount = utils7.parseEther("1"),
+  cTokenAmount = utils7.parseEther("1")
+}) {
+  const lendArgs = compoundArgs({
+    cToken,
+    minIncomingAssetAmount: cTokenAmount,
+    outgoingAssetAmount: tokenAmount
+  });
+  const callArgs = callOnIntegrationArgs2({
+    adapter: compoundAdapter,
+    encodedCallArgs: lendArgs,
+    selector: lendSelector2
+  });
+  const lendTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId3.CallOnIntegration, callArgs);
+  return lendTx;
+}
+async function compoundRedeem({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  compoundAdapter,
+  cToken,
+  tokenAmount = utils7.parseEther("1"),
+  cTokenAmount = utils7.parseEther("1")
+}) {
+  const redeemArgs = compoundArgs({
+    cToken: resolveAddress3(cToken),
+    minIncomingAssetAmount: tokenAmount,
+    outgoingAssetAmount: cTokenAmount
+  });
+  const callArgs = callOnIntegrationArgs2({
+    adapter: compoundAdapter,
+    encodedCallArgs: redeemArgs,
+    selector: redeemSelector2
+  });
+  const redeemTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId3.CallOnIntegration, callArgs);
+  return redeemTx;
+}
+
+// src/scaffolding/extensions/integrations/curve.ts
+import { contract as contract4 } from "@enzymefinance/ethers";
+import {
+  callOnIntegrationArgs as callOnIntegrationArgs3,
+  claimRewardsSelector as claimRewardsSelector2,
+  curveClaimRewardsArgs,
+  curveLendAndStakeArgs,
+  curveLendArgs,
+  curveRedeemArgs,
+  curveStakeArgs,
+  curveTakeOrderArgs,
+  curveUnstakeAndRedeemArgs,
+  curveUnstakeArgs,
+  IntegrationManagerActionId as IntegrationManagerActionId4,
+  lendAndStakeSelector,
+  lendSelector as lendSelector3,
+  redeemSelector as redeemSelector3,
+  stakeSelector,
+  takeOrderSelector,
+  unstakeAndRedeemSelector,
+  unstakeSelector
+} from "@enzymefinance/protocol";
+import { BigNumber as BigNumber6, utils as utils8 } from "ethers";
+var CurveLiquidityGaugeV2 = contract4()`
+  function claim_rewards(address)
+  function integrate_fraction(address) view returns (uint256)
+`;
+var CurveRegistry = contract4()`
+  function get_coins(address) view returns (address[8])
+  function get_lp_token(address) view returns (address)
+`;
+var CurveSwaps = contract4()`
+  function get_best_rate(address _from, address to, uint256 amount) view returns (address bestPool, uint256 amountReceived)
+`;
+var CurveMinter = contract4()`
+  function mint_for(address,address)
+`;
+async function curveTakeOrder({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  curveExchangeAdapter,
+  pool,
+  outgoingAsset,
+  outgoingAssetAmount = utils8.parseEther("1"),
+  incomingAsset,
+  minIncomingAssetAmount = utils8.parseEther("1")
+}) {
+  const takeOrderArgs = curveTakeOrderArgs({
+    incomingAsset,
+    minIncomingAssetAmount,
+    outgoingAsset,
+    outgoingAssetAmount,
+    pool
+  });
+  const callArgs = callOnIntegrationArgs3({
+    adapter: curveExchangeAdapter,
+    encodedCallArgs: takeOrderArgs,
+    selector: takeOrderSelector
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId4.CallOnIntegration, callArgs);
+}
+function curveClaimRewards({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  curveLiquidityAdapter,
+  stakingToken
+}) {
+  const callArgs = callOnIntegrationArgs3({
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: curveClaimRewardsArgs({ stakingToken }),
+    selector: claimRewardsSelector2
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId4.CallOnIntegration, callArgs);
+}
+async function curveLend({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  orderedOutgoingAssetAmounts,
+  minIncomingLpTokenAmount = BigNumber6.from(1),
+  useUnderlyings
+}) {
+  const callArgs = callOnIntegrationArgs3({
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: curveLendArgs({
+      minIncomingLpTokenAmount,
+      orderedOutgoingAssetAmounts,
+      pool,
+      useUnderlyings
+    }),
+    selector: lendSelector3
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, IntegrationManagerActionId4.CallOnIntegration, callArgs);
+}
+async function curveLendAndStake({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  orderedOutgoingAssetAmounts,
+  incomingStakingToken,
+  minIncomingStakingTokenAmount = BigNumber6.from(1),
+  useUnderlyings
+}) {
+  const callArgs = callOnIntegrationArgs3({
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: curveLendAndStakeArgs({
+      incomingStakingToken,
+      minIncomingStakingTokenAmount,
+      orderedOutgoingAssetAmounts,
+      pool,
+      useUnderlyings
+    }),
+    selector: lendAndStakeSelector
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, IntegrationManagerActionId4.CallOnIntegration, callArgs);
+}
+async function curveRedeem({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  outgoingLpTokenAmount,
+  useUnderlyings,
+  redeemType,
+  incomingAssetData
+}) {
+  const callArgs = callOnIntegrationArgs3({
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: curveRedeemArgs({
+      incomingAssetData,
+      outgoingLpTokenAmount,
+      pool,
+      redeemType,
+      useUnderlyings
+    }),
+    selector: redeemSelector3
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, IntegrationManagerActionId4.CallOnIntegration, callArgs);
+}
+async function curveStake({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  incomingStakingToken,
+  amount
+}) {
+  const callArgs = callOnIntegrationArgs3({
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: curveStakeArgs({
+      amount,
+      incomingStakingToken,
+      pool
+    }),
+    selector: stakeSelector
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, IntegrationManagerActionId4.CallOnIntegration, callArgs);
+}
+async function curveUnstake({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  outgoingStakingToken,
+  amount
+}) {
+  const callArgs = callOnIntegrationArgs3({
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: curveUnstakeArgs({
+      amount,
+      outgoingStakingToken,
+      pool
+    }),
+    selector: unstakeSelector
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, IntegrationManagerActionId4.CallOnIntegration, callArgs);
+}
+async function curveUnstakeAndRedeem({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  outgoingStakingToken,
+  outgoingStakingTokenAmount,
+  useUnderlyings,
+  redeemType,
+  incomingAssetData
+}) {
+  const callArgs = callOnIntegrationArgs3({
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: curveUnstakeAndRedeemArgs({
+      incomingAssetData,
+      outgoingStakingToken,
+      outgoingStakingTokenAmount,
+      pool,
+      redeemType,
+      useUnderlyings
+    }),
+    selector: unstakeAndRedeemSelector
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, IntegrationManagerActionId4.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/integrations/idle.ts
+import {
+  callOnIntegrationArgs as callOnIntegrationArgs4,
+  claimRewardsSelector as claimRewardsSelector3,
+  idleClaimRewardsArgs,
+  idleLendArgs,
+  idleRedeemArgs,
+  IntegrationManagerActionId as IntegrationManagerActionId5,
+  lendSelector as lendSelector4,
+  redeemSelector as redeemSelector4
+} from "@enzymefinance/protocol";
+import { BigNumber as BigNumber7 } from "ethers";
+async function idleClaimRewards({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  idleAdapter,
+  idleToken
+}) {
+  const callArgs = callOnIntegrationArgs4({
+    adapter: idleAdapter,
+    encodedCallArgs: idleClaimRewardsArgs({
+      idleToken
+    }),
+    selector: claimRewardsSelector3
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId5.CallOnIntegration, callArgs);
+}
+async function idleLend({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  idleAdapter,
+  idleToken,
+  outgoingUnderlyingAmount,
+  minIncomingIdleTokenAmount = BigNumber7.from(1)
+}) {
+  const callArgs = callOnIntegrationArgs4({
+    adapter: idleAdapter,
+    encodedCallArgs: idleLendArgs({
+      idleToken,
+      minIncomingIdleTokenAmount,
+      outgoingUnderlyingAmount
+    }),
+    selector: lendSelector4
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId5.CallOnIntegration, callArgs);
+}
+async function idleRedeem({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  idleAdapter,
+  idleToken,
+  outgoingIdleTokenAmount,
+  minIncomingUnderlyingAmount = BigNumber7.from(1)
+}) {
+  const callArgs = callOnIntegrationArgs4({
+    adapter: idleAdapter,
+    encodedCallArgs: idleRedeemArgs({
+      idleToken,
+      minIncomingUnderlyingAmount,
+      outgoingIdleTokenAmount
+    }),
+    selector: redeemSelector4
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId5.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/integrations/mock.ts
+import { callOnIntegrationArgs as callOnIntegrationArgs5, encodeArgs as encodeArgs3, IntegrationManagerActionId as IntegrationManagerActionId6, sighash } from "@enzymefinance/protocol";
+import { utils as utils9 } from "ethers";
+var mockGenericRemoveOnlySelector = sighash(utils9.FunctionFragment.fromString("removeOnly(address,bytes,bytes)"));
+var mockGenericSwapASelector = sighash(utils9.FunctionFragment.fromString("swapA(address,bytes,bytes)"));
+var mockGenericSwapBSelector = sighash(utils9.FunctionFragment.fromString("swapB(address,bytes,bytes)"));
+var mockGenericSwapDirectFromVaultSelector = sighash(utils9.FunctionFragment.fromString("swapDirectFromVault(address,bytes,bytes)"));
+var mockGenericSwapViaApprovalSelector = sighash(utils9.FunctionFragment.fromString("swapViaApproval(address,bytes,bytes)"));
+function mockGenericSwapArgs({
+  spendAssets = [],
+  actualSpendAssetAmounts = [],
+  maxSpendAssetAmounts = actualSpendAssetAmounts,
+  incomingAssets = [],
+  actualIncomingAssetAmounts = [],
+  minIncomingAssetAmounts = actualIncomingAssetAmounts
+}) {
+  return encodeArgs3(["address[]", "uint256[]", "uint256[]", "address[]", "uint256[]", "uint256[]"], [
+    spendAssets,
+    maxSpendAssetAmounts,
+    actualSpendAssetAmounts,
+    incomingAssets,
+    minIncomingAssetAmounts,
+    actualIncomingAssetAmounts
+  ]);
+}
+async function mockGenericSwap({
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  fundOwner,
+  mockGenericAdapter,
+  selector = mockGenericSwapASelector,
+  spendAssets = [],
+  actualSpendAssetAmounts = [],
+  maxSpendAssetAmounts = actualSpendAssetAmounts,
+  incomingAssets = [],
+  actualIncomingAssetAmounts = [],
+  minIncomingAssetAmounts = actualIncomingAssetAmounts,
+  seedFund = false
+}) {
+  if (seedFund) {
+    for (const key in spendAssets) {
+      await spendAssets[key].transfer(vaultProxy, maxSpendAssetAmounts[key]);
+    }
+  }
+  const swapArgs = mockGenericSwapArgs({
+    actualIncomingAssetAmounts,
+    actualSpendAssetAmounts,
+    incomingAssets,
+    maxSpendAssetAmounts,
+    minIncomingAssetAmounts,
+    spendAssets
+  });
+  const callArgs = callOnIntegrationArgs5({
+    adapter: mockGenericAdapter,
+    encodedCallArgs: swapArgs,
+    selector
+  });
+  const swapTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId6.CallOnIntegration, callArgs);
+  await expect(swapTx).resolves.toBeReceipt();
+  return swapTx;
+}
+
+// src/scaffolding/extensions/integrations/olympusV2.ts
+import {
+  callOnIntegrationArgs as callOnIntegrationArgs6,
+  IntegrationManagerActionId as IntegrationManagerActionId7,
+  olympusV2StakeArgs,
+  olympusV2UnstakeArgs,
+  stakeSelector as stakeSelector2,
+  unstakeSelector as unstakeSelector2
+} from "@enzymefinance/protocol";
+async function olympusV2Stake({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  olympusV2Adapter,
+  amount
+}) {
+  const stakeArgs = olympusV2StakeArgs({
+    amount
+  });
+  const callArgs = callOnIntegrationArgs6({
+    adapter: olympusV2Adapter,
+    encodedCallArgs: stakeArgs,
+    selector: stakeSelector2
+  });
+  const stakeTx = comptrollerProxy.connect(signer).callOnExtension(integrationManager, IntegrationManagerActionId7.CallOnIntegration, callArgs);
+  return stakeTx;
+}
+async function olympusV2Unstake({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  olympusV2Adapter,
+  amount
+}) {
+  const unstakeArgs = olympusV2UnstakeArgs({
+    amount
+  });
+  const callArgs = callOnIntegrationArgs6({
+    adapter: olympusV2Adapter,
+    encodedCallArgs: unstakeArgs,
+    selector: unstakeSelector2
+  });
+  const unstakeTx = comptrollerProxy.connect(signer).callOnExtension(integrationManager, IntegrationManagerActionId7.CallOnIntegration, callArgs);
+  return unstakeTx;
+}
+
+// src/scaffolding/extensions/integrations/paraSwapV5.ts
+import {
+  callOnIntegrationArgs as callOnIntegrationArgs7,
+  IntegrationManagerActionId as IntegrationManagerActionId8,
+  paraSwapV5TakeOrderArgs,
+  takeOrderSelector as takeOrderSelector2
+} from "@enzymefinance/protocol";
+import { utils as utils10 } from "ethers";
+function paraSwapV5GenerateDummyPaths({ toTokens }) {
+  return toTokens.map((toToken) => {
+    return {
+      adapters: [],
+      to: toToken,
+      totalNetworkFee: 0
+    };
+  });
+}
+async function paraSwapV5TakeOrder({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  paraSwapV5Adapter,
+  outgoingAsset,
+  outgoingAssetAmount,
+  minIncomingAssetAmount = 1,
+  expectedIncomingAssetAmount = minIncomingAssetAmount,
+  uuid = utils10.randomBytes(16),
+  paths
+}) {
+  const takeOrderArgs = paraSwapV5TakeOrderArgs({
+    expectedIncomingAssetAmount,
+    minIncomingAssetAmount,
+    outgoingAsset,
+    outgoingAssetAmount,
+    paths,
+    uuid
+  });
+  const callArgs = callOnIntegrationArgs7({
+    adapter: paraSwapV5Adapter,
+    encodedCallArgs: takeOrderArgs,
+    selector: takeOrderSelector2
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId8.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/integrations/poolTogetherV4.ts
+import {
+  callOnIntegrationArgs as callOnIntegrationArgs8,
+  claimRewardsSelector as claimRewardsSelector4,
+  IntegrationManagerActionId as IntegrationManagerActionId9,
+  lendSelector as lendSelector5,
+  poolTogetherV4ClaimRewardsArgs,
+  poolTogetherV4LendArgs,
+  poolTogetherV4RedeemArgs,
+  redeemSelector as redeemSelector5
+} from "@enzymefinance/protocol";
+import { utils as utils11 } from "ethers";
+async function poolTogetherV4Lend({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  poolTogetherV4Adapter,
+  ptToken,
+  amount = utils11.parseEther("1")
+}) {
+  const lendArgs = poolTogetherV4LendArgs({
+    amount,
+    ptToken
+  });
+  const callArgs = callOnIntegrationArgs8({
+    adapter: poolTogetherV4Adapter,
+    encodedCallArgs: lendArgs,
+    selector: lendSelector5
+  });
+  const lendTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId9.CallOnIntegration, callArgs);
+  return lendTx;
+}
+async function poolTogetherV4Redeem({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  poolTogetherV4Adapter,
+  ptToken,
+  amount = utils11.parseEther("1")
+}) {
+  const redeemArgs = poolTogetherV4RedeemArgs({
+    amount,
+    ptToken
+  });
+  const callArgs = callOnIntegrationArgs8({
+    adapter: poolTogetherV4Adapter,
+    encodedCallArgs: redeemArgs,
+    selector: redeemSelector5
+  });
+  const redeemTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId9.CallOnIntegration, callArgs);
+  return redeemTx;
+}
+async function poolTogetherV4ClaimRewards({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  poolTogetherV4Adapter,
+  prizeDistributor,
+  drawIds,
+  winningPicks
+}) {
+  const claimRewardsArgs = poolTogetherV4ClaimRewardsArgs({
+    drawIds,
+    prizeDistributor,
+    winningPicks
+  });
+  const callArgs = callOnIntegrationArgs8({
+    adapter: poolTogetherV4Adapter,
+    encodedCallArgs: claimRewardsArgs,
+    selector: claimRewardsSelector4
+  });
+  const claimTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId9.CallOnIntegration, callArgs);
+  return claimTx;
+}
+
+// src/scaffolding/extensions/integrations/synthetix.ts
+import {
+  callOnIntegrationArgs as callOnIntegrationArgs9,
+  encodeArgs as encodeArgs4,
+  IntegrationManagerActionId as IntegrationManagerActionId10,
+  redeemSelector as redeemSelector6,
+  synthetixAssignExchangeDelegateSelector,
+  synthetixRedeemArgs,
+  synthetixTakeOrderArgs,
+  takeOrderSelector as takeOrderSelector3
+} from "@enzymefinance/protocol";
+import { utils as utils12 } from "ethers";
+async function synthetixAssignExchangeDelegate({
+  comptrollerProxy,
+  synthetixDelegateApprovals,
+  fundOwner,
+  delegate
+}) {
+  await comptrollerProxy.connect(fundOwner).vaultCallOnContract(synthetixDelegateApprovals, synthetixAssignExchangeDelegateSelector, encodeArgs4(["address"], [delegate]));
+}
+async function synthetixRedeem({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  synthetixAdapter,
+  synths
+}) {
+  const redeemArgs = synthetixRedeemArgs({
+    synths
+  });
+  const callArgs = callOnIntegrationArgs9({
+    adapter: synthetixAdapter,
+    encodedCallArgs: redeemArgs,
+    selector: redeemSelector6
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, IntegrationManagerActionId10.CallOnIntegration, callArgs);
+}
+async function synthetixTakeOrder({
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  fundOwner,
+  synthetixAdapter,
+  outgoingAsset,
+  outgoingAssetAmount = utils12.parseEther("1"),
+  minIncomingSusdAmount = utils12.parseEther("1"),
+  seedFund = false
+}) {
+  if (seedFund) {
+    await outgoingAsset.transfer(vaultProxy, outgoingAssetAmount);
+  }
+  const takeOrderArgs = synthetixTakeOrderArgs({
+    minIncomingSusdAmount,
+    outgoingAsset,
+    outgoingAssetAmount
+  });
+  const callArgs = await callOnIntegrationArgs9({
+    adapter: synthetixAdapter,
+    encodedCallArgs: takeOrderArgs,
+    selector: takeOrderSelector3
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId10.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/integrations/uniswapV2.ts
+import { contract as contract5 } from "@enzymefinance/ethers";
+import {
+  callOnIntegrationArgs as callOnIntegrationArgs10,
+  IntegrationManagerActionId as IntegrationManagerActionId11,
+  lendSelector as lendSelector6,
+  redeemSelector as redeemSelector7,
+  takeOrderSelector as takeOrderSelector4,
+  uniswapV2LendArgs,
+  uniswapV2RedeemArgs,
+  uniswapV2TakeOrderArgs
+} from "@enzymefinance/protocol";
+var UniswapV2Factory = contract5()`
+  function createPair(address,address) returns (address)
+  function getPair(address,address) view returns (address)
+`;
+async function uniswapV2Lend({
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  fundOwner,
+  uniswapV2LiquidityAdapter,
+  tokenA,
+  tokenB,
+  amountADesired,
+  amountBDesired,
+  amountAMin,
+  amountBMin,
+  minPoolTokenAmount,
+  seedFund = false
+}) {
+  if (seedFund) {
+    await tokenA.transfer(vaultProxy, amountADesired);
+    await tokenB.transfer(vaultProxy, amountBDesired);
+  }
+  const lendArgs = uniswapV2LendArgs({
+    amountADesired,
+    amountAMin,
+    amountBDesired,
+    amountBMin,
+    minPoolTokenAmount,
+    tokenA,
+    tokenB
+  });
+  const callArgs = callOnIntegrationArgs10({
+    adapter: uniswapV2LiquidityAdapter,
+    encodedCallArgs: lendArgs,
+    selector: lendSelector6
+  });
+  const lendTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId11.CallOnIntegration, callArgs);
+  await expect(lendTx).resolves.toBeReceipt();
+  return lendTx;
+}
+async function uniswapV2Redeem({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  uniswapV2LiquidityAdapter,
+  poolTokenAmount,
+  tokenA,
+  tokenB,
+  amountAMin,
+  amountBMin
+}) {
+  const redeemArgs = uniswapV2RedeemArgs({
+    amountAMin,
+    amountBMin,
+    poolTokenAmount,
+    tokenA,
+    tokenB
+  });
+  const callArgs = callOnIntegrationArgs10({
+    adapter: uniswapV2LiquidityAdapter,
+    encodedCallArgs: redeemArgs,
+    selector: redeemSelector7
+  });
+  const redeemTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId11.CallOnIntegration, callArgs);
+  await expect(redeemTx).resolves.toBeReceipt();
+  return redeemTx;
+}
+async function uniswapV2TakeOrder({
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  fundOwner,
+  uniswapV2ExchangeAdapter,
+  path,
+  outgoingAssetAmount,
+  minIncomingAssetAmount,
+  seedFund = false
+}) {
+  if (seedFund) {
+    await path[0].transfer(vaultProxy, outgoingAssetAmount);
+  }
+  const takeOrderArgs = uniswapV2TakeOrderArgs({
+    minIncomingAssetAmount,
+    outgoingAssetAmount,
+    path
+  });
+  const callArgs = callOnIntegrationArgs10({
+    adapter: uniswapV2ExchangeAdapter,
+    encodedCallArgs: takeOrderArgs,
+    selector: takeOrderSelector4
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId11.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/integrations/uniswapV3.ts
+import {
+  callOnIntegrationArgs as callOnIntegrationArgs11,
+  IntegrationManagerActionId as IntegrationManagerActionId12,
+  takeOrderSelector as takeOrderSelector5,
+  uniswapV3TakeOrderArgs
+} from "@enzymefinance/protocol";
+async function uniswapV3TakeOrder({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  uniswapV3Adapter,
+  pathAddresses,
+  pathFees,
+  outgoingAssetAmount,
+  minIncomingAssetAmount = 1,
+  seedFund = false
+}) {
+  if (seedFund) {
+    const vaultProxy = await comptrollerProxy.getVaultProxy();
+    await pathAddresses[0].transfer(vaultProxy, outgoingAssetAmount);
+  }
+  const takeOrderArgs = uniswapV3TakeOrderArgs({
+    minIncomingAssetAmount,
+    outgoingAssetAmount,
+    pathAddresses,
+    pathFees
+  });
+  const callArgs = callOnIntegrationArgs11({
+    adapter: uniswapV3Adapter,
+    encodedCallArgs: takeOrderArgs,
+    selector: takeOrderSelector5
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId12.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/integrations/yearn.ts
+import {
+  callOnIntegrationArgs as callOnIntegrationArgs12,
+  IntegrationManagerActionId as IntegrationManagerActionId13,
+  lendSelector as lendSelector7,
+  redeemSelector as redeemSelector8,
+  yearnVaultV2LendArgs,
+  yearnVaultV2RedeemArgs
+} from "@enzymefinance/protocol";
+import { BigNumber as BigNumber8 } from "ethers";
+async function yearnVaultV2Lend({
+  signer,
+  comptrollerProxy,
+  integrationManager,
+  yearnVaultV2Adapter,
+  yVault,
+  outgoingUnderlyingAmount,
+  minIncomingYVaultSharesAmount = BigNumber8.from(1)
+}) {
+  const callArgs = callOnIntegrationArgs12({
+    adapter: yearnVaultV2Adapter,
+    encodedCallArgs: yearnVaultV2LendArgs({
+      minIncomingYVaultSharesAmount,
+      outgoingUnderlyingAmount,
+      yVault
+    }),
+    selector: lendSelector7
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, IntegrationManagerActionId13.CallOnIntegration, callArgs);
+}
+async function yearnVaultV2Redeem({
+  signer,
+  comptrollerProxy,
+  integrationManager,
+  yearnVaultV2Adapter,
+  yVault,
+  maxOutgoingYVaultSharesAmount,
+  minIncomingUnderlyingAmount = BigNumber8.from(1),
+  slippageToleranceBps = 1
+}) {
+  const callArgs = callOnIntegrationArgs12({
+    adapter: yearnVaultV2Adapter,
+    encodedCallArgs: yearnVaultV2RedeemArgs({
+      maxOutgoingYVaultSharesAmount,
+      minIncomingUnderlyingAmount,
+      slippageToleranceBps,
+      yVault
+    }),
+    selector: redeemSelector8
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, IntegrationManagerActionId13.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/integrations/zeroExV2.ts
+import {
+  callOnIntegrationArgs as callOnIntegrationArgs13,
+  IntegrationManagerActionId as IntegrationManagerActionId14,
+  takeOrderSelector as takeOrderSelector6,
+  zeroExV2TakeOrderArgs
+} from "@enzymefinance/protocol";
+async function zeroExV2TakeOrder({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  zeroExV2Adapter,
+  signedOrder,
+  takerAssetFillAmount
+}) {
+  const takeOrderArgs = zeroExV2TakeOrderArgs({
+    signedOrder,
+    takerAssetFillAmount
+  });
+  const callArgs = callOnIntegrationArgs13({
+    adapter: zeroExV2Adapter,
+    encodedCallArgs: takeOrderArgs,
+    selector: takeOrderSelector6
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, IntegrationManagerActionId14.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/policies.ts
+import { IPolicy, PolicyHook, policyManagerConfigArgs } from "@enzymefinance/protocol";
+import { constants as constants2, utils as utils13 } from "ethers";
+async function generatePolicyManagerConfigWithMockPolicies({ deployer }) {
+  const policies = Object.values(await generateMockPolicies({
+    deployer
+  }));
+  const policiesSettingsData = [...new Array(policies.length - 1).fill(constants2.HashZero), utils13.randomBytes(10)];
+  return policyManagerConfigArgs({
+    policies,
+    settings: policiesSettingsData
+  });
+}
+async function generateMockPolicies({ deployer }) {
+  const mockAddTrackedAssetsPolicy = await IPolicy.mock(deployer);
+  const mockCreateExternalPositionPolicy = await IPolicy.mock(deployer);
+  const mockPostBuySharesPolicy = await IPolicy.mock(deployer);
+  const mockPostCallOnExternalPositionPolicy = await IPolicy.mock(deployer);
+  const mockPostCoIPolicy = await IPolicy.mock(deployer);
+  const mockRedeemSharesForSpecificAssetsPolicy = await IPolicy.mock(deployer);
+  const mockPreTransferSharesPolicy = await IPolicy.mock(deployer);
+  const mockRemoveExternalPositionPolicy = await IPolicy.mock(deployer);
+  await Promise.all([
+    mockAddTrackedAssetsPolicy.identifier.returns(`MOCK_ADD_TRACKED_ASSETS`),
+    mockAddTrackedAssetsPolicy.addFundSettings.returns(void 0),
+    mockAddTrackedAssetsPolicy.activateForFund.returns(void 0),
+    mockAddTrackedAssetsPolicy.canDisable.returns(false),
+    mockAddTrackedAssetsPolicy.validateRule.returns(true),
+    mockAddTrackedAssetsPolicy.implementedHooks.returns([PolicyHook.AddTrackedAssets]),
+    mockAddTrackedAssetsPolicy.updateFundSettings.returns(void 0),
+    mockCreateExternalPositionPolicy.identifier.returns(`MOCK_CREATE_EXTERNAL_POSITION`),
+    mockCreateExternalPositionPolicy.addFundSettings.returns(void 0),
+    mockCreateExternalPositionPolicy.activateForFund.returns(void 0),
+    mockCreateExternalPositionPolicy.canDisable.returns(false),
+    mockCreateExternalPositionPolicy.validateRule.returns(true),
+    mockCreateExternalPositionPolicy.implementedHooks.returns([PolicyHook.CreateExternalPosition]),
+    mockCreateExternalPositionPolicy.updateFundSettings.returns(void 0),
+    mockPostBuySharesPolicy.identifier.returns(`MOCK_POST_BUY_SHARES`),
+    mockPostBuySharesPolicy.addFundSettings.returns(void 0),
+    mockPostBuySharesPolicy.activateForFund.returns(void 0),
+    mockPostBuySharesPolicy.canDisable.returns(false),
+    mockPostBuySharesPolicy.validateRule.returns(true),
+    mockPostBuySharesPolicy.implementedHooks.returns([PolicyHook.PostBuyShares]),
+    mockPostBuySharesPolicy.updateFundSettings.returns(void 0),
+    mockPostCallOnExternalPositionPolicy.identifier.returns(`MOCK_POST_CALL_ON_EXTERNAL_POSITION`),
+    mockPostCallOnExternalPositionPolicy.addFundSettings.returns(void 0),
+    mockPostCallOnExternalPositionPolicy.activateForFund.returns(void 0),
+    mockPostCallOnExternalPositionPolicy.canDisable.returns(false),
+    mockPostCallOnExternalPositionPolicy.validateRule.returns(true),
+    mockPostCallOnExternalPositionPolicy.implementedHooks.returns([PolicyHook.PostCallOnExternalPosition]),
+    mockPostCallOnExternalPositionPolicy.updateFundSettings.returns(void 0),
+    mockPostCoIPolicy.identifier.returns(`MOCK_POST_CALL_ON_INTEGRATION`),
+    mockPostCoIPolicy.addFundSettings.returns(void 0),
+    mockPostCoIPolicy.activateForFund.returns(void 0),
+    mockPostCoIPolicy.canDisable.returns(false),
+    mockPostCoIPolicy.validateRule.returns(true),
+    mockPostCoIPolicy.implementedHooks.returns([PolicyHook.PostCallOnIntegration]),
+    mockPostCoIPolicy.updateFundSettings.returns(void 0),
+    mockPreTransferSharesPolicy.identifier.returns(`MOCK_PRE_TRANSFER_SHARES`),
+    mockPreTransferSharesPolicy.addFundSettings.returns(void 0),
+    mockPreTransferSharesPolicy.activateForFund.returns(void 0),
+    mockPreTransferSharesPolicy.canDisable.returns(false),
+    mockPreTransferSharesPolicy.validateRule.returns(true),
+    mockPreTransferSharesPolicy.implementedHooks.returns([PolicyHook.PreTransferShares]),
+    mockPreTransferSharesPolicy.updateFundSettings.returns(void 0),
+    mockRedeemSharesForSpecificAssetsPolicy.identifier.returns(`MOCK_REDEEM_SHARES_FOR_SPECIFIC_ASSETS`),
+    mockRedeemSharesForSpecificAssetsPolicy.addFundSettings.returns(void 0),
+    mockRedeemSharesForSpecificAssetsPolicy.activateForFund.returns(void 0),
+    mockRedeemSharesForSpecificAssetsPolicy.canDisable.returns(false),
+    mockRedeemSharesForSpecificAssetsPolicy.validateRule.returns(true),
+    mockRedeemSharesForSpecificAssetsPolicy.implementedHooks.returns([PolicyHook.RedeemSharesForSpecificAssets]),
+    mockRedeemSharesForSpecificAssetsPolicy.updateFundSettings.returns(void 0),
+    mockRemoveExternalPositionPolicy.identifier.returns(`MOCK_REMOVE_EXTERNAL_POSITION`),
+    mockRemoveExternalPositionPolicy.addFundSettings.returns(void 0),
+    mockRemoveExternalPositionPolicy.activateForFund.returns(void 0),
+    mockRemoveExternalPositionPolicy.canDisable.returns(false),
+    mockRemoveExternalPositionPolicy.validateRule.returns(true),
+    mockRemoveExternalPositionPolicy.implementedHooks.returns([PolicyHook.RedeemSharesForSpecificAssets]),
+    mockRemoveExternalPositionPolicy.updateFundSettings.returns(void 0)
+  ]);
+  return {
+    mockAddTrackedAssetsPolicy,
+    mockCreateExternalPositionPolicy,
+    mockPostBuySharesPolicy,
+    mockPostCallOnExternalPositionPolicy,
+    mockPostCoIPolicy,
+    mockPreTransferSharesPolicy,
+    mockRedeemSharesForSpecificAssetsPolicy,
+    mockRemoveExternalPositionPolicy
+  };
+}
+
+// src/scaffolding/external-interfaces.ts
+import { contract as contract6 } from "@enzymefinance/ethers";
+var IConvexBaseRewardPool = contract6()`
+  function stakeFor(address, uint256) returns (bool)
+`;
+var IConvexCrvDepositor = contract6()`
+  function deposit(uint256, bool)
+`;
+var IConvexCvxLocker = contract6()`
+  function balanceOf(address) view returns (uint256)
+  function checkpointEpoch()
+  function getReward(address, bool)
+  function lockedBalanceOf(address) view returns (uint256)
+`;
+var IConvexVlCvxExtraRewardDistribution = contract6()`
+  function claimableRewards(address, address) view returns (uint256)
+  function addReward(address, uint256)
+`;
+var ISnapshotDelegateRegistry = contract6()`
+  function delegation(address, bytes32) view returns (address)
+`;
+var IVotiumMultiMerkleStash = contract6()`
+  function owner() view returns (address)
+  function updateMerkleRoot(address, bytes32)
+`;
+
+// src/scaffolding/peripheral/shares-splitter.ts
+import { SharesSplitterLib } from "@enzymefinance/protocol";
+async function deploySharesSplitter({
+  signer,
+  sharesSplitterFactory,
+  splitUsers,
+  splitPercentages
+}) {
+  const receipt = await sharesSplitterFactory.connect(signer).deploy(splitUsers, splitPercentages);
+  const proxyDeployedArgs = assertEvent(receipt, "ProxyDeployed", {
+    caller: signer,
+    proxy: expect.any(String)
+  });
+  const sharesSplitterProxy = new SharesSplitterLib(proxyDeployedArgs.proxy, provider);
+  return { receipt, sharesSplitterProxy };
+}
+
+// src/scaffolding/setup.ts
+import { randomAddress } from "@enzymefinance/ethers";
+import {
+  ComptrollerLib as ComptrollerLib3,
+  ComptrollerProxy,
+  encodeFunctionData,
+  GasRelayPaymasterLib,
+  VaultLib as VaultLib4,
+  VaultProxy
+} from "@enzymefinance/protocol";
+import { BigNumber as BigNumber9, utils as utils15 } from "ethers";
+
+// src/scaffolding/shares.ts
+import { constants as constants3, utils as utils14 } from "ethers";
+async function buyShares(options) {
+  return (await buySharesFunction(options)).send();
+}
+async function buySharesFunction({
+  comptrollerProxy,
+  denominationAsset,
+  buyer,
+  investmentAmount,
+  minSharesQuantity = 1,
+  seedBuyer = false
+}) {
+  if (investmentAmount == null) {
+    investmentAmount = utils14.parseUnits("1", await denominationAsset.decimals());
+  }
+  if (seedBuyer) {
+    await denominationAsset.transfer(buyer, investmentAmount);
+  }
+  await denominationAsset.connect(buyer).approve(comptrollerProxy, investmentAmount);
+  return comptrollerProxy.connect(buyer).buyShares.args(investmentAmount, minSharesQuantity).ref;
+}
+async function redeemSharesForSpecificAssets({
+  comptrollerProxy,
+  signer,
+  recipient = signer,
+  quantity = constants3.MaxUint256,
+  payoutAssets,
+  payoutAssetPercentages
+}) {
+  return comptrollerProxy.connect(signer).redeemSharesForSpecificAssets(recipient, quantity, payoutAssets, payoutAssetPercentages);
+}
+async function redeemSharesInKind({
+  comptrollerProxy,
+  signer,
+  recipient = signer,
+  quantity = constants3.MaxUint256,
+  additionalAssets = [],
+  assetsToSkip = []
+}) {
+  return comptrollerProxy.connect(signer).redeemSharesInKind(recipient, quantity, additionalAssets, assetsToSkip);
+}
+
+// src/scaffolding/setup.ts
+async function createComptrollerProxy({
+  signer,
+  comptrollerLib,
+  denominationAsset,
+  sharesActionTimelock = 0
+}) {
+  const constructData = encodeFunctionData(comptrollerLib.init.fragment, [denominationAsset, sharesActionTimelock]);
+  const comptrollerProxyContract = await ComptrollerProxy.deploy(signer, constructData, comptrollerLib);
+  return {
+    comptrollerProxy: new ComptrollerLib3(comptrollerProxyContract, signer),
+    receipt: comptrollerProxyContract.deployment
+  };
+}
+async function createMigrationRequest({
+  signer,
+  fundDeployer,
+  vaultProxy,
+  denominationAsset,
+  sharesActionTimelock = 0,
+  feeManagerConfigData = "0x",
+  policyManagerConfigData = "0x",
+  bypassPrevReleaseFailure = false
+}) {
+  const receipt = await fundDeployer.connect(signer).createMigrationRequest(vaultProxy, denominationAsset, sharesActionTimelock, feeManagerConfigData, policyManagerConfigData, bypassPrevReleaseFailure);
+  const comptrollerDeployedArgs = assertEvent(receipt, "ComptrollerProxyDeployed", {
+    comptrollerProxy: expect.any(String),
+    creator: signer,
+    denominationAsset,
+    sharesActionTimelock: BigNumber9.from(sharesActionTimelock)
+  });
+  return {
+    comptrollerProxy: new ComptrollerLib3(comptrollerDeployedArgs.comptrollerProxy, signer),
+    receipt
+  };
+}
+async function createNewFund({
+  signer,
+  fundDeployer,
+  denominationAsset,
+  sharesActionTimelock = 0,
+  fundOwner = randomAddress(),
+  fundName = "My Fund",
+  fundSymbol = "",
+  feeManagerConfig = "0x",
+  policyManagerConfig = "0x",
+  investment
+}) {
+  const receipt = await fundDeployer.connect(signer).createNewFund(fundOwner, fundName, fundSymbol, denominationAsset, sharesActionTimelock, feeManagerConfig, policyManagerConfig);
+  const comptrollerDeployedArgs = assertEvent(receipt, "ComptrollerProxyDeployed", {
+    comptrollerProxy: expect.any(String),
+    creator: signer,
+    denominationAsset,
+    sharesActionTimelock: BigNumber9.from(sharesActionTimelock)
+  });
+  const comptrollerProxy = new ComptrollerLib3(comptrollerDeployedArgs.comptrollerProxy, signer);
+  const newFundDeployedArgs = assertEvent(receipt, "NewFundCreated", {
+    comptrollerProxy,
+    creator: signer,
+    vaultProxy: expect.any(String)
+  });
+  const vaultProxy = new VaultLib4(newFundDeployedArgs.vaultProxy, signer);
+  if (investment != null) {
+    await buyShares(__spreadValues({
+      comptrollerProxy,
+      denominationAsset
+    }, investment));
+  }
+  return {
+    comptrollerProxy,
+    receipt,
+    vaultProxy
+  };
+}
+async function createReconfigurationRequest({
+  signer,
+  fundDeployer,
+  vaultProxy,
+  denominationAsset,
+  sharesActionTimelock = 0,
+  feeManagerConfigData = "0x",
+  policyManagerConfigData = "0x"
+}) {
+  const receipt = await fundDeployer.connect(signer).createReconfigurationRequest(vaultProxy, denominationAsset, sharesActionTimelock, feeManagerConfigData, policyManagerConfigData);
+  const comptrollerDeployedArgs = assertEvent(receipt, "ComptrollerProxyDeployed", {
+    comptrollerProxy: expect.any(String),
+    creator: signer,
+    denominationAsset,
+    sharesActionTimelock: BigNumber9.from(sharesActionTimelock)
+  });
+  return {
+    comptrollerProxy: new ComptrollerLib3(comptrollerDeployedArgs.comptrollerProxy, signer),
+    receipt
+  };
+}
+async function createVaultProxy({
+  signer,
+  vaultLib,
+  fundOwner,
+  fundAccessor,
+  fundName = "My Fund"
+}) {
+  const constructData = encodeFunctionData(vaultLib.init.fragment, [fundOwner, fundAccessor, fundName]);
+  const vaultProxyContract = await VaultProxy.deploy(signer, constructData, vaultLib);
+  return new VaultLib4(vaultProxyContract, fundAccessor);
+}
+async function setupGasRelayerPaymaster({
+  signer,
+  vaultProxy,
+  fundAccessor,
+  weth,
+  startingBalance = utils15.parseUnits("10", 18)
+}) {
+  await weth.transfer(vaultProxy, startingBalance);
+  const comptrollerProxy = new ComptrollerLib3(fundAccessor, signer);
+  const receipt = await comptrollerProxy.deployGasRelayPaymaster();
+  const eventArgs = assertEvent(receipt, "GasRelayPaymasterSet", {
+    gasRelayPaymaster: expect.any(String)
+  });
+  return new GasRelayPaymasterLib(eventArgs.gasRelayPaymaster, signer);
+}
+
+// src/scaffolding/vaultCalls.ts
+import {
+  addressListRegistryCreateListSelector,
+  curveMinterMintManySelector,
+  curveMinterMintSelector,
+  curveMinterToggleApproveMintSelector,
+  encodeArgs as encodeArgs5,
+  sighash as sighash2
+} from "@enzymefinance/protocol";
+import { constants as constants4, utils as utils16 } from "ethers";
+async function vaultCallCreateNewList({
+  addressListRegistry,
+  comptrollerProxy,
+  items,
+  owner,
+  signer,
+  updateType
+}) {
+  await comptrollerProxy.connect(signer).vaultCallOnContract(addressListRegistry.address, addressListRegistryCreateListSelector, encodeArgs5(["address", "uint8", "address[]"], [owner, updateType, items]));
+  const listCount = await addressListRegistry.getListCount();
+  return listCount.sub(1);
+}
+function vaultCallCurveMinterMint({
+  comptrollerProxy,
+  minter,
+  gauge
+}) {
+  return comptrollerProxy.vaultCallOnContract(minter, curveMinterMintSelector, encodeArgs5(["address"], [gauge]));
+}
+function vaultCallCurveMinterMintMany({
+  comptrollerProxy,
+  minter,
+  gauges
+}) {
+  const gaugesFormatted = new Array(8).fill(constants4.AddressZero);
+  for (const i in gauges) {
+    gaugesFormatted[i] = gauges[i];
+  }
+  return comptrollerProxy.vaultCallOnContract(minter, curveMinterMintManySelector, encodeArgs5(["address[8]"], [gaugesFormatted]));
+}
+function vaultCallCurveMinterToggleApproveMint({
+  comptrollerProxy,
+  minter,
+  account
+}) {
+  return comptrollerProxy.vaultCallOnContract(minter, curveMinterToggleApproveMintSelector, encodeArgs5(["address"], [account]));
+}
+function vaultCallStartAssetBypassTimelock({
+  comptrollerProxy,
+  contract: contract7,
+  asset
+}) {
+  return comptrollerProxy.vaultCallOnContract(contract7, sighash2(utils16.FunctionFragment.fromString("startAssetBypassTimelock(address)")), encodeArgs5(["address"], [asset]));
+}
+
+// src/whales.ts
+import { resolveAddress as resolveAddress4 } from "@enzymefinance/ethers";
+var whales = {
+  bat: "0x12274c71304bc0e6b38a56b94d2949b118feb838",
+  bnb: "0xbe0eb53f46cd790cd13851d5eff43d12404d33e8",
+  bnt: "0x7d1ed1601a12a172269436fa95fe156650603c1d",
+  busd: "0x47ac0fb4f2d84898e4d9e7b4dab3c24507a6d503",
+  comp: "0x0f50d31b3eaefd65236dd3736b863cffa4c63c4e",
+  crv: "0xf89501b77b2fa6329f94f5a05fe84cebb5c8b1a0",
+  dai: "0x47ac0fb4f2d84898e4d9e7b4dab3c24507a6d503",
+  grt: "0xf977814e90da44bfa03b6295a0616a897441acec",
+  knc: "0x09d51654bd9efbfcb56da3491989cc1444095fff",
+  ldo: "0x3dba737ccc50a32a1764b493285dd51c8af6c278",
+  link: "0xbe6977e08d4479c0a6777539ae0e8fa27be4e9d6",
+  lusd: "0x24cbbef882a77c5aaa9abd6558e68b4c648453c5",
+  mana: "0xefb94ac00f1cee8a89d5c3f49faa799da6f03024",
+  mln: "0xd8f8a53945bcfbbc19da162aa405e662ef71c40d",
+  ohm: "0x2cfcbd233268c302996c767347eb45bec36fb08d",
+  rep: "0xc6a043b07d33b6f30d8cb501026c391cfd25abe1",
+  ren: "0xbe0eb53f46cd790cd13851d5eff43d12404d33e8",
+  susd: "0xa5f7a39e55d7878bc5bd754ee5d6bd7a7662355b",
+  sohm: "0x3d5c83351c872fdf07da498c84ca3275222f284c",
+  uni: "0x47173b170c64d16393a52e6c480b3ad8c302ba1e",
+  usdc: "0xae2d4617c862309a3d75a0ffb358c7a5009c673f",
+  usdt: "0x5041ed759dd4afc3a72b8192c143f72f4724081a",
+  weth: "0xe08A8b19e5722a201EaF20A6BC595eF655397bd5",
+  zrx: "0x206376e8940e42538781cd94ef024df3c1e0fd43",
+  ausdc: "0x3DdfA8eC3052539b6C9549F12cEA2C295cfF5296",
+  ausdt: "0x7d6149ad9a573a6e2ca6ebf7d4897c1b766841b4",
+  ccomp: "0xd74f186194ab9219fafac5c2fe4b3270169666db",
+  cdai: "0x22fa8cc33a42320385cbd3690ed60a021891cb32",
+  ceth: "0x8aceab8167c80cb8b3de7fa6228b889bb1130ee8",
+  cuni: "0x39d8014b4f40d2cbc441137011d32023f4f1fd87",
+  cusdc: "0xb3bd459e0598dde1fe84b1d0a1430be175b5d5be",
+  fdai7: "0xa993d62492f41703f6185881eae755b0966ea5b0",
+  feth7: "0x05f284897641661fee9f1c1413a4f599a43a746f",
+  fdai8: "0xd6bf9d9079139dbb3a4fdb84b07efc75ea77838f",
+  ftribe8: "0xdb5ac83c137321da29a59a7592232bc4ed461730",
+  ptUsdc: "0x8904ffc6aa039db5941de11309a42372f3f7d2fd",
+  seth: "0xc34a7c65aa08cb36744bda8eeec7b8e9891e147c",
+  sxag: "0x40d68c490bf7262ec40048099aec23535f734be2",
+  sxau: "0x92eb453b7b5b8d41edb44e2c8b8b53eb70a482c7",
+  cvx: "0x0aca67fa70b142a3b9bf2ed89a81b40ff85dacdc",
+  lidoSteth: "0x06920c9fc643de77b99cb7670a944ad31eaaa260",
+  ust: "0x738cf6903e6c4e699d1c2dd9ab8b67fcdb3121ea",
+  stecrv: "0x56c915758ad3f76fd287fff7563ee313142fb663"
+};
+async function unlockWhale(token) {
+  const address = resolveAddress4(whales[token]);
+  await provider.send("hardhat_impersonateAccount", [address]);
+  return provider.getSignerWithAddress(address);
+}
+async function unlockAllWhales() {
+  const keys = Object.keys(whales);
+  const signers = await Promise.all(keys.map(async (token) => unlockWhale(token)));
+  const initial = {};
+  return keys.reduce((carry, key, index) => {
+    return __spreadProps(__spreadValues({}, carry), { [key]: signers[index] });
+  }, initial);
+}
+async function unlockWhales(...tokens) {
+  const signers = await Promise.all(tokens.map(async (token) => unlockWhale(token)));
+  const initial = {};
+  return tokens.reduce((carry, key, index) => {
+    return __spreadProps(__spreadValues({}, carry), { [key]: signers[index] });
+  }, initial);
+}
+export {
+  CurveLiquidityGaugeV2,
+  CurveMinter,
+  CurveRegistry,
+  CurveSwaps,
+  ICompoundComptroller,
+  IConvexBaseRewardPool,
+  IConvexCrvDepositor,
+  IConvexCvxLocker,
+  IConvexVlCvxExtraRewardDistribution,
+  ILiquityHintHelper,
+  ILiquitySortedTroves,
+  ILiquityTroveManager,
+  ISnapshotDelegateRegistry,
+  IUniswapV3NonFungibleTokenManager,
+  IVotiumMultiMerkleStash,
+  UniswapV2Factory,
+  UniswapV3FeeAmount,
+  aaveDebtPositionAddCollateral,
+  aaveDebtPositionBorrow,
+  aaveDebtPositionClaimRewards,
+  aaveDebtPositionRemoveCollateral,
+  aaveDebtPositionRepayBorrow,
+  aaveLend,
+  aaveRedeem,
+  addNewAssetsToFund,
+  addTrackedAssetsToVault,
+  assertCompoundLend,
+  assertCompoundRedeem,
+  assertDidRelay,
+  assertDidRelaySuccessfully,
+  assertDidRelayWithCharge,
+  assertDidRelayWithError,
+  assertEvent,
+  assertNoEvent,
+  assertPaymasterDidReject,
+  assertPaymasterDidRejectForReason,
+  buyShares,
+  buySharesFunction,
+  calcMlnValueAndBurnAmountForSharesBuyback,
+  callOnExtension,
+  callOnExternalPosition,
+  compoundClaim,
+  compoundDebtPositionAddCollateral,
+  compoundDebtPositionBorrow,
+  compoundDebtPositionClaimComp,
+  compoundDebtPositionRemoveCollateral,
+  compoundDebtPositionRepayBorrow,
+  compoundLend,
+  compoundRedeem,
+  convexVotingPositionClaimRewards,
+  convexVotingPositionDelegate,
+  convexVotingPositionLock,
+  convexVotingPositionRelock,
+  convexVotingPositionWithdraw,
+  createAaveDebtPosition,
+  createCompoundDebtPosition,
+  createComptrollerProxy,
+  createConvexVotingPosition,
+  createExternalPosition,
+  createFundDeployer,
+  createLiquityDebtPosition,
+  createMapleLiquidityPosition,
+  createMigrationRequest,
+  createMockExternalPosition,
+  createNewFund,
+  createReconfigurationRequest,
+  createTheGraphDelegationPosition,
+  createUniswapV3LiquidityPosition,
+  createVaultProxy,
+  curveClaimRewards,
+  curveLend,
+  curveLendAndStake,
+  curveRedeem,
+  curveStake,
+  curveTakeOrder,
+  curveUnstake,
+  curveUnstakeAndRedeem,
+  deployProtocolFixture,
+  deploySharesSplitter,
+  generateFeeManagerConfigWithMockFees,
+  generateMerkleTreeForContractProof,
+  generateMockFees,
+  generateMockPolicies,
+  generatePolicyManagerConfigWithMockPolicies,
+  getAssetBalances,
+  getAssetUnit,
+  getNamedSigner,
+  getUnnamedSigners,
+  idleClaimRewards,
+  idleLend,
+  idleRedeem,
+  impersonateContractSigner,
+  impersonateSigner,
+  liquityCalcHints,
+  liquityDebtPositionAddCollateral,
+  liquityDebtPositionBorrow,
+  liquityDebtPositionCloseTrove,
+  liquityDebtPositionOpenTrove,
+  liquityDebtPositionRemoveCollateral,
+  liquityDebtPositionRepay,
+  mapleLiquidityPositionClaimInterest,
+  mapleLiquidityPositionClaimRewards,
+  mapleLiquidityPositionIntendToRedeem,
+  mapleLiquidityPositionLend,
+  mapleLiquidityPositionLendAndStake,
+  mapleLiquidityPositionRedeem,
+  mapleLiquidityPositionStake,
+  mapleLiquidityPositionUnstake,
+  mapleLiquidityPositionUnstakeAndRedeem,
+  mockExternalPositionAddDebtAssets,
+  mockExternalPositionAddManagedAssets,
+  mockExternalPositionRemoveDebtAssets,
+  mockExternalPositionRemoveManagedAssets,
+  mockGenericRemoveOnlySelector,
+  mockGenericSwap,
+  mockGenericSwapASelector,
+  mockGenericSwapArgs,
+  mockGenericSwapBSelector,
+  mockGenericSwapDirectFromVaultSelector,
+  mockGenericSwapViaApprovalSelector,
+  olympusV2Stake,
+  olympusV2Unstake,
+  paraSwapV5GenerateDummyPaths,
+  paraSwapV5TakeOrder,
+  poolTogetherV4ClaimRewards,
+  poolTogetherV4Lend,
+  poolTogetherV4Redeem,
+  reactivateExternalPosition,
+  redeemSharesForSpecificAssets,
+  redeemSharesInKind,
+  relayTransaction,
+  removeExternalPosition,
+  removeTrackedAssetsFromVault,
+  sendEthBySelfDestruct,
+  setupGasRelayerPaymaster,
+  synthetixAssignExchangeDelegate,
+  synthetixRedeem,
+  synthetixTakeOrder,
+  theGraphDelegationPositionDelegate,
+  theGraphDelegationPositionUndelegate,
+  theGraphDelegationPositionWithdraw,
+  transactionTimestamp,
+  uniswapV2Lend,
+  uniswapV2Redeem,
+  uniswapV2TakeOrder,
+  uniswapV3LiquidityPositionAddLiquidity,
+  uniswapV3LiquidityPositionCollect,
+  uniswapV3LiquidityPositionGetMaxTick,
+  uniswapV3LiquidityPositionGetMinTick,
+  uniswapV3LiquidityPositionMint,
+  uniswapV3LiquidityPositionPurge,
+  uniswapV3LiquidityPositionRemoveLiquidity,
+  uniswapV3OrderTokenPair,
+  uniswapV3TakeOrder,
+  unlockAllWhales,
+  unlockWhale,
+  unlockWhales,
+  updateChainlinkAggregator,
+  vaultCallCreateNewList,
+  vaultCallCurveMinterMint,
+  vaultCallCurveMinterMintMany,
+  vaultCallCurveMinterToggleApproveMint,
+  vaultCallStartAssetBypassTimelock,
+  yearnVaultV2Lend,
+  yearnVaultV2Redeem,
+  zeroExV2TakeOrder
+};