@enzymefinance/testutils 4.0.0 → 4.0.1

package/dist/index.js

@@ -0,0 +1,3352 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});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
+var _ethers = require('@enzymefinance/ethers');
+
+// src/helpers.ts
+var _protocol = require('@enzymefinance/protocol');
+var _ethers3 = require('ethers');
+var _merkletreejs = require('merkletreejs');
+async function calcMlnValueAndBurnAmountForSharesBuyback({
+  valueInterpreter,
+  mln,
+  denominationAsset,
+  sharesSupply,
+  gav,
+  buybackSharesAmount
+}) {
+  const grossShareValue = _ethers3.BigNumber.from(gav).mul(_ethers3.utils.parseEther("1")).div(sharesSupply);
+  const denominationAssetValueOfBuyback = grossShareValue.mul(buybackSharesAmount).div(_ethers3.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) => _ethers3.utils.solidityKeccak256(itemTypes, itemArray));
+  const tree = new (0, _merkletreejs.MerkleTree)(leaves, _ethers3.utils.keccak256, { sort: true });
+  const root = tree.getHexRoot();
+  return { leaves, root, tree };
+}
+async function sendEthBySelfDestruct({
+  signer,
+  recipient,
+  amount = _ethers3.utils.parseEther("1")
+}) {
+  const selfDestructEthPayer = await _protocol.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(_ethers.resolveAddress.call(void 0, signerAddress));
+}
+
+// src/assertions.ts
+
+function assertEvent(receipt, event, match) {
+  var _a;
+  const events = _ethers.extractEvent.call(void 0, 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 = _ethers.extractEvent.call(void 0, receipt, event);
+  expect(events.length).toBe(0);
+}
+
+// src/deployment.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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 (0, _protocol.AaveAdapter)(fixture.AaveAdapter.address, deployer),
+    aaveDebtPositionLib: new (0, _protocol.AaveDebtPositionLib)(fixture.AaveDebtPositionLib.address, deployer),
+    aaveDebtPositionParser: new (0, _protocol.AaveDebtPositionParser)(fixture.AaveDebtPositionParser.address, deployer),
+    aavePriceFeed: new (0, _protocol.AavePriceFeed)(fixture.AavePriceFeed.address, deployer),
+    addressListRegistry: new (0, _protocol.AddressListRegistry)(fixture.AddressListRegistry.address, deployer),
+    allowedAdapterIncomingAssetsPolicy: new (0, _protocol.AllowedAdapterIncomingAssetsPolicy)(fixture.AllowedAdapterIncomingAssetsPolicy.address, deployer),
+    allowedAdaptersPolicy: new (0, _protocol.AllowedAdaptersPolicy)(fixture.AllowedAdaptersPolicy.address, deployer),
+    allowedAssetsForRedemptionPolicy: new (0, _protocol.AllowedAssetsForRedemptionPolicy)(fixture.AllowedAssetsForRedemptionPolicy.address, deployer),
+    allowedDepositRecipientsPolicy: new (0, _protocol.AllowedDepositRecipientsPolicy)(fixture.AllowedDepositRecipientsPolicy.address, deployer),
+    allowedExternalPositionTypesPolicy: new (0, _protocol.AllowedExternalPositionTypesPolicy)(fixture.AllowedExternalPositionTypesPolicy.address, deployer),
+    allowedSharesTransferRecipientsPolicy: new (0, _protocol.AllowedSharesTransferRecipientsPolicy)(fixture.AllowedSharesTransferRecipientsPolicy.address, deployer),
+    compoundAdapter: new (0, _protocol.CompoundAdapter)(fixture.CompoundAdapter.address, deployer),
+    compoundDebtPositionLib: new (0, _protocol.CompoundDebtPositionLib)(fixture.CompoundDebtPositionLib.address, deployer),
+    compoundDebtPositionParser: new (0, _protocol.CompoundDebtPositionParser)(fixture.CompoundDebtPositionParser.address, deployer),
+    compoundPriceFeed: new (0, _protocol.CompoundPriceFeed)(fixture.CompoundPriceFeed.address, deployer),
+    comptrollerLib: new (0, _protocol.ComptrollerLib)(fixture.ComptrollerLib.address, deployer),
+    convexCurveLpStakingAdapter: new (0, _protocol.ConvexCurveLpStakingAdapter)(fixture.ConvexCurveLpStakingAdapter.address, deployer),
+    convexCurveLpStakingWrapperFactory: new (0, _protocol.ConvexCurveLpStakingWrapperFactory)(fixture.ConvexCurveLpStakingWrapperFactory.address, deployer),
+    convexCurveLpStakingWrapperPriceFeed: new (0, _protocol.ConvexCurveLpStakingWrapperPriceFeed)(fixture.ConvexCurveLpStakingWrapperPriceFeed.address, deployer),
+    convexVotingPositionLib: new (0, _protocol.ConvexVotingPositionLib)(fixture.ConvexVotingPositionLib.address, deployer),
+    convexVotingPositionParser: new (0, _protocol.ConvexVotingPositionParser)(fixture.ConvexVotingPositionParser.address, deployer),
+    cumulativeSlippageTolerancePolicy: new (0, _protocol.CumulativeSlippageTolerancePolicy)(fixture.CumulativeSlippageTolerancePolicy.address, deployer),
+    curveExchangeAdapter: new (0, _protocol.CurveExchangeAdapter)(fixture.CurveExchangeAdapter.address, deployer),
+    curveLiquidityAdapter: new (0, _protocol.CurveLiquidityAdapter)(fixture.CurveLiquidityAdapter.address, deployer),
+    curvePriceFeed: new (0, _protocol.CurvePriceFeed)(fixture.CurvePriceFeed.address, deployer),
+    depositWrapper: new (0, _protocol.DepositWrapper)(fixture.DepositWrapper.address, deployer),
+    dispatcher: new (0, _protocol.Dispatcher)(fixture.Dispatcher.address, deployer),
+    entranceRateBurnFee: new (0, _protocol.EntranceRateBurnFee)(fixture.EntranceRateBurnFee.address, deployer),
+    entranceRateDirectFee: new (0, _protocol.EntranceRateDirectFee)(fixture.EntranceRateDirectFee.address, deployer),
+    exitRateBurnFee: new (0, _protocol.ExitRateBurnFee)(fixture.ExitRateBurnFee.address, deployer),
+    exitRateDirectFee: new (0, _protocol.ExitRateDirectFee)(fixture.ExitRateDirectFee.address, deployer),
+    externalPositionFactory: new (0, _protocol.ExternalPositionFactory)(fixture.ExternalPositionFactory.address, deployer),
+    externalPositionManager: new (0, _protocol.ExternalPositionManager)(fixture.ExternalPositionManager.address, deployer),
+    feeManager: new (0, _protocol.FeeManager)(fixture.FeeManager.address, deployer),
+    fundDeployer: new (0, _protocol.FundDeployer)(fixture.FundDeployer.address, deployer),
+    fundValueCalculator: new (0, _protocol.FundValueCalculator)(fixture.FundValueCalculator.address, deployer),
+    fundValueCalculatorRouter: new (0, _protocol.FundValueCalculatorRouter)(fixture.FundValueCalculatorRouter.address, deployer),
+    fundValueCalculatorUsdWrapper: new (0, _protocol.FundValueCalculatorUsdWrapper)(fixture.FundValueCalculatorUsdWrapper.address, deployer),
+    fuseAdapter: new (0, _protocol.FuseAdapter)(fixture.FuseAdapter.address, deployer),
+    fusePriceFeed: new (0, _protocol.FusePriceFeed)(fixture.FusePriceFeed.address, deployer),
+    gasRelayPaymasterFactory: new (0, _protocol.GasRelayPaymasterFactory)(fixture.GasRelayPaymasterFactory.address, deployer),
+    globalConfigLib: new (0, _protocol.GlobalConfigLib)(fixture.GlobalConfigLib.address, deployer),
+    globalConfigProxy: new (0, _protocol.GlobalConfigLib)(fixture.GlobalConfigProxy.address, deployer),
+    idleAdapter: new (0, _protocol.IdleAdapter)(fixture.IdleAdapter.address, deployer),
+    idlePriceFeed: new (0, _protocol.IdlePriceFeed)(fixture.IdlePriceFeed.address, deployer),
+    integrationManager: new (0, _protocol.IntegrationManager)(fixture.IntegrationManager.address, deployer),
+    lidoStethPriceFeed: new (0, _protocol.LidoStethPriceFeed)(fixture.LidoStethPriceFeed.address, deployer),
+    liquityDebtPositionLib: new (0, _protocol.LiquityDebtPositionLib)(fixture.LiquityDebtPositionLib.address, deployer),
+    liquityDebtPositionParser: new (0, _protocol.LiquityDebtPositionParser)(fixture.LiquityDebtPositionParser.address, deployer),
+    managementFee: new (0, _protocol.ManagementFee)(fixture.ManagementFee.address, deployer),
+    mapleLiquidityPositionLib: new (0, _protocol.MapleLiquidityPositionLib)(fixture.MapleLiquidityPositionLib.address, deployer),
+    mapleLiquidityPositionParser: new (0, _protocol.MapleLiquidityPositionParser)(fixture.MapleLiquidityPositionParser.address, deployer),
+    minAssetBalancesPostRedemptionPolicy: new (0, _protocol.MinAssetBalancesPostRedemptionPolicy)(fixture.MinAssetBalancesPostRedemptionPolicy.address, deployer),
+    minMaxInvestmentPolicy: new (0, _protocol.MinMaxInvestmentPolicy)(fixture.MinMaxInvestmentPolicy.address, deployer),
+    olympusV2Adapter: new (0, _protocol.OlympusV2Adapter)(fixture.OlympusV2Adapter.address, deployer),
+    onlyRemoveDustExternalPositionPolicy: new (0, _protocol.OnlyRemoveDustExternalPositionPolicy)(fixture.OnlyRemoveDustExternalPositionPolicy.address, deployer),
+    onlyUntrackDustOrPricelessAssetsPolicy: new (0, _protocol.OnlyUntrackDustOrPricelessAssetsPolicy)(fixture.OnlyUntrackDustOrPricelessAssetsPolicy.address, deployer),
+    paraSwapV5Adapter: new (0, _protocol.ParaSwapV5Adapter)(fixture.ParaSwapV5Adapter.address, deployer),
+    performanceFee: new (0, _protocol.PerformanceFee)(fixture.PerformanceFee.address, deployer),
+    policyManager: new (0, _protocol.PolicyManager)(fixture.PolicyManager.address, deployer),
+    poolTogetherV4Adapter: new (0, _protocol.PoolTogetherV4Adapter)(fixture.PoolTogetherV4Adapter.address, deployer),
+    poolTogetherV4PriceFeed: new (0, _protocol.PoolTogetherV4PriceFeed)(fixture.PoolTogetherV4PriceFeed.address, deployer),
+    protocolFeeReserveLib: new (0, _protocol.ProtocolFeeReserveLib)(fixture.ProtocolFeeReserveLib.address, deployer),
+    protocolFeeReserveProxy: new (0, _protocol.ProtocolFeeReserveLib)(fixture.ProtocolFeeReserveProxy.address, deployer),
+    protocolFeeTracker: new (0, _protocol.ProtocolFeeTracker)(fixture.ProtocolFeeTracker.address, deployer),
+    revertingPriceFeed: new (0, _protocol.RevertingPriceFeed)(fixture.RevertingPriceFeed.address, deployer),
+    sharesSplitterFactory: new (0, _protocol.SharesSplitterFactory)(fixture.SharesSplitterFactory.address, deployer),
+    synthetixAdapter: new (0, _protocol.SynthetixAdapter)(fixture.SynthetixAdapter.address, deployer),
+    uniswapV2ExchangeAdapter: new (0, _protocol.UniswapV2ExchangeAdapter)(fixture.UniswapV2ExchangeAdapter.address, deployer),
+    uniswapV2LiquidityAdapter: new (0, _protocol.UniswapV2LiquidityAdapter)(fixture.UniswapV2LiquidityAdapter.address, deployer),
+    uniswapV2PoolPriceFeed: new (0, _protocol.UniswapV2PoolPriceFeed)(fixture.UniswapV2PoolPriceFeed.address, deployer),
+    uniswapV3Adapter: new (0, _protocol.UniswapV3Adapter)(fixture.UniswapV3Adapter.address, deployer),
+    unpermissionedActionsWrapper: new (0, _protocol.UnpermissionedActionsWrapper)(fixture.UnpermissionedActionsWrapper.address, deployer),
+    usdEthSimulatedAggregator: new (0, _protocol.UsdEthSimulatedAggregator)(fixture.UsdEthSimulatedAggregator.address, deployer),
+    valueInterpreter: new (0, _protocol.ValueInterpreter)(fixture.ValueInterpreter.address, deployer),
+    vaultLib: new (0, _protocol.VaultLib)(fixture.VaultLib.address, deployer),
+    yearnVaultV2Adapter: new (0, _protocol.YearnVaultV2Adapter)(fixture.YearnVaultV2Adapter.address, deployer),
+    yearnVaultV2PriceFeed: new (0, _protocol.YearnVaultV2PriceFeed)(fixture.YearnVaultV2PriceFeed.address, deployer),
+    zeroExV2Adapter: new (0, _protocol.ZeroExV2Adapter)(fixture.ZeroExV2Adapter.address, deployer)
+  };
+  return {
+    accounts,
+    config,
+    deployer,
+    deployment
+  };
+}
+
+// src/gasRelayer.ts
+
+
+async function relayTransaction(options) {
+  const signer = options.sendFunction.contract.signer;
+  if (!(signer && _protocol.isTypedDataSigner.call(void 0, signer))) {
+    throw new Error("Missing or invalid signer");
+  }
+  const { relayData, relayRequest, signedRelayRequest } = await _protocol.createSignedRelayRequest.call(void 0, options);
+  const defaultGasLimit = 1245e4;
+  const defaultMaxAcceptance = _ethers3.BigNumber.from(15e4);
+  const mergedRelayRequest = {
+    relayData,
+    request: relayRequest
+  };
+  const relayHub = new (0, _protocol.IGsnRelayHub)(options.relayHub, provider.getSigner(options.relayWorker));
+  return relayHub.relayCall.args(defaultMaxAcceptance, mergedRelayRequest, signedRelayRequest, "0x", defaultGasLimit).gas(defaultGasLimit, relayData.gasPrice).send();
+}
+var relayed = _ethers3.utils.EventFragment.fromString("TransactionRelayed(address indexed relayManager, address indexed relayWorker, address indexed from, address to, address paymaster, bytes4 selector, uint8 status, uint256 charge)");
+var rejected = _ethers3.utils.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(_ethers3.utils.toUtf8String(`0x${params.reason.substr(138)}`)).toMatch(reason);
+}
+
+// src/scaffolding/extensions/integrations/trackedAssets.ts
+
+
+
+
+
+function addTrackedAssetsToVault({
+  signer,
+  comptrollerProxy,
+  integrationManager,
+  assets
+}) {
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.AddTrackedAssetsToVault, _protocol.addTrackedAssetsToVaultArgs.call(void 0, { assets }));
+}
+function removeTrackedAssetsFromVault({
+  signer,
+  comptrollerProxy,
+  integrationManager,
+  assets
+}) {
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.RemoveTrackedAssetsFromVault, _protocol.removeTrackedAssetsFromVaultArgs.call(void 0, { 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
+
+
+async function getAssetBalances({ account, assets }) {
+  return Promise.all(assets.map((asset) => new (0, _protocol.StandardToken)(asset, provider).balanceOf(account)));
+}
+async function getAssetUnit(asset) {
+  return _ethers3.utils.parseUnits("1", await asset.decimals());
+}
+
+// src/scaffolding/core.ts
+
+
+
+
+
+
+
+
+
+
+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 _protocol.FundDeployer.deploy(deployer, dispatcher, gasRelayPaymasterFactory);
+  const nextPolicyManager = await _protocol.PolicyManager.deploy(deployer, nextFundDeployer, gasRelayPaymasterFactory);
+  const nextExternalPositionManager = await _protocol.ExternalPositionManager.deploy(deployer, nextFundDeployer, await externalPositionManager.getExternalPositionFactory(), nextPolicyManager);
+  const nextFeeManager = await _protocol.FeeManager.deploy(deployer, nextFundDeployer);
+  const nextIntegrationManager = await _protocol.IntegrationManager.deploy(deployer, nextFundDeployer, nextPolicyManager, valueInterpreter);
+  const nextComptrollerLib = await _protocol.ComptrollerLib.deploy(deployer, dispatcher, protocolFeeReserve, nextFundDeployer, valueInterpreter, nextExternalPositionManager, nextFeeManager, nextIntegrationManager, nextPolicyManager, gasRelayPaymasterFactory, mlnToken, wethToken);
+  await nextFundDeployer.setComptrollerLib(nextComptrollerLib);
+  const nextProtocolFeeTracker = await _protocol.ProtocolFeeTracker.deploy(deployer, nextFundDeployer);
+  await nextFundDeployer.setProtocolFeeTracker(nextProtocolFeeTracker);
+  const nextVaultLib = await _protocol.VaultLib.deploy(deployer, externalPositionManager, await vaultLib.getGasRelayPaymasterFactory(), await vaultLib.getProtocolFeeReserve(), nextProtocolFeeTracker, await vaultLib.getMlnToken(), await vaultLib.getMlnBurner(), await vaultLib.getWethToken(), await vaultLib.getPositionsLimit());
+  await nextFundDeployer.setVaultLib(nextVaultLib);
+  if (setReleaseLive) {
+    await nextFundDeployer.setReleaseLive();
+  }
+  if (setOnDispatcher) {
+    await dispatcher.setCurrentFundDeployer(nextFundDeployer);
+  }
+  return nextFundDeployer;
+}
+
+// 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
+
+
+
+
+
+
+
+
+
+
+// src/scaffolding/extensions/external-positions/actions.ts
+
+
+
+
+
+
+
+
+
+async function callOnExternalPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  actionId,
+  actionArgs
+}) {
+  const callArgs = _protocol.callOnExternalPositionArgs.call(void 0, {
+    actionArgs,
+    actionId,
+    externalPositionProxy
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, _protocol.ExternalPositionManagerActionId.CallOnExternalPosition, callArgs);
+}
+async function createExternalPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionTypeId,
+  initializationData = "0x",
+  callOnExternalPositionData = "0x"
+}) {
+  const receipt = await comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, _protocol.ExternalPositionManagerActionId.CreateExternalPosition, _protocol.encodeArgs.call(void 0, ["uint256", "bytes", "bytes"], [externalPositionTypeId, initializationData, callOnExternalPositionData]));
+  const event = _ethers.extractEvent.call(void 0, receipt, externalPositionManager.abi.getEvent("ExternalPositionDeployedForFund"));
+  const externalPositionProxy = new (0, _protocol.IExternalPositionProxy)(event[0].args.externalPosition, signer);
+  return { externalPositionProxy, receipt };
+}
+async function reactivateExternalPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy
+}) {
+  const callArgs = _protocol.externalPositionReactivateArgs.call(void 0, { externalPositionProxy });
+  return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, _protocol.ExternalPositionManagerActionId.ReactivateExternalPosition, callArgs);
+}
+async function removeExternalPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy
+}) {
+  const callArgs = _protocol.externalPositionRemoveArgs.call(void 0, { externalPositionProxy });
+  return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, _protocol.ExternalPositionManagerActionId.RemoveExternalPosition, callArgs);
+}
+
+// src/scaffolding/extensions/external-positions/aave-debt.ts
+async function aaveDebtPositionAddCollateral({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  aTokens,
+  amounts,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.aaveDebtPositionAddCollateralArgs.call(void 0, {
+    aTokens,
+    amounts
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.AaveDebtPositionActionId.AddCollateralAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function aaveDebtPositionBorrow({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  tokens,
+  amounts,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.aaveDebtPositionBorrowArgs.call(void 0, {
+    amounts,
+    tokens
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.AaveDebtPositionActionId.BorrowAsset,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function aaveDebtPositionClaimRewards({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  assets,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.aaveDebtPositionClaimRewardsArgs.call(void 0, {
+    assets
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.AaveDebtPositionActionId.ClaimRewards,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function aaveDebtPositionRemoveCollateral({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  aTokens,
+  amounts,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.aaveDebtPositionRemoveCollateralArgs.call(void 0, {
+    aTokens,
+    amounts
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.AaveDebtPositionActionId.RemoveCollateralAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function aaveDebtPositionRepayBorrow({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  tokens,
+  amounts,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.aaveDebtPositionRepayBorrowArgs.call(void 0, {
+    amounts,
+    tokens
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.AaveDebtPositionActionId.RepayBorrowedAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function createAaveDebtPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager
+}) {
+  return createExternalPosition({
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: _protocol.ExternalPositionType.AaveDebtPosition,
+    signer
+  });
+}
+
+// src/scaffolding/extensions/external-positions/compound.ts
+
+
+
+
+
+
+async function compoundDebtPositionAddCollateral({
+  comptrollerProxy,
+  externalPositionManager,
+  fundOwner,
+  assets,
+  amounts,
+  externalPositionProxy,
+  cTokens
+}) {
+  const actionArgs = _protocol.compoundExternalPositionActionArgs.call(void 0, {
+    amounts,
+    assets,
+    data: _protocol.encodeArgs.call(void 0, ["address[]"], [cTokens])
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.CompoundDebtPositionActionId.AddCollateralAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer: fundOwner
+  });
+}
+async function compoundDebtPositionBorrow({
+  comptrollerProxy,
+  externalPositionManager,
+  fundOwner,
+  externalPositionProxy,
+  assets,
+  amounts,
+  cTokens
+}) {
+  const actionArgs = _protocol.compoundExternalPositionActionArgs.call(void 0, {
+    amounts,
+    assets,
+    data: _protocol.encodeArgs.call(void 0, ["address[]"], [cTokens])
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.CompoundDebtPositionActionId.BorrowAsset,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer: fundOwner
+  });
+}
+async function compoundDebtPositionClaimComp({
+  comptrollerProxy,
+  externalPositionManager,
+  fundOwner,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.compoundExternalPositionActionArgs.call(void 0, {
+    amounts: [],
+    assets: [],
+    data: "0x"
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.CompoundDebtPositionActionId.ClaimComp,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer: fundOwner
+  });
+}
+async function compoundDebtPositionRemoveCollateral({
+  comptrollerProxy,
+  externalPositionManager,
+  fundOwner,
+  assets,
+  amounts,
+  externalPositionProxy,
+  cTokens
+}) {
+  const actionArgs = _protocol.compoundExternalPositionActionArgs.call(void 0, {
+    amounts,
+    assets,
+    data: _protocol.encodeArgs.call(void 0, ["address[]"], [cTokens])
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.CompoundDebtPositionActionId.RemoveCollateralAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer: fundOwner
+  });
+}
+async function compoundDebtPositionRepayBorrow({
+  comptrollerProxy,
+  externalPositionManager,
+  fundOwner,
+  assets,
+  amounts,
+  externalPositionProxy,
+  cTokens
+}) {
+  const actionArgs = _protocol.compoundExternalPositionActionArgs.call(void 0, {
+    amounts,
+    assets,
+    data: _protocol.encodeArgs.call(void 0, ["address[]"], [cTokens])
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.CompoundDebtPositionActionId.RepayBorrowedAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer: fundOwner
+  });
+}
+async function createCompoundDebtPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager
+}) {
+  return createExternalPosition({
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: _protocol.ExternalPositionType.CompoundDebtPosition,
+    signer
+  });
+}
+
+// src/scaffolding/extensions/external-positions/convex-voting.ts
+
+
+
+
+
+
+
+
+function createConvexVotingPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager
+}) {
+  return createExternalPosition({
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: _protocol.ExternalPositionType.ConvexVotingPosition,
+    signer
+  });
+}
+function convexVotingPositionClaimRewards({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  externalPositionProxy,
+  claimLockerRewards,
+  extraRewardTokens,
+  votiumClaims,
+  unstakeCvxCrv,
+  allTokensToTransfer
+}) {
+  const actionArgs = _protocol.convexVotingPositionClaimRewardsArgs.call(void 0, {
+    allTokensToTransfer,
+    claimLockerRewards,
+    extraRewardTokens,
+    unstakeCvxCrv,
+    votiumClaims
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.ConvexVotingPositionActionId.ClaimRewards,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+function convexVotingPositionDelegate({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  externalPositionProxy,
+  delegatee
+}) {
+  const actionArgs = _protocol.convexVotingPositionDelegateArgs.call(void 0, {
+    delegatee
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.ConvexVotingPositionActionId.Delegate,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+function convexVotingPositionLock({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  externalPositionProxy,
+  amount,
+  spendRatio = _ethers3.BigNumber.from(0)
+}) {
+  const actionArgs = _protocol.convexVotingPositionLockArgs.call(void 0, {
+    amount,
+    spendRatio
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.ConvexVotingPositionActionId.Lock,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+function convexVotingPositionRelock({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  externalPositionProxy
+}) {
+  return callOnExternalPosition({
+    actionArgs: "0x",
+    actionId: _protocol.ConvexVotingPositionActionId.Relock,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+function convexVotingPositionWithdraw({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  externalPositionProxy
+}) {
+  return callOnExternalPosition({
+    actionArgs: "0x",
+    actionId: _protocol.ConvexVotingPositionActionId.Withdraw,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+
+// src/scaffolding/extensions/external-positions/liquity-debt.ts
+
+
+
+
+
+
+
+
+
+
+
+var ILiquityTroveManager = _ethers.contract.call(void 0, )`
+  function getBorrowingFee(uint256) external returns (uint256)
+`;
+var ILiquityHintHelper = _ethers.contract.call(void 0, )`
+  function getApproxHint(uint256, uint256, uint256) external returns (address, uint256, uint256)
+`;
+var ILiquitySortedTroves = _ethers.contract.call(void 0, )`
+  function findInsertPosition(uint256, address, address) external view returns (address, address)
+`;
+async function createLiquityDebtPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager
+}) {
+  return createExternalPosition({
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: _protocol.ExternalPositionType.LiquityDebtPosition,
+    signer
+  });
+}
+async function liquityCalcHints({
+  collateralAmount,
+  lusdAmount,
+  numTrials = _ethers3.BigNumber.from("15"),
+  liquitySortedTroves,
+  liquityHintHelper,
+  inputRandomSeed = _ethers3.BigNumber.from("4")
+}) {
+  const nicr = collateralAmount.mul(_ethers3.utils.parseEther("100")).div(lusdAmount);
+  const approxHint = await liquityHintHelper.getApproxHint.args(nicr, numTrials, inputRandomSeed).call();
+  const hints = await liquitySortedTroves.findInsertPosition.args(nicr, approxHint[0], approxHint[0]).call();
+  return hints;
+}
+async function liquityDebtPositionAddCollateral({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  collateralAmount,
+  lowerHint,
+  upperHint,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.liquityDebtPositionAddCollateralArgs.call(void 0, {
+    collateralAmount,
+    lowerHint,
+    upperHint
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.LiquityDebtPositionActionId.AddCollateral,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function liquityDebtPositionBorrow({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  maxFeePercentage,
+  lusdAmount,
+  lowerHint,
+  upperHint,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.liquityDebtPositionBorrowArgs.call(void 0, {
+    lowerHint,
+    lusdAmount,
+    maxFeePercentage,
+    upperHint
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.LiquityDebtPositionActionId.Borrow,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function liquityDebtPositionCloseTrove({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  externalPositionProxy
+}) {
+  const actionArgs = "0x";
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.LiquityDebtPositionActionId.CloseTrove,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function liquityDebtPositionOpenTrove({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  maxFeePercentage,
+  collateralAmount,
+  lusdAmount,
+  lowerHint,
+  upperHint,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.liquityDebtPositionOpenTroveArgs.call(void 0, {
+    collateralAmount,
+    lowerHint,
+    lusdAmount,
+    maxFeePercentage,
+    upperHint
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.LiquityDebtPositionActionId.OpenTrove,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function liquityDebtPositionRemoveCollateral({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  collateralAmount,
+  lowerHint,
+  upperHint,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.liquityDebtPositionRemoveCollateralArgs.call(void 0, {
+    collateralAmount,
+    lowerHint,
+    upperHint
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.LiquityDebtPositionActionId.RemoveCollateral,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function liquityDebtPositionRepay({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  lusdAmount,
+  lowerHint,
+  upperHint,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.liquityDebtPositionRepayBorrowArgs.call(void 0, {
+    lowerHint,
+    lusdAmount,
+    upperHint
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.LiquityDebtPositionActionId.Repay,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+
+// src/scaffolding/extensions/external-positions/maple-liquidity.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+async function createMapleLiquidityPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager
+}) {
+  return createExternalPosition({
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: _protocol.ExternalPositionType.MapleLiquidityPosition,
+    signer
+  });
+}
+async function mapleLiquidityPositionClaimInterest({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  pool,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.mapleLiquidityPositionClaimInterestArgs.call(void 0, {
+    pool
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.MapleLiquidityPositionActionId.ClaimInterest,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionClaimRewards({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  rewardsContract,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.mapleLiquidityPositionClaimRewardsArgs.call(void 0, {
+    rewardsContract
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.MapleLiquidityPositionActionId.ClaimRewards,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionIntendToRedeem({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  pool,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.mapleLiquidityPositionIntendToRedeemArgs.call(void 0, {
+    pool
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.MapleLiquidityPositionActionId.IntendToRedeem,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionLend({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  liquidityAssetAmount,
+  pool,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.mapleLiquidityPositionLendArgs.call(void 0, {
+    liquidityAssetAmount,
+    pool
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.MapleLiquidityPositionActionId.Lend,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionLendAndStake({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  liquidityAssetAmount,
+  pool,
+  rewardsContract,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.mapleLiquidityPositionLendAndStakeArgs.call(void 0, {
+    liquidityAssetAmount,
+    pool,
+    rewardsContract
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.MapleLiquidityPositionActionId.LendAndStake,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionRedeem({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  liquidityAssetAmount,
+  pool,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.mapleLiquidityPositionRedeemArgs.call(void 0, {
+    liquidityAssetAmount,
+    pool
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.MapleLiquidityPositionActionId.Redeem,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionStake({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  poolTokenAmount,
+  pool,
+  rewardsContract,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.mapleLiquidityPositionStakeArgs.call(void 0, {
+    pool,
+    poolTokenAmount,
+    rewardsContract
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.MapleLiquidityPositionActionId.Stake,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionUnstake({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  poolTokenAmount,
+  rewardsContract,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.mapleLiquidityPositionUnstakeArgs.call(void 0, {
+    poolTokenAmount,
+    rewardsContract
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.MapleLiquidityPositionActionId.Unstake,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mapleLiquidityPositionUnstakeAndRedeem({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  pool,
+  poolTokenAmount,
+  rewardsContract,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.mapleLiquidityPositionUnstakeAndRedeemArgs.call(void 0, {
+    pool,
+    poolTokenAmount,
+    rewardsContract
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.MapleLiquidityPositionActionId.UnstakeAndRedeem,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+
+// src/scaffolding/extensions/external-positions/mocks.ts
+
+
+
+
+
+
+
+async function createMockExternalPosition({
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionFactory,
+  defaultActionAssetsToTransfer,
+  defaultActionAmountsToTransfer,
+  defaultActionAssetsToReceive,
+  fundOwner,
+  deployer
+}) {
+  const vaultProxy = new (0, _protocol.VaultLib)(await comptrollerProxy.getVaultProxy(), deployer);
+  const typeId = await externalPositionFactory.getPositionTypeCounter();
+  await externalPositionFactory.addNewPositionTypes(["TEST"]);
+  const mockGenericExternalPositionLib = await _protocol.MockGenericExternalPositionLib.deploy(deployer);
+  const mockExternalPositionParser = await _protocol.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 = _protocol.mockGenericExternalPositionActionArgs.call(void 0, {
+    amounts,
+    assets
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.MockGenericExternalPositionActionId.AddDebtAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mockExternalPositionAddManagedAssets({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  assets,
+  amounts
+}) {
+  const actionArgs = _protocol.mockGenericExternalPositionActionArgs.call(void 0, {
+    amounts,
+    assets
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.MockGenericExternalPositionActionId.AddManagedAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mockExternalPositionRemoveDebtAssets({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  assets,
+  amounts
+}) {
+  const actionArgs = _protocol.mockGenericExternalPositionActionArgs.call(void 0, {
+    amounts,
+    assets
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.MockGenericExternalPositionActionId.RemoveDebtAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function mockExternalPositionRemoveManagedAssets({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  assets,
+  amounts
+}) {
+  const actionArgs = _protocol.mockGenericExternalPositionActionArgs.call(void 0, {
+    amounts,
+    assets
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.MockGenericExternalPositionActionId.RemoveManagedAssets,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+
+// src/scaffolding/extensions/external-positions/the-graph-delegation.ts
+
+
+
+
+
+
+
+async function theGraphDelegationPositionDelegate({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  indexer,
+  tokens,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.theGraphDelegationPositionDelegateArgs.call(void 0, {
+    indexer,
+    tokens
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.TheGraphDelegationPositionActionId.Delegate,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function theGraphDelegationPositionUndelegate({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  indexer,
+  shares,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.theGraphDelegationPositionUndelegateArgs.call(void 0, {
+    indexer,
+    shares
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.TheGraphDelegationPositionActionId.Undelegate,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function theGraphDelegationPositionWithdraw({
+  comptrollerProxy,
+  externalPositionManager,
+  signer,
+  indexer,
+  nextIndexer,
+  externalPositionProxy
+}) {
+  const actionArgs = _protocol.theGraphDelegationPositionWithdrawArgs.call(void 0, {
+    indexer,
+    nextIndexer
+  });
+  return callOnExternalPosition({
+    actionArgs,
+    actionId: _protocol.TheGraphDelegationPositionActionId.Withdraw,
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionProxy,
+    signer
+  });
+}
+async function createTheGraphDelegationPosition({
+  signer,
+  comptrollerProxy,
+  externalPositionManager
+}) {
+  return createExternalPosition({
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: _protocol.ExternalPositionType.TheGraphDelegationPosition,
+    signer
+  });
+}
+
+// src/scaffolding/extensions/external-positions/uniswap-v3-liquidity.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+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 = _ethers.contract.call(void 0, )`
+  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: _protocol.ExternalPositionType.UniswapV3LiquidityPosition,
+    signer
+  });
+  return { externalPositionProxyAddress: externalPositionProxyContract.address, receipt };
+}
+async function uniswapV3LiquidityPositionAddLiquidity({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  nftId,
+  amount0Desired,
+  amount1Desired,
+  amount0Min = 0,
+  amount1Min = 0
+}) {
+  const actionArgs = _protocol.uniswapV3LiquidityPositionAddLiquidityArgs.call(void 0, {
+    amount0Desired,
+    amount0Min,
+    amount1Desired,
+    amount1Min,
+    nftId
+  });
+  const callArgs = _protocol.callOnExternalPositionArgs.call(void 0, {
+    actionArgs,
+    actionId: _protocol.UniswapV3LiquidityPositionActionId.AddLiquidity,
+    externalPositionProxy
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, _protocol.ExternalPositionManagerActionId.CallOnExternalPosition, callArgs);
+}
+async function uniswapV3LiquidityPositionCollect({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  nftId
+}) {
+  const actionArgs = _protocol.uniswapV3LiquidityPositionCollectArgs.call(void 0, {
+    nftId
+  });
+  const callArgs = _protocol.callOnExternalPositionArgs.call(void 0, {
+    actionArgs,
+    actionId: _protocol.UniswapV3LiquidityPositionActionId.Collect,
+    externalPositionProxy
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, _protocol.ExternalPositionManagerActionId.CallOnExternalPosition, callArgs);
+}
+async function uniswapV3LiquidityPositionMint({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  token0,
+  token1,
+  fee,
+  tickLower,
+  tickUpper,
+  amount0Desired,
+  amount1Desired,
+  amount0Min = 0,
+  amount1Min = 0
+}) {
+  const actionArgs = _protocol.uniswapV3LiquidityPositionMintArgs.call(void 0, {
+    amount0Desired,
+    amount0Min,
+    amount1Desired,
+    amount1Min,
+    fee,
+    tickLower,
+    tickUpper,
+    token0,
+    token1
+  });
+  const callArgs = _protocol.callOnExternalPositionArgs.call(void 0, {
+    actionArgs,
+    actionId: _protocol.UniswapV3LiquidityPositionActionId.Mint,
+    externalPositionProxy
+  });
+  const receipt = await comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, _protocol.ExternalPositionManagerActionId.CallOnExternalPosition, callArgs);
+  const externalPosition = new (0, _protocol.UniswapV3LiquidityPositionLib)(externalPositionProxy, provider);
+  const nftId = _ethers.extractEvent.call(void 0, 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 = _protocol.uniswapV3LiquidityPositionPurgeArgs.call(void 0, {
+    amount0Min,
+    amount1Min,
+    liquidity,
+    nftId
+  });
+  const callArgs = _protocol.callOnExternalPositionArgs.call(void 0, {
+    actionArgs,
+    actionId: _protocol.UniswapV3LiquidityPositionActionId.Purge,
+    externalPositionProxy
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, _protocol.ExternalPositionManagerActionId.CallOnExternalPosition, callArgs);
+}
+async function uniswapV3LiquidityPositionRemoveLiquidity({
+  signer,
+  comptrollerProxy,
+  externalPositionManager,
+  externalPositionProxy,
+  nftId,
+  liquidity,
+  amount0Min = 0,
+  amount1Min = 0
+}) {
+  const actionArgs = _protocol.uniswapV3LiquidityPositionRemoveLiquidityArgs.call(void 0, {
+    amount0Min,
+    amount1Min,
+    liquidity,
+    nftId
+  });
+  const callArgs = _protocol.callOnExternalPositionArgs.call(void 0, {
+    actionArgs,
+    actionId: _protocol.UniswapV3LiquidityPositionActionId.RemoveLiquidity,
+    externalPositionProxy
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(externalPositionManager, _protocol.ExternalPositionManagerActionId.CallOnExternalPosition, callArgs);
+}
+function uniswapV3OrderTokenPair({ tokenA, tokenB }) {
+  const tokenAAddress = _ethers.resolveAddress.call(void 0, tokenA);
+  const tokenBAddress = _ethers.resolveAddress.call(void 0, tokenB);
+  return tokenAAddress < tokenBAddress ? { token0: tokenAAddress, token1: tokenBAddress } : { token0: tokenBAddress, token1: tokenAAddress };
+}
+
+// src/scaffolding/extensions/fees.ts
+
+
+async function generateFeeManagerConfigWithMockFees({ deployer }) {
+  const fees = await generateMockFees({
+    deployer
+  });
+  const feeManagerSettingsData = [_ethers3.utils.randomBytes(10), "0x", _ethers3.utils.randomBytes(2)];
+  return _protocol.feeManagerConfigArgs.call(void 0, {
+    fees: Object.values(fees),
+    settings: feeManagerSettingsData
+  });
+}
+async function generateMockFees({ deployer }) {
+  const mockContinuousFeeSettleOnly = await _protocol.IFee.mock(deployer);
+  const mockContinuousFeeWithGavAndUpdates = await _protocol.IFee.mock(deployer);
+  const mockPostBuySharesFee = await _protocol.IFee.mock(deployer);
+  await Promise.all([
+    mockContinuousFeeSettleOnly.getRecipientForFund.returns(_ethers3.constants.AddressZero),
+    mockContinuousFeeSettleOnly.settle.returns(_protocol.FeeSettlementType.None, _ethers3.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(_protocol.FeeHook.Continuous).returns(true, false),
+    mockContinuousFeeSettleOnly.settlesOnHook.given(_protocol.FeeHook.PreBuyShares).returns(true, false),
+    mockContinuousFeeSettleOnly.settlesOnHook.given(_protocol.FeeHook.PreRedeemShares).returns(true, false),
+    mockContinuousFeeSettleOnly.updatesOnHook.returns(false, false),
+    mockContinuousFeeWithGavAndUpdates.getRecipientForFund.returns(_ethers3.constants.AddressZero),
+    mockContinuousFeeWithGavAndUpdates.settle.returns(_protocol.FeeSettlementType.None, _ethers3.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(_protocol.FeeHook.Continuous).returns(true, true),
+    mockContinuousFeeWithGavAndUpdates.settlesOnHook.given(_protocol.FeeHook.PreBuyShares).returns(true, true),
+    mockContinuousFeeWithGavAndUpdates.settlesOnHook.given(_protocol.FeeHook.PreRedeemShares).returns(true, true),
+    mockContinuousFeeWithGavAndUpdates.updatesOnHook.returns(false, false),
+    mockContinuousFeeWithGavAndUpdates.updatesOnHook.given(_protocol.FeeHook.Continuous).returns(true, true),
+    mockContinuousFeeWithGavAndUpdates.updatesOnHook.given(_protocol.FeeHook.PostBuyShares).returns(true, true),
+    mockContinuousFeeWithGavAndUpdates.updatesOnHook.given(_protocol.FeeHook.PreRedeemShares).returns(true, true),
+    mockPostBuySharesFee.getRecipientForFund.returns(_ethers3.constants.AddressZero),
+    mockPostBuySharesFee.settle.returns(_protocol.FeeSettlementType.None, _ethers3.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(_protocol.FeeHook.PostBuyShares).returns(true, false),
+    mockPostBuySharesFee.updatesOnHook.returns(false, false)
+  ]);
+  return {
+    mockContinuousFeeSettleOnly,
+    mockContinuousFeeWithGavAndUpdates,
+    mockPostBuySharesFee
+  };
+}
+
+// src/scaffolding/extensions/integrations/aave.ts
+
+
+
+
+
+
+
+
+
+async function aaveLend({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  aaveAdapter,
+  aToken,
+  amount = _ethers3.utils.parseEther("1")
+}) {
+  const lendArgs = _protocol.aaveLendArgs.call(void 0, {
+    aToken,
+    amount
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: aaveAdapter,
+    encodedCallArgs: lendArgs,
+    selector: _protocol.lendSelector
+  });
+  const lendTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+  return lendTx;
+}
+async function aaveRedeem({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  aaveAdapter,
+  aToken,
+  amount = _ethers3.utils.parseEther("1")
+}) {
+  const redeemArgs = _protocol.aaveRedeemArgs.call(void 0, {
+    aToken,
+    amount
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: aaveAdapter,
+    encodedCallArgs: redeemArgs,
+    selector: _protocol.redeemSelector
+  });
+  const redeemTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+  return redeemTx;
+}
+
+// src/scaffolding/extensions/integrations/compound.ts
+
+
+
+
+
+
+
+
+
+
+
+
+var ICompoundComptroller = _ethers.contract.call(void 0, )`
+  function claimComp(address)
+`;
+async function assertCompoundLend({
+  tokenWhale,
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  fundOwner,
+  compoundAdapter,
+  tokenAmount = _ethers3.utils.parseEther("1"),
+  cToken,
+  compoundPriceFeed
+}) {
+  const token = new (0, _protocol.StandardToken)(await compoundPriceFeed.getTokenFromCToken.args(cToken).call(), tokenWhale);
+  await token.connect(tokenWhale).transfer(vaultProxy, tokenAmount);
+  const rateBefore = await cToken.exchangeRateStored.call();
+  const minIncomingCTokenAmount = tokenAmount.mul(_ethers3.utils.parseEther("1")).div(rateBefore).mul(_ethers3.BigNumber.from("999")).div(_ethers3.BigNumber.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(_ethers3.utils.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 = _ethers3.utils.parseUnits("1", await cToken.decimals());
+  await cToken.transfer(vaultProxy, cTokenAmount);
+  const token = new (0, _protocol.StandardToken)(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(_ethers3.utils.parseEther("1"));
+  const redeemReceipt = await compoundRedeem({
+    cToken,
+    cTokenAmount,
+    compoundAdapter,
+    comptrollerProxy,
+    fundOwner,
+    integrationManager,
+    tokenAmount: minIncomingTokenAmount,
+    vaultProxy
+  });
+  const [postTxIncomingAssetBalance, postTxOutgoingAssetBalance] = await getAssetBalances({
+    account: vaultProxy,
+    assets: [token, cToken]
+  });
+  const rate = await cToken.exchangeRateStored();
+  const expectedTokenAmount = cTokenAmount.mul(rate).div(_ethers3.utils.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 = _protocol.compoundClaimRewardsArgs.call(void 0, {
+    cTokens,
+    compoundComptroller
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: compoundAdapter,
+    encodedCallArgs: claimArgs,
+    selector: _protocol.claimRewardsSelector
+  });
+  const claimRewardsTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+  return claimRewardsTx;
+}
+async function compoundLend({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  compoundAdapter,
+  cToken,
+  tokenAmount = _ethers3.utils.parseEther("1"),
+  cTokenAmount = _ethers3.utils.parseEther("1")
+}) {
+  const lendArgs = _protocol.compoundArgs.call(void 0, {
+    cToken,
+    minIncomingAssetAmount: cTokenAmount,
+    outgoingAssetAmount: tokenAmount
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: compoundAdapter,
+    encodedCallArgs: lendArgs,
+    selector: _protocol.lendSelector
+  });
+  const lendTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+  return lendTx;
+}
+async function compoundRedeem({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  compoundAdapter,
+  cToken,
+  tokenAmount = _ethers3.utils.parseEther("1"),
+  cTokenAmount = _ethers3.utils.parseEther("1")
+}) {
+  const redeemArgs = _protocol.compoundArgs.call(void 0, {
+    cToken: _ethers.resolveAddress.call(void 0, cToken),
+    minIncomingAssetAmount: tokenAmount,
+    outgoingAssetAmount: cTokenAmount
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: compoundAdapter,
+    encodedCallArgs: redeemArgs,
+    selector: _protocol.redeemSelector
+  });
+  const redeemTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+  return redeemTx;
+}
+
+// src/scaffolding/extensions/integrations/curve.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var CurveLiquidityGaugeV2 = _ethers.contract.call(void 0, )`
+  function claim_rewards(address)
+  function integrate_fraction(address) view returns (uint256)
+`;
+var CurveRegistry = _ethers.contract.call(void 0, )`
+  function get_coins(address) view returns (address[8])
+  function get_lp_token(address) view returns (address)
+`;
+var CurveSwaps = _ethers.contract.call(void 0, )`
+  function get_best_rate(address _from, address to, uint256 amount) view returns (address bestPool, uint256 amountReceived)
+`;
+var CurveMinter = _ethers.contract.call(void 0, )`
+  function mint_for(address,address)
+`;
+async function curveTakeOrder({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  curveExchangeAdapter,
+  pool,
+  outgoingAsset,
+  outgoingAssetAmount = _ethers3.utils.parseEther("1"),
+  incomingAsset,
+  minIncomingAssetAmount = _ethers3.utils.parseEther("1")
+}) {
+  const takeOrderArgs = _protocol.curveTakeOrderArgs.call(void 0, {
+    incomingAsset,
+    minIncomingAssetAmount,
+    outgoingAsset,
+    outgoingAssetAmount,
+    pool
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: curveExchangeAdapter,
+    encodedCallArgs: takeOrderArgs,
+    selector: _protocol.takeOrderSelector
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+function curveClaimRewards({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  curveLiquidityAdapter,
+  stakingToken
+}) {
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: _protocol.curveClaimRewardsArgs.call(void 0, { stakingToken }),
+    selector: _protocol.claimRewardsSelector
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+async function curveLend({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  orderedOutgoingAssetAmounts,
+  minIncomingLpTokenAmount = _ethers3.BigNumber.from(1),
+  useUnderlyings
+}) {
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: _protocol.curveLendArgs.call(void 0, {
+      minIncomingLpTokenAmount,
+      orderedOutgoingAssetAmounts,
+      pool,
+      useUnderlyings
+    }),
+    selector: _protocol.lendSelector
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+async function curveLendAndStake({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  orderedOutgoingAssetAmounts,
+  incomingStakingToken,
+  minIncomingStakingTokenAmount = _ethers3.BigNumber.from(1),
+  useUnderlyings
+}) {
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: _protocol.curveLendAndStakeArgs.call(void 0, {
+      incomingStakingToken,
+      minIncomingStakingTokenAmount,
+      orderedOutgoingAssetAmounts,
+      pool,
+      useUnderlyings
+    }),
+    selector: _protocol.lendAndStakeSelector
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+async function curveRedeem({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  outgoingLpTokenAmount,
+  useUnderlyings,
+  redeemType,
+  incomingAssetData
+}) {
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: _protocol.curveRedeemArgs.call(void 0, {
+      incomingAssetData,
+      outgoingLpTokenAmount,
+      pool,
+      redeemType,
+      useUnderlyings
+    }),
+    selector: _protocol.redeemSelector
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+async function curveStake({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  incomingStakingToken,
+  amount
+}) {
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: _protocol.curveStakeArgs.call(void 0, {
+      amount,
+      incomingStakingToken,
+      pool
+    }),
+    selector: _protocol.stakeSelector
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+async function curveUnstake({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  outgoingStakingToken,
+  amount
+}) {
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: _protocol.curveUnstakeArgs.call(void 0, {
+      amount,
+      outgoingStakingToken,
+      pool
+    }),
+    selector: _protocol.unstakeSelector
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+async function curveUnstakeAndRedeem({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  outgoingStakingToken,
+  outgoingStakingTokenAmount,
+  useUnderlyings,
+  redeemType,
+  incomingAssetData
+}) {
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: _protocol.curveUnstakeAndRedeemArgs.call(void 0, {
+      incomingAssetData,
+      outgoingStakingToken,
+      outgoingStakingTokenAmount,
+      pool,
+      redeemType,
+      useUnderlyings
+    }),
+    selector: _protocol.unstakeAndRedeemSelector
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/integrations/idle.ts
+
+
+
+
+
+
+
+
+
+
+
+async function idleClaimRewards({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  idleAdapter,
+  idleToken
+}) {
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: idleAdapter,
+    encodedCallArgs: _protocol.idleClaimRewardsArgs.call(void 0, {
+      idleToken
+    }),
+    selector: _protocol.claimRewardsSelector
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+async function idleLend({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  idleAdapter,
+  idleToken,
+  outgoingUnderlyingAmount,
+  minIncomingIdleTokenAmount = _ethers3.BigNumber.from(1)
+}) {
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: idleAdapter,
+    encodedCallArgs: _protocol.idleLendArgs.call(void 0, {
+      idleToken,
+      minIncomingIdleTokenAmount,
+      outgoingUnderlyingAmount
+    }),
+    selector: _protocol.lendSelector
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+async function idleRedeem({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  idleAdapter,
+  idleToken,
+  outgoingIdleTokenAmount,
+  minIncomingUnderlyingAmount = _ethers3.BigNumber.from(1)
+}) {
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: idleAdapter,
+    encodedCallArgs: _protocol.idleRedeemArgs.call(void 0, {
+      idleToken,
+      minIncomingUnderlyingAmount,
+      outgoingIdleTokenAmount
+    }),
+    selector: _protocol.redeemSelector
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/integrations/mock.ts
+
+
+var mockGenericRemoveOnlySelector = _protocol.sighash.call(void 0, _ethers3.utils.FunctionFragment.fromString("removeOnly(address,bytes,bytes)"));
+var mockGenericSwapASelector = _protocol.sighash.call(void 0, _ethers3.utils.FunctionFragment.fromString("swapA(address,bytes,bytes)"));
+var mockGenericSwapBSelector = _protocol.sighash.call(void 0, _ethers3.utils.FunctionFragment.fromString("swapB(address,bytes,bytes)"));
+var mockGenericSwapDirectFromVaultSelector = _protocol.sighash.call(void 0, _ethers3.utils.FunctionFragment.fromString("swapDirectFromVault(address,bytes,bytes)"));
+var mockGenericSwapViaApprovalSelector = _protocol.sighash.call(void 0, _ethers3.utils.FunctionFragment.fromString("swapViaApproval(address,bytes,bytes)"));
+function mockGenericSwapArgs({
+  spendAssets = [],
+  actualSpendAssetAmounts = [],
+  maxSpendAssetAmounts = actualSpendAssetAmounts,
+  incomingAssets = [],
+  actualIncomingAssetAmounts = [],
+  minIncomingAssetAmounts = actualIncomingAssetAmounts
+}) {
+  return _protocol.encodeArgs.call(void 0, ["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 = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: mockGenericAdapter,
+    encodedCallArgs: swapArgs,
+    selector
+  });
+  const swapTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+  await expect(swapTx).resolves.toBeReceipt();
+  return swapTx;
+}
+
+// src/scaffolding/extensions/integrations/olympusV2.ts
+
+
+
+
+
+
+
+
+async function olympusV2Stake({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  olympusV2Adapter,
+  amount
+}) {
+  const stakeArgs = _protocol.olympusV2StakeArgs.call(void 0, {
+    amount
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: olympusV2Adapter,
+    encodedCallArgs: stakeArgs,
+    selector: _protocol.stakeSelector
+  });
+  const stakeTx = comptrollerProxy.connect(signer).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+  return stakeTx;
+}
+async function olympusV2Unstake({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  olympusV2Adapter,
+  amount
+}) {
+  const unstakeArgs = _protocol.olympusV2UnstakeArgs.call(void 0, {
+    amount
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: olympusV2Adapter,
+    encodedCallArgs: unstakeArgs,
+    selector: _protocol.unstakeSelector
+  });
+  const unstakeTx = comptrollerProxy.connect(signer).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+  return unstakeTx;
+}
+
+// src/scaffolding/extensions/integrations/paraSwapV5.ts
+
+
+
+
+
+
+
+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 = _ethers3.utils.randomBytes(16),
+  paths
+}) {
+  const takeOrderArgs = _protocol.paraSwapV5TakeOrderArgs.call(void 0, {
+    expectedIncomingAssetAmount,
+    minIncomingAssetAmount,
+    outgoingAsset,
+    outgoingAssetAmount,
+    paths,
+    uuid
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: paraSwapV5Adapter,
+    encodedCallArgs: takeOrderArgs,
+    selector: _protocol.takeOrderSelector
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/integrations/poolTogetherV4.ts
+
+
+
+
+
+
+
+
+
+
+
+async function poolTogetherV4Lend({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  poolTogetherV4Adapter,
+  ptToken,
+  amount = _ethers3.utils.parseEther("1")
+}) {
+  const lendArgs = _protocol.poolTogetherV4LendArgs.call(void 0, {
+    amount,
+    ptToken
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: poolTogetherV4Adapter,
+    encodedCallArgs: lendArgs,
+    selector: _protocol.lendSelector
+  });
+  const lendTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+  return lendTx;
+}
+async function poolTogetherV4Redeem({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  poolTogetherV4Adapter,
+  ptToken,
+  amount = _ethers3.utils.parseEther("1")
+}) {
+  const redeemArgs = _protocol.poolTogetherV4RedeemArgs.call(void 0, {
+    amount,
+    ptToken
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: poolTogetherV4Adapter,
+    encodedCallArgs: redeemArgs,
+    selector: _protocol.redeemSelector
+  });
+  const redeemTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+  return redeemTx;
+}
+async function poolTogetherV4ClaimRewards({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  poolTogetherV4Adapter,
+  prizeDistributor,
+  drawIds,
+  winningPicks
+}) {
+  const claimRewardsArgs = _protocol.poolTogetherV4ClaimRewardsArgs.call(void 0, {
+    drawIds,
+    prizeDistributor,
+    winningPicks
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: poolTogetherV4Adapter,
+    encodedCallArgs: claimRewardsArgs,
+    selector: _protocol.claimRewardsSelector
+  });
+  const claimTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+  return claimTx;
+}
+
+// src/scaffolding/extensions/integrations/synthetix.ts
+
+
+
+
+
+
+
+
+
+
+
+async function synthetixAssignExchangeDelegate({
+  comptrollerProxy,
+  synthetixDelegateApprovals,
+  fundOwner,
+  delegate
+}) {
+  await comptrollerProxy.connect(fundOwner).vaultCallOnContract(synthetixDelegateApprovals, _protocol.synthetixAssignExchangeDelegateSelector, _protocol.encodeArgs.call(void 0, ["address"], [delegate]));
+}
+async function synthetixRedeem({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  synthetixAdapter,
+  synths
+}) {
+  const redeemArgs = _protocol.synthetixRedeemArgs.call(void 0, {
+    synths
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: synthetixAdapter,
+    encodedCallArgs: redeemArgs,
+    selector: _protocol.redeemSelector
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+async function synthetixTakeOrder({
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  fundOwner,
+  synthetixAdapter,
+  outgoingAsset,
+  outgoingAssetAmount = _ethers3.utils.parseEther("1"),
+  minIncomingSusdAmount = _ethers3.utils.parseEther("1"),
+  seedFund = false
+}) {
+  if (seedFund) {
+    await outgoingAsset.transfer(vaultProxy, outgoingAssetAmount);
+  }
+  const takeOrderArgs = _protocol.synthetixTakeOrderArgs.call(void 0, {
+    minIncomingSusdAmount,
+    outgoingAsset,
+    outgoingAssetAmount
+  });
+  const callArgs = await _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: synthetixAdapter,
+    encodedCallArgs: takeOrderArgs,
+    selector: _protocol.takeOrderSelector
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/integrations/uniswapV2.ts
+
+
+
+
+
+
+
+
+
+
+
+var UniswapV2Factory = _ethers.contract.call(void 0, )`
+  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 = _protocol.uniswapV2LendArgs.call(void 0, {
+    amountADesired,
+    amountAMin,
+    amountBDesired,
+    amountBMin,
+    minPoolTokenAmount,
+    tokenA,
+    tokenB
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: uniswapV2LiquidityAdapter,
+    encodedCallArgs: lendArgs,
+    selector: _protocol.lendSelector
+  });
+  const lendTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+  await expect(lendTx).resolves.toBeReceipt();
+  return lendTx;
+}
+async function uniswapV2Redeem({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  uniswapV2LiquidityAdapter,
+  poolTokenAmount,
+  tokenA,
+  tokenB,
+  amountAMin,
+  amountBMin
+}) {
+  const redeemArgs = _protocol.uniswapV2RedeemArgs.call(void 0, {
+    amountAMin,
+    amountBMin,
+    poolTokenAmount,
+    tokenA,
+    tokenB
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: uniswapV2LiquidityAdapter,
+    encodedCallArgs: redeemArgs,
+    selector: _protocol.redeemSelector
+  });
+  const redeemTx = comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.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 = _protocol.uniswapV2TakeOrderArgs.call(void 0, {
+    minIncomingAssetAmount,
+    outgoingAssetAmount,
+    path
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: uniswapV2ExchangeAdapter,
+    encodedCallArgs: takeOrderArgs,
+    selector: _protocol.takeOrderSelector
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/integrations/uniswapV3.ts
+
+
+
+
+
+
+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 = _protocol.uniswapV3TakeOrderArgs.call(void 0, {
+    minIncomingAssetAmount,
+    outgoingAssetAmount,
+    pathAddresses,
+    pathFees
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: uniswapV3Adapter,
+    encodedCallArgs: takeOrderArgs,
+    selector: _protocol.takeOrderSelector
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/integrations/yearn.ts
+
+
+
+
+
+
+
+
+
+async function yearnVaultV2Lend({
+  signer,
+  comptrollerProxy,
+  integrationManager,
+  yearnVaultV2Adapter,
+  yVault,
+  outgoingUnderlyingAmount,
+  minIncomingYVaultSharesAmount = _ethers3.BigNumber.from(1)
+}) {
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: yearnVaultV2Adapter,
+    encodedCallArgs: _protocol.yearnVaultV2LendArgs.call(void 0, {
+      minIncomingYVaultSharesAmount,
+      outgoingUnderlyingAmount,
+      yVault
+    }),
+    selector: _protocol.lendSelector
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+async function yearnVaultV2Redeem({
+  signer,
+  comptrollerProxy,
+  integrationManager,
+  yearnVaultV2Adapter,
+  yVault,
+  maxOutgoingYVaultSharesAmount,
+  minIncomingUnderlyingAmount = _ethers3.BigNumber.from(1),
+  slippageToleranceBps = 1
+}) {
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: yearnVaultV2Adapter,
+    encodedCallArgs: _protocol.yearnVaultV2RedeemArgs.call(void 0, {
+      maxOutgoingYVaultSharesAmount,
+      minIncomingUnderlyingAmount,
+      slippageToleranceBps,
+      yVault
+    }),
+    selector: _protocol.redeemSelector
+  });
+  return comptrollerProxy.connect(signer).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/integrations/zeroExV2.ts
+
+
+
+
+
+
+async function zeroExV2TakeOrder({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  zeroExV2Adapter,
+  signedOrder,
+  takerAssetFillAmount
+}) {
+  const takeOrderArgs = _protocol.zeroExV2TakeOrderArgs.call(void 0, {
+    signedOrder,
+    takerAssetFillAmount
+  });
+  const callArgs = _protocol.callOnIntegrationArgs.call(void 0, {
+    adapter: zeroExV2Adapter,
+    encodedCallArgs: takeOrderArgs,
+    selector: _protocol.takeOrderSelector
+  });
+  return comptrollerProxy.connect(fundOwner).callOnExtension(integrationManager, _protocol.IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+
+// src/scaffolding/extensions/policies.ts
+
+
+async function generatePolicyManagerConfigWithMockPolicies({ deployer }) {
+  const policies = Object.values(await generateMockPolicies({
+    deployer
+  }));
+  const policiesSettingsData = [...new Array(policies.length - 1).fill(_ethers3.constants.HashZero), _ethers3.utils.randomBytes(10)];
+  return _protocol.policyManagerConfigArgs.call(void 0, {
+    policies,
+    settings: policiesSettingsData
+  });
+}
+async function generateMockPolicies({ deployer }) {
+  const mockAddTrackedAssetsPolicy = await _protocol.IPolicy.mock(deployer);
+  const mockCreateExternalPositionPolicy = await _protocol.IPolicy.mock(deployer);
+  const mockPostBuySharesPolicy = await _protocol.IPolicy.mock(deployer);
+  const mockPostCallOnExternalPositionPolicy = await _protocol.IPolicy.mock(deployer);
+  const mockPostCoIPolicy = await _protocol.IPolicy.mock(deployer);
+  const mockRedeemSharesForSpecificAssetsPolicy = await _protocol.IPolicy.mock(deployer);
+  const mockPreTransferSharesPolicy = await _protocol.IPolicy.mock(deployer);
+  const mockRemoveExternalPositionPolicy = await _protocol.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([_protocol.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([_protocol.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([_protocol.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([_protocol.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([_protocol.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([_protocol.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([_protocol.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([_protocol.PolicyHook.RedeemSharesForSpecificAssets]),
+    mockRemoveExternalPositionPolicy.updateFundSettings.returns(void 0)
+  ]);
+  return {
+    mockAddTrackedAssetsPolicy,
+    mockCreateExternalPositionPolicy,
+    mockPostBuySharesPolicy,
+    mockPostCallOnExternalPositionPolicy,
+    mockPostCoIPolicy,
+    mockPreTransferSharesPolicy,
+    mockRedeemSharesForSpecificAssetsPolicy,
+    mockRemoveExternalPositionPolicy
+  };
+}
+
+// src/scaffolding/external-interfaces.ts
+
+var IConvexBaseRewardPool = _ethers.contract.call(void 0, )`
+  function stakeFor(address, uint256) returns (bool)
+`;
+var IConvexCrvDepositor = _ethers.contract.call(void 0, )`
+  function deposit(uint256, bool)
+`;
+var IConvexCvxLocker = _ethers.contract.call(void 0, )`
+  function balanceOf(address) view returns (uint256)
+  function checkpointEpoch()
+  function getReward(address, bool)
+  function lockedBalanceOf(address) view returns (uint256)
+`;
+var IConvexVlCvxExtraRewardDistribution = _ethers.contract.call(void 0, )`
+  function claimableRewards(address, address) view returns (uint256)
+  function addReward(address, uint256)
+`;
+var ISnapshotDelegateRegistry = _ethers.contract.call(void 0, )`
+  function delegation(address, bytes32) view returns (address)
+`;
+var IVotiumMultiMerkleStash = _ethers.contract.call(void 0, )`
+  function owner() view returns (address)
+  function updateMerkleRoot(address, bytes32)
+`;
+
+// src/scaffolding/peripheral/shares-splitter.ts
+
+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 (0, _protocol.SharesSplitterLib)(proxyDeployedArgs.proxy, provider);
+  return { receipt, sharesSplitterProxy };
+}
+
+// src/scaffolding/setup.ts
+
+
+
+
+
+
+
+
+
+
+
+// src/scaffolding/shares.ts
+
+async function buyShares(options) {
+  return (await buySharesFunction(options)).send();
+}
+async function buySharesFunction({
+  comptrollerProxy,
+  denominationAsset,
+  buyer,
+  investmentAmount,
+  minSharesQuantity = 1,
+  seedBuyer = false
+}) {
+  if (investmentAmount == null) {
+    investmentAmount = _ethers3.utils.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 = _ethers3.constants.MaxUint256,
+  payoutAssets,
+  payoutAssetPercentages
+}) {
+  return comptrollerProxy.connect(signer).redeemSharesForSpecificAssets(recipient, quantity, payoutAssets, payoutAssetPercentages);
+}
+async function redeemSharesInKind({
+  comptrollerProxy,
+  signer,
+  recipient = signer,
+  quantity = _ethers3.constants.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 = _protocol.encodeFunctionData.call(void 0, comptrollerLib.init.fragment, [denominationAsset, sharesActionTimelock]);
+  const comptrollerProxyContract = await _protocol.ComptrollerProxy.deploy(signer, constructData, comptrollerLib);
+  return {
+    comptrollerProxy: new (0, _protocol.ComptrollerLib)(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: _ethers3.BigNumber.from(sharesActionTimelock)
+  });
+  return {
+    comptrollerProxy: new (0, _protocol.ComptrollerLib)(comptrollerDeployedArgs.comptrollerProxy, signer),
+    receipt
+  };
+}
+async function createNewFund({
+  signer,
+  fundDeployer,
+  denominationAsset,
+  sharesActionTimelock = 0,
+  fundOwner = _ethers.randomAddress.call(void 0, ),
+  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: _ethers3.BigNumber.from(sharesActionTimelock)
+  });
+  const comptrollerProxy = new (0, _protocol.ComptrollerLib)(comptrollerDeployedArgs.comptrollerProxy, signer);
+  const newFundDeployedArgs = assertEvent(receipt, "NewFundCreated", {
+    comptrollerProxy,
+    creator: signer,
+    vaultProxy: expect.any(String)
+  });
+  const vaultProxy = new (0, _protocol.VaultLib)(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: _ethers3.BigNumber.from(sharesActionTimelock)
+  });
+  return {
+    comptrollerProxy: new (0, _protocol.ComptrollerLib)(comptrollerDeployedArgs.comptrollerProxy, signer),
+    receipt
+  };
+}
+async function createVaultProxy({
+  signer,
+  vaultLib,
+  fundOwner,
+  fundAccessor,
+  fundName = "My Fund"
+}) {
+  const constructData = _protocol.encodeFunctionData.call(void 0, vaultLib.init.fragment, [fundOwner, fundAccessor, fundName]);
+  const vaultProxyContract = await _protocol.VaultProxy.deploy(signer, constructData, vaultLib);
+  return new (0, _protocol.VaultLib)(vaultProxyContract, fundAccessor);
+}
+async function setupGasRelayerPaymaster({
+  signer,
+  vaultProxy,
+  fundAccessor,
+  weth,
+  startingBalance = _ethers3.utils.parseUnits("10", 18)
+}) {
+  await weth.transfer(vaultProxy, startingBalance);
+  const comptrollerProxy = new (0, _protocol.ComptrollerLib)(fundAccessor, signer);
+  const receipt = await comptrollerProxy.deployGasRelayPaymaster();
+  const eventArgs = assertEvent(receipt, "GasRelayPaymasterSet", {
+    gasRelayPaymaster: expect.any(String)
+  });
+  return new (0, _protocol.GasRelayPaymasterLib)(eventArgs.gasRelayPaymaster, signer);
+}
+
+// src/scaffolding/vaultCalls.ts
+
+
+
+
+
+
+
+
+
+async function vaultCallCreateNewList({
+  addressListRegistry,
+  comptrollerProxy,
+  items,
+  owner,
+  signer,
+  updateType
+}) {
+  await comptrollerProxy.connect(signer).vaultCallOnContract(addressListRegistry.address, _protocol.addressListRegistryCreateListSelector, _protocol.encodeArgs.call(void 0, ["address", "uint8", "address[]"], [owner, updateType, items]));
+  const listCount = await addressListRegistry.getListCount();
+  return listCount.sub(1);
+}
+function vaultCallCurveMinterMint({
+  comptrollerProxy,
+  minter,
+  gauge
+}) {
+  return comptrollerProxy.vaultCallOnContract(minter, _protocol.curveMinterMintSelector, _protocol.encodeArgs.call(void 0, ["address"], [gauge]));
+}
+function vaultCallCurveMinterMintMany({
+  comptrollerProxy,
+  minter,
+  gauges
+}) {
+  const gaugesFormatted = new Array(8).fill(_ethers3.constants.AddressZero);
+  for (const i in gauges) {
+    gaugesFormatted[i] = gauges[i];
+  }
+  return comptrollerProxy.vaultCallOnContract(minter, _protocol.curveMinterMintManySelector, _protocol.encodeArgs.call(void 0, ["address[8]"], [gaugesFormatted]));
+}
+function vaultCallCurveMinterToggleApproveMint({
+  comptrollerProxy,
+  minter,
+  account
+}) {
+  return comptrollerProxy.vaultCallOnContract(minter, _protocol.curveMinterToggleApproveMintSelector, _protocol.encodeArgs.call(void 0, ["address"], [account]));
+}
+function vaultCallStartAssetBypassTimelock({
+  comptrollerProxy,
+  contract: contract7,
+  asset
+}) {
+  return comptrollerProxy.vaultCallOnContract(contract7, _protocol.sighash.call(void 0, _ethers3.utils.FunctionFragment.fromString("startAssetBypassTimelock(address)")), _protocol.encodeArgs.call(void 0, ["address"], [asset]));
+}
+
+// src/whales.ts
+
+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 = _ethers.resolveAddress.call(void 0, 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);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CurveLiquidityGaugeV2 = CurveLiquidityGaugeV2; exports.CurveMinter = CurveMinter; exports.CurveRegistry = CurveRegistry; exports.CurveSwaps = CurveSwaps; exports.ICompoundComptroller = ICompoundComptroller; exports.IConvexBaseRewardPool = IConvexBaseRewardPool; exports.IConvexCrvDepositor = IConvexCrvDepositor; exports.IConvexCvxLocker = IConvexCvxLocker; exports.IConvexVlCvxExtraRewardDistribution = IConvexVlCvxExtraRewardDistribution; exports.ILiquityHintHelper = ILiquityHintHelper; exports.ILiquitySortedTroves = ILiquitySortedTroves; exports.ILiquityTroveManager = ILiquityTroveManager; exports.ISnapshotDelegateRegistry = ISnapshotDelegateRegistry; exports.IUniswapV3NonFungibleTokenManager = IUniswapV3NonFungibleTokenManager; exports.IVotiumMultiMerkleStash = IVotiumMultiMerkleStash; exports.UniswapV2Factory = UniswapV2Factory; exports.UniswapV3FeeAmount = UniswapV3FeeAmount; exports.aaveDebtPositionAddCollateral = aaveDebtPositionAddCollateral; exports.aaveDebtPositionBorrow = aaveDebtPositionBorrow; exports.aaveDebtPositionClaimRewards = aaveDebtPositionClaimRewards; exports.aaveDebtPositionRemoveCollateral = aaveDebtPositionRemoveCollateral; exports.aaveDebtPositionRepayBorrow = aaveDebtPositionRepayBorrow; exports.aaveLend = aaveLend; exports.aaveRedeem = aaveRedeem; exports.addNewAssetsToFund = addNewAssetsToFund; exports.addTrackedAssetsToVault = addTrackedAssetsToVault; exports.assertCompoundLend = assertCompoundLend; exports.assertCompoundRedeem = assertCompoundRedeem; exports.assertDidRelay = assertDidRelay; exports.assertDidRelaySuccessfully = assertDidRelaySuccessfully; exports.assertDidRelayWithCharge = assertDidRelayWithCharge; exports.assertDidRelayWithError = assertDidRelayWithError; exports.assertEvent = assertEvent; exports.assertNoEvent = assertNoEvent; exports.assertPaymasterDidReject = assertPaymasterDidReject; exports.assertPaymasterDidRejectForReason = assertPaymasterDidRejectForReason; exports.buyShares = buyShares; exports.buySharesFunction = buySharesFunction; exports.calcMlnValueAndBurnAmountForSharesBuyback = calcMlnValueAndBurnAmountForSharesBuyback; exports.callOnExtension = callOnExtension; exports.callOnExternalPosition = callOnExternalPosition; exports.compoundClaim = compoundClaim; exports.compoundDebtPositionAddCollateral = compoundDebtPositionAddCollateral; exports.compoundDebtPositionBorrow = compoundDebtPositionBorrow; exports.compoundDebtPositionClaimComp = compoundDebtPositionClaimComp; exports.compoundDebtPositionRemoveCollateral = compoundDebtPositionRemoveCollateral; exports.compoundDebtPositionRepayBorrow = compoundDebtPositionRepayBorrow; exports.compoundLend = compoundLend; exports.compoundRedeem = compoundRedeem; exports.convexVotingPositionClaimRewards = convexVotingPositionClaimRewards; exports.convexVotingPositionDelegate = convexVotingPositionDelegate; exports.convexVotingPositionLock = convexVotingPositionLock; exports.convexVotingPositionRelock = convexVotingPositionRelock; exports.convexVotingPositionWithdraw = convexVotingPositionWithdraw; exports.createAaveDebtPosition = createAaveDebtPosition; exports.createCompoundDebtPosition = createCompoundDebtPosition; exports.createComptrollerProxy = createComptrollerProxy; exports.createConvexVotingPosition = createConvexVotingPosition; exports.createExternalPosition = createExternalPosition; exports.createFundDeployer = createFundDeployer; exports.createLiquityDebtPosition = createLiquityDebtPosition; exports.createMapleLiquidityPosition = createMapleLiquidityPosition; exports.createMigrationRequest = createMigrationRequest; exports.createMockExternalPosition = createMockExternalPosition; exports.createNewFund = createNewFund; exports.createReconfigurationRequest = createReconfigurationRequest; exports.createTheGraphDelegationPosition = createTheGraphDelegationPosition; exports.createUniswapV3LiquidityPosition = createUniswapV3LiquidityPosition; exports.createVaultProxy = createVaultProxy; exports.curveClaimRewards = curveClaimRewards; exports.curveLend = curveLend; exports.curveLendAndStake = curveLendAndStake; exports.curveRedeem = curveRedeem; exports.curveStake = curveStake; exports.curveTakeOrder = curveTakeOrder; exports.curveUnstake = curveUnstake; exports.curveUnstakeAndRedeem = curveUnstakeAndRedeem; exports.deployProtocolFixture = deployProtocolFixture; exports.deploySharesSplitter = deploySharesSplitter; exports.generateFeeManagerConfigWithMockFees = generateFeeManagerConfigWithMockFees; exports.generateMerkleTreeForContractProof = generateMerkleTreeForContractProof; exports.generateMockFees = generateMockFees; exports.generateMockPolicies = generateMockPolicies; exports.generatePolicyManagerConfigWithMockPolicies = generatePolicyManagerConfigWithMockPolicies; exports.getAssetBalances = getAssetBalances; exports.getAssetUnit = getAssetUnit; exports.getNamedSigner = getNamedSigner; exports.getUnnamedSigners = getUnnamedSigners; exports.idleClaimRewards = idleClaimRewards; exports.idleLend = idleLend; exports.idleRedeem = idleRedeem; exports.impersonateContractSigner = impersonateContractSigner; exports.impersonateSigner = impersonateSigner; exports.liquityCalcHints = liquityCalcHints; exports.liquityDebtPositionAddCollateral = liquityDebtPositionAddCollateral; exports.liquityDebtPositionBorrow = liquityDebtPositionBorrow; exports.liquityDebtPositionCloseTrove = liquityDebtPositionCloseTrove; exports.liquityDebtPositionOpenTrove = liquityDebtPositionOpenTrove; exports.liquityDebtPositionRemoveCollateral = liquityDebtPositionRemoveCollateral; exports.liquityDebtPositionRepay = liquityDebtPositionRepay; exports.mapleLiquidityPositionClaimInterest = mapleLiquidityPositionClaimInterest; exports.mapleLiquidityPositionClaimRewards = mapleLiquidityPositionClaimRewards; exports.mapleLiquidityPositionIntendToRedeem = mapleLiquidityPositionIntendToRedeem; exports.mapleLiquidityPositionLend = mapleLiquidityPositionLend; exports.mapleLiquidityPositionLendAndStake = mapleLiquidityPositionLendAndStake; exports.mapleLiquidityPositionRedeem = mapleLiquidityPositionRedeem; exports.mapleLiquidityPositionStake = mapleLiquidityPositionStake; exports.mapleLiquidityPositionUnstake = mapleLiquidityPositionUnstake; exports.mapleLiquidityPositionUnstakeAndRedeem = mapleLiquidityPositionUnstakeAndRedeem; exports.mockExternalPositionAddDebtAssets = mockExternalPositionAddDebtAssets; exports.mockExternalPositionAddManagedAssets = mockExternalPositionAddManagedAssets; exports.mockExternalPositionRemoveDebtAssets = mockExternalPositionRemoveDebtAssets; exports.mockExternalPositionRemoveManagedAssets = mockExternalPositionRemoveManagedAssets; exports.mockGenericRemoveOnlySelector = mockGenericRemoveOnlySelector; exports.mockGenericSwap = mockGenericSwap; exports.mockGenericSwapASelector = mockGenericSwapASelector; exports.mockGenericSwapArgs = mockGenericSwapArgs; exports.mockGenericSwapBSelector = mockGenericSwapBSelector; exports.mockGenericSwapDirectFromVaultSelector = mockGenericSwapDirectFromVaultSelector; exports.mockGenericSwapViaApprovalSelector = mockGenericSwapViaApprovalSelector; exports.olympusV2Stake = olympusV2Stake; exports.olympusV2Unstake = olympusV2Unstake; exports.paraSwapV5GenerateDummyPaths = paraSwapV5GenerateDummyPaths; exports.paraSwapV5TakeOrder = paraSwapV5TakeOrder; exports.poolTogetherV4ClaimRewards = poolTogetherV4ClaimRewards; exports.poolTogetherV4Lend = poolTogetherV4Lend; exports.poolTogetherV4Redeem = poolTogetherV4Redeem; exports.reactivateExternalPosition = reactivateExternalPosition; exports.redeemSharesForSpecificAssets = redeemSharesForSpecificAssets; exports.redeemSharesInKind = redeemSharesInKind; exports.relayTransaction = relayTransaction; exports.removeExternalPosition = removeExternalPosition; exports.removeTrackedAssetsFromVault = removeTrackedAssetsFromVault; exports.sendEthBySelfDestruct = sendEthBySelfDestruct; exports.setupGasRelayerPaymaster = setupGasRelayerPaymaster; exports.synthetixAssignExchangeDelegate = synthetixAssignExchangeDelegate; exports.synthetixRedeem = synthetixRedeem; exports.synthetixTakeOrder = synthetixTakeOrder; exports.theGraphDelegationPositionDelegate = theGraphDelegationPositionDelegate; exports.theGraphDelegationPositionUndelegate = theGraphDelegationPositionUndelegate; exports.theGraphDelegationPositionWithdraw = theGraphDelegationPositionWithdraw; exports.transactionTimestamp = transactionTimestamp; exports.uniswapV2Lend = uniswapV2Lend; exports.uniswapV2Redeem = uniswapV2Redeem; exports.uniswapV2TakeOrder = uniswapV2TakeOrder; exports.uniswapV3LiquidityPositionAddLiquidity = uniswapV3LiquidityPositionAddLiquidity; exports.uniswapV3LiquidityPositionCollect = uniswapV3LiquidityPositionCollect; exports.uniswapV3LiquidityPositionGetMaxTick = uniswapV3LiquidityPositionGetMaxTick; exports.uniswapV3LiquidityPositionGetMinTick = uniswapV3LiquidityPositionGetMinTick; exports.uniswapV3LiquidityPositionMint = uniswapV3LiquidityPositionMint; exports.uniswapV3LiquidityPositionPurge = uniswapV3LiquidityPositionPurge; exports.uniswapV3LiquidityPositionRemoveLiquidity = uniswapV3LiquidityPositionRemoveLiquidity; exports.uniswapV3OrderTokenPair = uniswapV3OrderTokenPair; exports.uniswapV3TakeOrder = uniswapV3TakeOrder; exports.unlockAllWhales = unlockAllWhales; exports.unlockWhale = unlockWhale; exports.unlockWhales = unlockWhales; exports.updateChainlinkAggregator = updateChainlinkAggregator; exports.vaultCallCreateNewList = vaultCallCreateNewList; exports.vaultCallCurveMinterMint = vaultCallCurveMinterMint; exports.vaultCallCurveMinterMintMany = vaultCallCurveMinterMintMany; exports.vaultCallCurveMinterToggleApproveMint = vaultCallCurveMinterToggleApproveMint; exports.vaultCallStartAssetBypassTimelock = vaultCallStartAssetBypassTimelock; exports.yearnVaultV2Lend = yearnVaultV2Lend; exports.yearnVaultV2Redeem = yearnVaultV2Redeem; exports.zeroExV2TakeOrder = zeroExV2TakeOrder;