@enzymefinance/testutils 4.0.0 → 4.0.1

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

@@ -1,73 +0,0 @@
-import type { AddressLike } from '@enzymefinance/ethers';
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type {
-  ComptrollerLib,
-  IntegrationManager,
-  ParaSwapV5Adapter,
-  ParaSwapV5Path,
-  StandardToken,
-} from '@enzymefinance/protocol';
-import {
-  callOnIntegrationArgs,
-  IntegrationManagerActionId,
-  paraSwapV5TakeOrderArgs,
-  takeOrderSelector,
-} from '@enzymefinance/protocol';
-import type { BigNumberish, BytesLike } from 'ethers';
-import { utils } from 'ethers';
-
-// ParaSwapV5Path
-export function paraSwapV5GenerateDummyPaths({ toTokens }: { toTokens: AddressLike[] }) {
-  return toTokens.map((toToken) => {
-    return {
-      // Not supported in our protocol
-      adapters: [],
-
-      to: toToken,
-      totalNetworkFee: 0, // Can ignore this param in the dummy
-    };
-  });
-}
-
-export async function paraSwapV5TakeOrder({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  paraSwapV5Adapter,
-  outgoingAsset,
-  outgoingAssetAmount,
-  minIncomingAssetAmount = 1,
-  expectedIncomingAssetAmount = minIncomingAssetAmount,
-  uuid = utils.randomBytes(16),
-  paths,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  paraSwapV5Adapter: ParaSwapV5Adapter;
-  outgoingAsset: StandardToken;
-  outgoingAssetAmount: BigNumberish;
-  minIncomingAssetAmount?: BigNumberish;
-  expectedIncomingAssetAmount?: BigNumberish;
-  uuid?: BytesLike;
-  paths: ParaSwapV5Path[];
-}) {
-  const takeOrderArgs = paraSwapV5TakeOrderArgs({
-    expectedIncomingAssetAmount,
-    minIncomingAssetAmount,
-    outgoingAsset,
-    outgoingAssetAmount,
-    paths,
-    uuid,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: paraSwapV5Adapter,
-    encodedCallArgs: takeOrderArgs,
-    selector: takeOrderSelector,
-  });
-
-  return comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}

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

@@ -1,117 +0,0 @@
-import type { AddressLike } from '@enzymefinance/ethers';
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type { ComptrollerLib, IntegrationManager, PoolTogetherV4Adapter, StandardToken } from '@enzymefinance/protocol';
-import {
-  callOnIntegrationArgs,
-  claimRewardsSelector,
-  IntegrationManagerActionId,
-  lendSelector,
-  poolTogetherV4ClaimRewardsArgs,
-  poolTogetherV4LendArgs,
-  poolTogetherV4RedeemArgs,
-  redeemSelector,
-} from '@enzymefinance/protocol';
-import type { BigNumberish, BytesLike } from 'ethers';
-import { utils } from 'ethers';
-
-export async function poolTogetherV4Lend({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  poolTogetherV4Adapter,
-  ptToken,
-  amount = utils.parseEther('1'),
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  poolTogetherV4Adapter: PoolTogetherV4Adapter;
-  ptToken: StandardToken;
-  amount?: BigNumberish;
-}) {
-  const lendArgs = poolTogetherV4LendArgs({
-    amount,
-    ptToken,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: poolTogetherV4Adapter,
-    encodedCallArgs: lendArgs,
-    selector: lendSelector,
-  });
-
-  const lendTx = comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-
-  return lendTx;
-}
-
-export async function poolTogetherV4Redeem({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  poolTogetherV4Adapter,
-  ptToken,
-  amount = utils.parseEther('1'),
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  poolTogetherV4Adapter: PoolTogetherV4Adapter;
-  ptToken: StandardToken;
-  amount?: BigNumberish;
-}) {
-  const redeemArgs = poolTogetherV4RedeemArgs({
-    amount,
-    ptToken,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: poolTogetherV4Adapter,
-    encodedCallArgs: redeemArgs,
-    selector: redeemSelector,
-  });
-
-  const redeemTx = comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-
-  return redeemTx;
-}
-
-export async function poolTogetherV4ClaimRewards({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  poolTogetherV4Adapter,
-  prizeDistributor,
-  drawIds,
-  winningPicks,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  poolTogetherV4Adapter: PoolTogetherV4Adapter;
-  prizeDistributor: AddressLike;
-  drawIds: BigNumberish[];
-  winningPicks: BytesLike;
-}) {
-  const claimRewardsArgs = poolTogetherV4ClaimRewardsArgs({
-    drawIds,
-    prizeDistributor,
-    winningPicks,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: poolTogetherV4Adapter,
-    encodedCallArgs: claimRewardsArgs,
-    selector: claimRewardsSelector,
-  });
-
-  const claimTx = comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-
-  return claimTx;
-}

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

@@ -1,111 +0,0 @@
-import type { AddressLike } from '@enzymefinance/ethers';
-import type {
-  ComptrollerLib,
-  IntegrationManager,
-  StandardToken,
-  SynthetixAdapter,
-  VaultLib,
-} from '@enzymefinance/protocol';
-import {
-  callOnIntegrationArgs,
-  encodeArgs,
-  IntegrationManagerActionId,
-  redeemSelector,
-  synthetixAssignExchangeDelegateSelector,
-  synthetixRedeemArgs,
-  synthetixTakeOrderArgs,
-  takeOrderSelector,
-} from '@enzymefinance/protocol';
-import type { BigNumberish, Signer } from 'ethers';
-import { utils } from 'ethers';
-
-export async function synthetixAssignExchangeDelegate({
-  comptrollerProxy,
-  synthetixDelegateApprovals,
-  fundOwner,
-  delegate,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  synthetixDelegateApprovals: AddressLike;
-  fundOwner: Signer;
-  delegate: AddressLike;
-}) {
-  await comptrollerProxy
-    .connect(fundOwner)
-    .vaultCallOnContract(
-      synthetixDelegateApprovals,
-      synthetixAssignExchangeDelegateSelector,
-      encodeArgs(['address'], [delegate]),
-    );
-}
-
-export async function synthetixRedeem({
-  comptrollerProxy,
-  integrationManager,
-  signer,
-  synthetixAdapter,
-  synths,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  signer: Signer;
-  synthetixAdapter: SynthetixAdapter;
-  synths: AddressLike[];
-}) {
-  const redeemArgs = synthetixRedeemArgs({
-    synths,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: synthetixAdapter,
-    encodedCallArgs: redeemArgs,
-    selector: redeemSelector,
-  });
-
-  return comptrollerProxy
-    .connect(signer)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-
-export async function synthetixTakeOrder({
-  comptrollerProxy,
-  vaultProxy,
-  integrationManager,
-  fundOwner,
-  synthetixAdapter,
-  outgoingAsset,
-  outgoingAssetAmount = utils.parseEther('1'),
-  minIncomingSusdAmount = utils.parseEther('1'),
-  seedFund = false,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  vaultProxy: VaultLib;
-  integrationManager: IntegrationManager;
-  fundOwner: Signer;
-  synthetixAdapter: SynthetixAdapter;
-  outgoingAsset: StandardToken;
-  outgoingAssetAmount?: BigNumberish;
-  minIncomingSusdAmount?: BigNumberish;
-  seedFund?: boolean;
-}) {
-  if (seedFund) {
-    // Seed the VaultProxy with enough outgoingAsset for the tx
-    await outgoingAsset.transfer(vaultProxy, outgoingAssetAmount);
-  }
-
-  const takeOrderArgs = synthetixTakeOrderArgs({
-    minIncomingSusdAmount,
-    outgoingAsset,
-    outgoingAssetAmount,
-  });
-
-  const callArgs = await callOnIntegrationArgs({
-    adapter: synthetixAdapter,
-    encodedCallArgs: takeOrderArgs,
-    selector: takeOrderSelector,
-  });
-
-  return comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}

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

@@ -1,48 +0,0 @@
-import type { AddressLike } from '@enzymefinance/ethers';
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type { ComptrollerLib, IntegrationManager } from '@enzymefinance/protocol';
-import {
-  addTrackedAssetsToVaultArgs,
-  IntegrationManagerActionId,
-  removeTrackedAssetsFromVaultArgs,
-} from '@enzymefinance/protocol';
-
-export function addTrackedAssetsToVault({
-  signer,
-  comptrollerProxy,
-  integrationManager,
-  assets,
-}: {
-  signer: SignerWithAddress;
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  assets: AddressLike[];
-}) {
-  return comptrollerProxy
-    .connect(signer)
-    .callOnExtension(
-      integrationManager,
-      IntegrationManagerActionId.AddTrackedAssetsToVault,
-      addTrackedAssetsToVaultArgs({ assets }),
-    );
-}
-
-export function removeTrackedAssetsFromVault({
-  signer,
-  comptrollerProxy,
-  integrationManager,
-  assets,
-}: {
-  signer: SignerWithAddress;
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  assets: AddressLike[];
-}) {
-  return comptrollerProxy
-    .connect(signer)
-    .callOnExtension(
-      integrationManager,
-      IntegrationManagerActionId.RemoveTrackedAssetsFromVault,
-      removeTrackedAssetsFromVaultArgs({ assets }),
-    );
-}

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

@@ -1,175 +0,0 @@
-import type { AddressLike, Call, Contract, Send } from '@enzymefinance/ethers';
-import { contract } from '@enzymefinance/ethers';
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type {
-  ComptrollerLib,
-  IntegrationManager,
-  StandardToken,
-  UniswapV2ExchangeAdapter,
-  UniswapV2LiquidityAdapter,
-  VaultLib,
-} from '@enzymefinance/protocol';
-import {
-  callOnIntegrationArgs,
-  IntegrationManagerActionId,
-  lendSelector,
-  redeemSelector,
-  takeOrderSelector,
-  uniswapV2LendArgs,
-  uniswapV2RedeemArgs,
-  uniswapV2TakeOrderArgs,
-} from '@enzymefinance/protocol';
-import type { BigNumberish } from 'ethers';
-
-export interface UniswapV2Factory extends Contract<UniswapV2Factory> {
-  createPair: Send<(_token0: AddressLike, _token1: AddressLike) => AddressLike>;
-  getPair: Call<(_token0: AddressLike, _token1: AddressLike) => AddressLike>;
-}
-
-export const UniswapV2Factory = contract<UniswapV2Factory>()`
-  function createPair(address,address) returns (address)
-  function getPair(address,address) view returns (address)
-`;
-
-export async function uniswapV2Lend({
-  comptrollerProxy,
-  vaultProxy,
-  integrationManager,
-  fundOwner,
-  uniswapV2LiquidityAdapter,
-  tokenA,
-  tokenB,
-  amountADesired,
-  amountBDesired,
-  amountAMin,
-  amountBMin,
-  minPoolTokenAmount,
-  seedFund = false,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  vaultProxy: VaultLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  uniswapV2LiquidityAdapter: UniswapV2LiquidityAdapter;
-  tokenA: StandardToken;
-  tokenB: StandardToken;
-  amountADesired: BigNumberish;
-  amountBDesired: BigNumberish;
-  amountAMin: BigNumberish;
-  amountBMin: BigNumberish;
-  minPoolTokenAmount: BigNumberish;
-  seedFund?: boolean;
-}) {
-  if (seedFund) {
-    // Seed the VaultProxy with enough tokenA and tokenB for the tx
-    await tokenA.transfer(vaultProxy, amountADesired);
-    await tokenB.transfer(vaultProxy, amountBDesired);
-  }
-
-  const lendArgs = uniswapV2LendArgs({
-    amountADesired,
-    amountAMin,
-    amountBDesired,
-    amountBMin,
-    minPoolTokenAmount,
-    tokenA,
-    tokenB,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: uniswapV2LiquidityAdapter,
-    encodedCallArgs: lendArgs,
-    selector: lendSelector,
-  });
-
-  const lendTx = comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-  await expect(lendTx).resolves.toBeReceipt();
-
-  return lendTx;
-}
-
-export async function uniswapV2Redeem({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  uniswapV2LiquidityAdapter,
-  poolTokenAmount,
-  tokenA,
-  tokenB,
-  amountAMin,
-  amountBMin,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  uniswapV2LiquidityAdapter: UniswapV2LiquidityAdapter;
-  poolTokenAmount: BigNumberish;
-  tokenA: AddressLike;
-  tokenB: AddressLike;
-  amountAMin: BigNumberish;
-  amountBMin: BigNumberish;
-}) {
-  const redeemArgs = uniswapV2RedeemArgs({
-    amountAMin,
-    amountBMin,
-    poolTokenAmount,
-    tokenA,
-    tokenB,
-  });
-  const callArgs = callOnIntegrationArgs({
-    adapter: uniswapV2LiquidityAdapter,
-    encodedCallArgs: redeemArgs,
-    selector: redeemSelector,
-  });
-
-  const redeemTx = comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-  await expect(redeemTx).resolves.toBeReceipt();
-
-  return redeemTx;
-}
-
-export async function uniswapV2TakeOrder({
-  comptrollerProxy,
-  vaultProxy,
-  integrationManager,
-  fundOwner,
-  uniswapV2ExchangeAdapter,
-  path,
-  outgoingAssetAmount,
-  minIncomingAssetAmount,
-  seedFund = false,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  vaultProxy: VaultLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  uniswapV2ExchangeAdapter: UniswapV2ExchangeAdapter;
-  path: StandardToken[];
-  outgoingAssetAmount: BigNumberish;
-  minIncomingAssetAmount: BigNumberish;
-  seedFund?: boolean;
-}) {
-  if (seedFund) {
-    // Seed the VaultProxy with enough outgoingAsset for the tx
-    await path[0].transfer(vaultProxy, outgoingAssetAmount);
-  }
-
-  const takeOrderArgs = uniswapV2TakeOrderArgs({
-    minIncomingAssetAmount,
-    outgoingAssetAmount,
-    path,
-  });
-  const callArgs = callOnIntegrationArgs({
-    adapter: uniswapV2ExchangeAdapter,
-    encodedCallArgs: takeOrderArgs,
-    selector: takeOrderSelector,
-  });
-
-  return comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}

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

@@ -1,55 +0,0 @@
-import type { AddressLike } from '@enzymefinance/ethers';
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type { ComptrollerLib, IntegrationManager, StandardToken } from '@enzymefinance/protocol';
-import {
-  callOnIntegrationArgs,
-  IntegrationManagerActionId,
-  takeOrderSelector,
-  uniswapV3TakeOrderArgs,
-} from '@enzymefinance/protocol';
-import type { BigNumber, BigNumberish } from 'ethers';
-
-export async function uniswapV3TakeOrder({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  uniswapV3Adapter,
-  pathAddresses,
-  pathFees,
-  outgoingAssetAmount,
-  minIncomingAssetAmount = 1,
-  seedFund = false,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  uniswapV3Adapter: AddressLike;
-  pathAddresses: StandardToken[];
-  pathFees: BigNumber[];
-  outgoingAssetAmount: BigNumberish;
-  minIncomingAssetAmount?: BigNumberish;
-  seedFund?: boolean;
-}) {
-  if (seedFund) {
-    // Seed the VaultProxy with enough outgoingAsset for the tx
-    const vaultProxy = await comptrollerProxy.getVaultProxy();
-    await pathAddresses[0].transfer(vaultProxy, outgoingAssetAmount);
-  }
-
-  const takeOrderArgs = uniswapV3TakeOrderArgs({
-    minIncomingAssetAmount,
-    outgoingAssetAmount,
-    pathAddresses,
-    pathFees,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: uniswapV3Adapter,
-    encodedCallArgs: takeOrderArgs,
-    selector: takeOrderSelector,
-  });
-
-  return comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}

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

@@ -1,79 +0,0 @@
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type { ComptrollerLib, IntegrationManager, StandardToken, YearnVaultV2Adapter } from '@enzymefinance/protocol';
-import {
-  callOnIntegrationArgs,
-  IntegrationManagerActionId,
-  lendSelector,
-  redeemSelector,
-  yearnVaultV2LendArgs,
-  yearnVaultV2RedeemArgs,
-} from '@enzymefinance/protocol';
-import type { BigNumberish } from 'ethers';
-import { BigNumber } from 'ethers';
-
-export async function yearnVaultV2Lend({
-  signer,
-  comptrollerProxy,
-  integrationManager,
-  yearnVaultV2Adapter,
-  yVault,
-  outgoingUnderlyingAmount,
-  minIncomingYVaultSharesAmount = BigNumber.from(1),
-}: {
-  signer: SignerWithAddress;
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  yearnVaultV2Adapter: YearnVaultV2Adapter;
-  yVault: StandardToken;
-  outgoingUnderlyingAmount: BigNumberish;
-  minIncomingYVaultSharesAmount?: BigNumberish;
-}) {
-  const callArgs = callOnIntegrationArgs({
-    adapter: yearnVaultV2Adapter,
-    encodedCallArgs: yearnVaultV2LendArgs({
-      minIncomingYVaultSharesAmount,
-      outgoingUnderlyingAmount,
-      yVault,
-    }),
-    selector: lendSelector,
-  });
-
-  return comptrollerProxy
-    .connect(signer)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-
-export async function yearnVaultV2Redeem({
-  signer,
-  comptrollerProxy,
-  integrationManager,
-  yearnVaultV2Adapter,
-  yVault,
-  maxOutgoingYVaultSharesAmount,
-  minIncomingUnderlyingAmount = BigNumber.from(1),
-  slippageToleranceBps = 1,
-}: {
-  signer: SignerWithAddress;
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  yearnVaultV2Adapter: YearnVaultV2Adapter;
-  yVault: StandardToken;
-  maxOutgoingYVaultSharesAmount: BigNumberish;
-  minIncomingUnderlyingAmount?: BigNumberish;
-  slippageToleranceBps?: BigNumberish;
-}) {
-  const callArgs = callOnIntegrationArgs({
-    adapter: yearnVaultV2Adapter,
-    encodedCallArgs: yearnVaultV2RedeemArgs({
-      maxOutgoingYVaultSharesAmount,
-      minIncomingUnderlyingAmount,
-      slippageToleranceBps,
-      yVault,
-    }),
-    selector: redeemSelector,
-  });
-
-  return comptrollerProxy
-    .connect(signer)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}

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

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