@enzymefinance/testutils 4.0.0 → 4.0.1

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

@@ -1,354 +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,
-  CurveExchangeAdapter,
-  CurveLiquidityAdapter,
-  CurveRedeemType,
-  IntegrationManager,
-  StandardToken,
-} from '@enzymefinance/protocol';
-import {
-  callOnIntegrationArgs,
-  claimRewardsSelector,
-  curveClaimRewardsArgs,
-  curveLendAndStakeArgs,
-  curveLendArgs,
-  curveRedeemArgs,
-  curveStakeArgs,
-  curveTakeOrderArgs,
-  curveUnstakeAndRedeemArgs,
-  curveUnstakeArgs,
-  IntegrationManagerActionId,
-  lendAndStakeSelector,
-  lendSelector,
-  redeemSelector,
-  stakeSelector,
-  takeOrderSelector,
-  unstakeAndRedeemSelector,
-  unstakeSelector,
-} from '@enzymefinance/protocol';
-import type { BigNumberish, BytesLike } from 'ethers';
-import { BigNumber, utils } from 'ethers';
-
-export interface CurveLiquidityGaugeV2 extends Contract<CurveLiquidityGaugeV2> {
-  claim_rewards: Send<(_addr: AddressLike) => void>;
-  integrate_fraction: Call<(_for: AddressLike) => BigNumber, Contract<any>>;
-}
-
-export const CurveLiquidityGaugeV2 = contract<CurveLiquidityGaugeV2>()`
-  function claim_rewards(address)
-  function integrate_fraction(address) view returns (uint256)
-`;
-
-export interface CurveRegistry extends Contract<CurveRegistry> {
-  get_coins: Call<(_pool: AddressLike) => AddressLike[], Contract<any>>;
-  get_lp_token: Call<(_pool: AddressLike) => AddressLike, Contract<any>>;
-}
-
-export const CurveRegistry = contract<CurveRegistry>()`
-  function get_coins(address) view returns (address[8])
-  function get_lp_token(address) view returns (address)
-`;
-
-// prettier-ignore
-export interface CurveSwaps extends Contract<CurveSwaps> {
-  get_best_rate: Call<(_from: AddressLike, to: AddressLike, amount: BigNumberish) => { bestPool: AddressLike, amountReceived: BigNumber }, CurveSwaps>
-}
-
-export const CurveSwaps = contract<CurveSwaps>()`
-  function get_best_rate(address _from, address to, uint256 amount) view returns (address bestPool, uint256 amountReceived)
-`;
-
-export interface CurveMinter extends Contract<CurveMinter> {
-  mint_for: Send<(_gauge_address: AddressLike, _for: AddressLike) => void>;
-}
-
-export const CurveMinter = contract<CurveMinter>()`
-  function mint_for(address,address)
-`;
-
-// exchanges
-
-export async function curveTakeOrder({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  curveExchangeAdapter,
-  pool,
-  outgoingAsset,
-  outgoingAssetAmount = utils.parseEther('1'),
-  incomingAsset,
-  minIncomingAssetAmount = utils.parseEther('1'),
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  curveExchangeAdapter: CurveExchangeAdapter;
-  pool: AddressLike;
-  outgoingAsset: StandardToken;
-  outgoingAssetAmount?: BigNumberish;
-  incomingAsset: StandardToken;
-  minIncomingAssetAmount?: BigNumberish;
-}) {
-  const takeOrderArgs = curveTakeOrderArgs({
-    incomingAsset,
-    minIncomingAssetAmount,
-    outgoingAsset,
-    outgoingAssetAmount,
-    pool,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: curveExchangeAdapter,
-    encodedCallArgs: takeOrderArgs,
-    selector: takeOrderSelector,
-  });
-
-  return comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-
-// combined liquidity
-
-export function curveClaimRewards({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  curveLiquidityAdapter,
-  stakingToken,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  curveLiquidityAdapter: CurveLiquidityAdapter;
-  stakingToken: AddressLike;
-}) {
-  const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityAdapter,
-    encodedCallArgs: curveClaimRewardsArgs({ stakingToken }),
-    selector: claimRewardsSelector,
-  });
-
-  return comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-
-export async function curveLend({
-  comptrollerProxy,
-  integrationManager,
-  signer,
-  curveLiquidityAdapter,
-  pool,
-  orderedOutgoingAssetAmounts,
-  minIncomingLpTokenAmount = BigNumber.from(1),
-  useUnderlyings,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  signer: SignerWithAddress;
-  curveLiquidityAdapter: CurveLiquidityAdapter;
-  pool: AddressLike;
-  orderedOutgoingAssetAmounts: BigNumberish[];
-  minIncomingLpTokenAmount?: BigNumberish;
-  useUnderlyings: boolean;
-}) {
-  const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityAdapter,
-    encodedCallArgs: curveLendArgs({
-      minIncomingLpTokenAmount,
-      orderedOutgoingAssetAmounts,
-      pool,
-      useUnderlyings,
-    }),
-    selector: lendSelector,
-  });
-
-  return comptrollerProxy
-    .connect(signer)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-
-export async function curveLendAndStake({
-  comptrollerProxy,
-  integrationManager,
-  signer,
-  curveLiquidityAdapter,
-  pool,
-  orderedOutgoingAssetAmounts,
-  incomingStakingToken,
-  minIncomingStakingTokenAmount = BigNumber.from(1),
-  useUnderlyings,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  signer: SignerWithAddress;
-  curveLiquidityAdapter: CurveLiquidityAdapter;
-  pool: AddressLike;
-  orderedOutgoingAssetAmounts: BigNumberish[];
-  incomingStakingToken: AddressLike;
-  minIncomingStakingTokenAmount?: BigNumberish;
-  useUnderlyings: boolean;
-}) {
-  const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityAdapter,
-    encodedCallArgs: curveLendAndStakeArgs({
-      incomingStakingToken,
-      minIncomingStakingTokenAmount,
-      orderedOutgoingAssetAmounts,
-      pool,
-      useUnderlyings,
-    }),
-    selector: lendAndStakeSelector,
-  });
-
-  return comptrollerProxy
-    .connect(signer)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-
-export async function curveRedeem({
-  comptrollerProxy,
-  integrationManager,
-  signer,
-  curveLiquidityAdapter,
-  pool,
-  outgoingLpTokenAmount,
-  useUnderlyings,
-  redeemType,
-  incomingAssetData,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  signer: SignerWithAddress;
-  curveLiquidityAdapter: CurveLiquidityAdapter;
-  pool: AddressLike;
-  outgoingLpTokenAmount: BigNumberish;
-  useUnderlyings: boolean;
-  redeemType: CurveRedeemType;
-  incomingAssetData: BytesLike;
-}) {
-  const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityAdapter,
-    encodedCallArgs: curveRedeemArgs({
-      incomingAssetData,
-      outgoingLpTokenAmount,
-      pool,
-      redeemType,
-      useUnderlyings,
-    }),
-    selector: redeemSelector,
-  });
-
-  return comptrollerProxy
-    .connect(signer)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-
-export async function curveStake({
-  comptrollerProxy,
-  integrationManager,
-  signer,
-  curveLiquidityAdapter,
-  pool,
-  incomingStakingToken,
-  amount,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  signer: SignerWithAddress;
-  curveLiquidityAdapter: CurveLiquidityAdapter;
-  pool: AddressLike;
-  incomingStakingToken: AddressLike;
-  amount: BigNumberish;
-}) {
-  const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityAdapter,
-    encodedCallArgs: curveStakeArgs({
-      amount,
-      incomingStakingToken,
-      pool,
-    }),
-    selector: stakeSelector,
-  });
-
-  return comptrollerProxy
-    .connect(signer)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-
-export async function curveUnstake({
-  comptrollerProxy,
-  integrationManager,
-  signer,
-  curveLiquidityAdapter,
-  pool,
-  outgoingStakingToken,
-  amount,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  signer: SignerWithAddress;
-  curveLiquidityAdapter: CurveLiquidityAdapter;
-  pool: AddressLike;
-  outgoingStakingToken: AddressLike;
-  amount: BigNumberish;
-}) {
-  const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityAdapter,
-    encodedCallArgs: curveUnstakeArgs({
-      amount,
-      outgoingStakingToken,
-      pool,
-    }),
-    selector: unstakeSelector,
-  });
-
-  return comptrollerProxy
-    .connect(signer)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-
-export async function curveUnstakeAndRedeem({
-  comptrollerProxy,
-  integrationManager,
-  signer,
-  curveLiquidityAdapter,
-  pool,
-  outgoingStakingToken,
-  outgoingStakingTokenAmount,
-  useUnderlyings,
-  redeemType,
-  incomingAssetData,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  signer: SignerWithAddress;
-  curveLiquidityAdapter: CurveLiquidityAdapter;
-  pool: AddressLike;
-  outgoingStakingToken: StandardToken;
-  outgoingStakingTokenAmount: BigNumberish;
-  useUnderlyings: boolean;
-  redeemType: CurveRedeemType;
-  incomingAssetData: BytesLike;
-}) {
-  const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityAdapter,
-    encodedCallArgs: curveUnstakeAndRedeemArgs({
-      incomingAssetData,
-      outgoingStakingToken,
-      outgoingStakingTokenAmount,
-      pool,
-      redeemType,
-      useUnderlyings,
-    }),
-    selector: unstakeAndRedeemSelector,
-  });
-
-  return comptrollerProxy
-    .connect(signer)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}

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

@@ -1,104 +0,0 @@
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type { ComptrollerLib, IdleAdapter, IntegrationManager, StandardToken } from '@enzymefinance/protocol';
-import {
-  callOnIntegrationArgs,
-  claimRewardsSelector,
-  idleClaimRewardsArgs,
-  idleLendArgs,
-  idleRedeemArgs,
-  IntegrationManagerActionId,
-  lendSelector,
-  redeemSelector,
-} from '@enzymefinance/protocol';
-import type { BigNumberish } from 'ethers';
-import { BigNumber } from 'ethers';
-
-export async function idleClaimRewards({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  idleAdapter,
-  idleToken,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  idleAdapter: IdleAdapter;
-  idleToken: StandardToken;
-}) {
-  const callArgs = callOnIntegrationArgs({
-    adapter: idleAdapter,
-    encodedCallArgs: idleClaimRewardsArgs({
-      idleToken,
-    }),
-    selector: claimRewardsSelector,
-  });
-
-  return comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-
-export async function idleLend({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  idleAdapter,
-  idleToken,
-  outgoingUnderlyingAmount,
-  minIncomingIdleTokenAmount = BigNumber.from(1),
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  idleAdapter: IdleAdapter;
-  idleToken: StandardToken;
-  outgoingUnderlyingAmount: BigNumberish;
-  minIncomingIdleTokenAmount?: BigNumberish;
-}) {
-  const callArgs = callOnIntegrationArgs({
-    adapter: idleAdapter,
-    encodedCallArgs: idleLendArgs({
-      idleToken,
-      minIncomingIdleTokenAmount,
-      outgoingUnderlyingAmount,
-    }),
-    selector: lendSelector,
-  });
-
-  return comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}
-
-export async function idleRedeem({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  idleAdapter,
-  idleToken,
-  outgoingIdleTokenAmount,
-  minIncomingUnderlyingAmount = BigNumber.from(1),
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  idleAdapter: IdleAdapter;
-  idleToken: StandardToken;
-  outgoingIdleTokenAmount: BigNumberish;
-  minIncomingUnderlyingAmount?: BigNumberish;
-}) {
-  const callArgs = callOnIntegrationArgs({
-    adapter: idleAdapter,
-    encodedCallArgs: idleRedeemArgs({
-      idleToken,
-      minIncomingUnderlyingAmount,
-      outgoingIdleTokenAmount,
-    }),
-    selector: redeemSelector,
-  });
-
-  return comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}

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

@@ -1,14 +0,0 @@
-export * from './aave';
-export * from './compound';
-export * from './curve';
-export * from './idle';
-export * from './mock';
-export * from './olympusV2';
-export * from './paraSwapV5';
-export * from './poolTogetherV4';
-export * from './synthetix';
-export * from './trackedAssets';
-export * from './uniswapV2';
-export * from './uniswapV3';
-export * from './yearn';
-export * from './zeroExV2';

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

@@ -1,116 +0,0 @@
-import type { AddressLike } from '@enzymefinance/ethers';
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type {
-  ComptrollerLib,
-  IntegrationManager,
-  MockGenericAdapter,
-  StandardToken,
-  VaultLib,
-} from '@enzymefinance/protocol';
-import { callOnIntegrationArgs, encodeArgs, IntegrationManagerActionId, sighash } from '@enzymefinance/protocol';
-import type { BigNumberish, BytesLike } from 'ethers';
-import { utils } from 'ethers';
-
-export const mockGenericRemoveOnlySelector = sighash(
-  utils.FunctionFragment.fromString('removeOnly(address,bytes,bytes)'),
-);
-
-export const mockGenericSwapASelector = sighash(utils.FunctionFragment.fromString('swapA(address,bytes,bytes)'));
-
-export const mockGenericSwapBSelector = sighash(utils.FunctionFragment.fromString('swapB(address,bytes,bytes)'));
-
-export const mockGenericSwapDirectFromVaultSelector = sighash(
-  utils.FunctionFragment.fromString('swapDirectFromVault(address,bytes,bytes)'),
-);
-
-export const mockGenericSwapViaApprovalSelector = sighash(
-  utils.FunctionFragment.fromString('swapViaApproval(address,bytes,bytes)'),
-);
-
-export function mockGenericSwapArgs({
-  spendAssets = [],
-  actualSpendAssetAmounts = [],
-  maxSpendAssetAmounts = actualSpendAssetAmounts,
-  incomingAssets = [],
-  actualIncomingAssetAmounts = [],
-  minIncomingAssetAmounts = actualIncomingAssetAmounts,
-}: {
-  spendAssets?: AddressLike[];
-  maxSpendAssetAmounts?: BigNumberish[];
-  actualSpendAssetAmounts?: BigNumberish[];
-  incomingAssets?: AddressLike[];
-  minIncomingAssetAmounts?: BigNumberish[];
-  actualIncomingAssetAmounts?: BigNumberish[];
-}) {
-  return encodeArgs(
-    ['address[]', 'uint256[]', 'uint256[]', 'address[]', 'uint256[]', 'uint256[]'],
-    [
-      spendAssets,
-      maxSpendAssetAmounts,
-      actualSpendAssetAmounts,
-      incomingAssets,
-      minIncomingAssetAmounts,
-      actualIncomingAssetAmounts,
-    ],
-  );
-}
-
-export async function mockGenericSwap({
-  comptrollerProxy,
-  vaultProxy,
-  integrationManager,
-  fundOwner,
-  mockGenericAdapter,
-  selector = mockGenericSwapASelector,
-  spendAssets = [],
-  actualSpendAssetAmounts = [],
-  maxSpendAssetAmounts = actualSpendAssetAmounts,
-  incomingAssets = [],
-  actualIncomingAssetAmounts = [],
-  minIncomingAssetAmounts = actualIncomingAssetAmounts,
-  seedFund = false,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  vaultProxy: VaultLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  mockGenericAdapter: MockGenericAdapter;
-  selector?: BytesLike;
-  spendAssets?: StandardToken[];
-  maxSpendAssetAmounts?: BigNumberish[];
-  actualSpendAssetAmounts?: BigNumberish[];
-  incomingAssets?: StandardToken[];
-  minIncomingAssetAmounts?: BigNumberish[];
-  actualIncomingAssetAmounts?: BigNumberish[];
-  seedFund?: boolean;
-}) {
-  // Seed the VaultProxy with enough spendAssets for the tx
-  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 = callOnIntegrationArgs({
-    adapter: mockGenericAdapter,
-    encodedCallArgs: swapArgs,
-    selector,
-  });
-
-  const swapTx = comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-
-  await expect(swapTx).resolves.toBeReceipt();
-
-  return swapTx;
-}

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

@@ -1,71 +0,0 @@
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type { ComptrollerLib, IntegrationManager, OlympusV2Adapter } from '@enzymefinance/protocol';
-import {
-  callOnIntegrationArgs,
-  IntegrationManagerActionId,
-  olympusV2StakeArgs,
-  olympusV2UnstakeArgs,
-  stakeSelector,
-  unstakeSelector,
-} from '@enzymefinance/protocol';
-import type { BigNumberish } from 'ethers';
-
-export async function olympusV2Stake({
-  comptrollerProxy,
-  integrationManager,
-  signer,
-  olympusV2Adapter,
-  amount,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  signer: SignerWithAddress;
-  olympusV2Adapter: OlympusV2Adapter;
-  amount: BigNumberish;
-}) {
-  const stakeArgs = olympusV2StakeArgs({
-    amount,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: olympusV2Adapter,
-    encodedCallArgs: stakeArgs,
-    selector: stakeSelector,
-  });
-
-  const stakeTx = comptrollerProxy
-    .connect(signer)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-
-  return stakeTx;
-}
-
-export async function olympusV2Unstake({
-  comptrollerProxy,
-  integrationManager,
-  signer,
-  olympusV2Adapter,
-  amount,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  signer: SignerWithAddress;
-  olympusV2Adapter: OlympusV2Adapter;
-  amount: BigNumberish;
-}) {
-  const unstakeArgs = olympusV2UnstakeArgs({
-    amount,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: olympusV2Adapter,
-    encodedCallArgs: unstakeArgs,
-    selector: unstakeSelector,
-  });
-
-  const unstakeTx = comptrollerProxy
-    .connect(signer)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-
-  return unstakeTx;
-}