@enzymefinance/testutils 4.0.0-next.2 → 4.0.0-next.7

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

@@ -1,32 +1,37 @@
-import { AddressLike, Call, Contract, contract, Send } from '@enzymefinance/ethers';
-import { SignerWithAddress } from '@enzymefinance/hardhat';
+import type { AddressLike, Call, Contract, Send } from '@enzymefinance/ethers';
+import { contract } from '@enzymefinance/ethers';
+import type { SignerWithAddress } from '@enzymefinance/hardhat';
+import type {
+  ComptrollerLib,
+  CurveExchangeAdapter,
+  CurveLiquidityAaveAdapter,
+  CurveLiquidityAdapter,
+  CurveLiquiditySethAdapter,
+  CurveLiquidityStethAdapter,
+  CurveRedeemType,
+  IntegrationManager,
+  StandardToken,
+} from '@enzymefinance/protocol';
 import {
   callOnIntegrationArgs,
   claimRewardsSelector,
-  ComptrollerLib,
   curveAaveLendAndStakeArgs,
   curveAaveLendArgs,
   curveAaveRedeemArgs,
   curveAaveStakeArgs,
   curveAaveUnstakeAndRedeemArgs,
   curveAaveUnstakeArgs,
-  curveEursLendAndStakeArgs,
-  curveEursLendArgs,
-  curveEursRedeemArgs,
-  curveEursStakeArgs,
-  curveEursUnstakeAndRedeemArgs,
-  curveEursUnstakeArgs,
-  CurveExchangeAdapter,
-  CurveLiquidityAaveAdapter,
-  CurveLiquidityEursAdapter,
-  CurveLiquiditySethAdapter,
-  CurveLiquidityStethAdapter,
+  curveClaimRewardsArgs,
+  curveLendAndStakeArgs,
+  curveLendArgs,
+  curveRedeemArgs,
   curveSethLendAndStakeArgs,
   curveSethLendArgs,
   curveSethRedeemArgs,
   curveSethStakeArgs,
   curveSethUnstakeAndRedeemArgs,
   curveSethUnstakeArgs,
+  curveStakeArgs,
   curveStethLendAndStakeArgs,
   curveStethLendArgs,
   curveStethRedeemArgs,
@@ -34,18 +39,19 @@ import {
   curveStethUnstakeAndRedeemArgs,
   curveStethUnstakeArgs,
   curveTakeOrderArgs,
-  IntegrationManager,
+  curveUnstakeAndRedeemArgs,
+  curveUnstakeArgs,
   IntegrationManagerActionId,
   lendAndStakeSelector,
   lendSelector,
   redeemSelector,
   stakeSelector,
-  StandardToken,
   takeOrderSelector,
   unstakeAndRedeemSelector,
   unstakeSelector,
 } from '@enzymefinance/protocol';
-import { BigNumber, BigNumberish, constants, utils } from 'ethers';
+import type { BigNumberish, BytesLike } from 'ethers';
+import { BigNumber, constants, utils } from 'ethers';
 
 export interface CurveLiquidityGaugeV2 extends Contract<CurveLiquidityGaugeV2> {
   claim_rewards: Send<(_addr: AddressLike) => void>;
@@ -57,6 +63,16 @@ export const CurveLiquidityGaugeV2 = contract<CurveLiquidityGaugeV2>()`
   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>
@@ -98,17 +114,17 @@ export async function curveTakeOrder({
   minIncomingAssetAmount?: BigNumberish;
 }) {
   const takeOrderArgs = curveTakeOrderArgs({
+    incomingAsset,
+    minIncomingAssetAmount,
+    outgoingAsset,
+    outgoingAssetAmount,
     pool,
-    outgoingAsset: outgoingAsset,
-    outgoingAssetAmount: outgoingAssetAmount,
-    incomingAsset: incomingAsset,
-    minIncomingAssetAmount: minIncomingAssetAmount,
   });
 
   const callArgs = callOnIntegrationArgs({
     adapter: curveExchangeAdapter,
-    selector: takeOrderSelector,
     encodedCallArgs: takeOrderArgs,
+    selector: takeOrderSelector,
   });
 
   return comptrollerProxy
@@ -116,23 +132,25 @@ export async function curveTakeOrder({
     .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
 
-// aave pool
+// combined liquidity
 
-export function curveAaveClaimRewards({
+export function curveClaimRewards({
   comptrollerProxy,
   integrationManager,
   fundOwner,
-  curveLiquidityAaveAdapter,
+  curveLiquidityAdapter,
+  stakingToken,
 }: {
   comptrollerProxy: ComptrollerLib;
   integrationManager: IntegrationManager;
   fundOwner: SignerWithAddress;
-  curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
+  curveLiquidityAdapter: CurveLiquidityAdapter;
+  stakingToken: AddressLike;
 }) {
   const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityAaveAdapter,
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: curveClaimRewardsArgs({ stakingToken }),
     selector: claimRewardsSelector,
-    encodedCallArgs: constants.HashZero,
   });
 
   return comptrollerProxy
@@ -140,233 +158,239 @@ export function curveAaveClaimRewards({
     .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
 
-export function curveAaveLend({
+export async function curveLend({
   comptrollerProxy,
   integrationManager,
-  fundOwner,
-  curveLiquidityAaveAdapter,
-  outgoingAaveDaiAmount = BigNumber.from(0),
-  outgoingAaveUsdcAmount = BigNumber.from(0),
-  outgoingAaveUsdtAmount = BigNumber.from(0),
-  minIncomingLPTokenAmount = BigNumber.from(1),
-  useUnderlyings = false,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  orderedOutgoingAssetAmounts,
+  minIncomingLpTokenAmount = BigNumber.from(1),
+  useUnderlyings,
 }: {
   comptrollerProxy: ComptrollerLib;
   integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
-  outgoingAaveDaiAmount?: BigNumberish;
-  outgoingAaveUsdcAmount?: BigNumberish;
-  outgoingAaveUsdtAmount?: BigNumberish;
-  minIncomingLPTokenAmount?: BigNumberish;
-  useUnderlyings?: boolean;
+  signer: SignerWithAddress;
+  curveLiquidityAdapter: CurveLiquidityAdapter;
+  pool: AddressLike;
+  orderedOutgoingAssetAmounts: BigNumberish[];
+  minIncomingLpTokenAmount?: BigNumberish;
+  useUnderlyings: boolean;
 }) {
   const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityAaveAdapter,
-    selector: lendSelector,
-    encodedCallArgs: curveAaveLendArgs({
-      outgoingAaveDaiAmount,
-      outgoingAaveUsdcAmount,
-      outgoingAaveUsdtAmount,
-      minIncomingLPTokenAmount,
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: curveLendArgs({
+      minIncomingLpTokenAmount,
+      orderedOutgoingAssetAmounts,
+      pool,
       useUnderlyings,
     }),
+    selector: lendSelector,
   });
 
   return comptrollerProxy
-    .connect(fundOwner)
+    .connect(signer)
     .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
 
-export function curveAaveLendAndStake({
+export async function curveLendAndStake({
   comptrollerProxy,
   integrationManager,
-  fundOwner,
-  curveLiquidityAaveAdapter,
-  outgoingAaveDaiAmount = BigNumber.from(0),
-  outgoingAaveUsdcAmount = BigNumber.from(0),
-  outgoingAaveUsdtAmount = BigNumber.from(0),
-  minIncomingLiquidityGaugeTokenAmount = BigNumber.from(1),
-  useUnderlyings = false,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  orderedOutgoingAssetAmounts,
+  incomingStakingToken,
+  minIncomingStakingTokenAmount = BigNumber.from(1),
+  useUnderlyings,
 }: {
   comptrollerProxy: ComptrollerLib;
   integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
-  outgoingAaveDaiAmount?: BigNumberish;
-  outgoingAaveUsdcAmount?: BigNumberish;
-  outgoingAaveUsdtAmount?: BigNumberish;
-  minIncomingLiquidityGaugeTokenAmount?: BigNumberish;
-  useUnderlyings?: boolean;
+  signer: SignerWithAddress;
+  curveLiquidityAdapter: CurveLiquidityAdapter;
+  pool: AddressLike;
+  orderedOutgoingAssetAmounts: BigNumberish[];
+  incomingStakingToken: AddressLike;
+  minIncomingStakingTokenAmount?: BigNumberish;
+  useUnderlyings: boolean;
 }) {
   const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityAaveAdapter,
-    selector: lendAndStakeSelector,
-    encodedCallArgs: curveAaveLendAndStakeArgs({
-      outgoingAaveDaiAmount,
-      outgoingAaveUsdcAmount,
-      outgoingAaveUsdtAmount,
-      minIncomingLiquidityGaugeTokenAmount,
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: curveLendAndStakeArgs({
+      incomingStakingToken,
+      minIncomingStakingTokenAmount,
+      orderedOutgoingAssetAmounts,
+      pool,
       useUnderlyings,
     }),
+    selector: lendAndStakeSelector,
   });
 
   return comptrollerProxy
-    .connect(fundOwner)
+    .connect(signer)
     .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
 
-export function curveAaveRedeem({
+export async function curveRedeem({
   comptrollerProxy,
   integrationManager,
-  fundOwner,
-  curveLiquidityAaveAdapter,
-  outgoingLPTokenAmount,
-  minIncomingAaveDaiAmount = BigNumber.from(1),
-  minIncomingAaveUsdcAmount = BigNumber.from(1),
-  minIncomingAaveUsdtAmount = BigNumber.from(1),
-  receiveSingleAsset = false,
-  useUnderlyings = false,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  outgoingLpTokenAmount,
+  useUnderlyings,
+  redeemType,
+  incomingAssetData,
 }: {
   comptrollerProxy: ComptrollerLib;
   integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
-  outgoingLPTokenAmount: BigNumberish;
-  minIncomingAaveDaiAmount?: BigNumberish;
-  minIncomingAaveUsdcAmount?: BigNumberish;
-  minIncomingAaveUsdtAmount?: BigNumberish;
-  receiveSingleAsset?: boolean;
-  useUnderlyings?: boolean;
+  signer: SignerWithAddress;
+  curveLiquidityAdapter: CurveLiquidityAdapter;
+  pool: AddressLike;
+  outgoingLpTokenAmount: BigNumberish;
+  useUnderlyings: boolean;
+  redeemType: CurveRedeemType;
+  incomingAssetData: BytesLike;
 }) {
   const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityAaveAdapter,
-    selector: redeemSelector,
-    encodedCallArgs: curveAaveRedeemArgs({
-      outgoingLPTokenAmount,
-      minIncomingAaveDaiAmount,
-      minIncomingAaveUsdcAmount,
-      minIncomingAaveUsdtAmount,
-      receiveSingleAsset,
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: curveRedeemArgs({
+      incomingAssetData,
+      outgoingLpTokenAmount,
+      pool,
+      redeemType,
       useUnderlyings,
     }),
+    selector: redeemSelector,
   });
 
   return comptrollerProxy
-    .connect(fundOwner)
+    .connect(signer)
     .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
 
-export function curveAaveStake({
+export async function curveStake({
   comptrollerProxy,
   integrationManager,
-  fundOwner,
-  curveLiquidityAaveAdapter,
-  outgoingLPTokenAmount,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  incomingStakingToken,
+  amount,
 }: {
   comptrollerProxy: ComptrollerLib;
   integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
-  outgoingLPTokenAmount: BigNumberish;
+  signer: SignerWithAddress;
+  curveLiquidityAdapter: CurveLiquidityAdapter;
+  pool: AddressLike;
+  incomingStakingToken: AddressLike;
+  amount: BigNumberish;
 }) {
   const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityAaveAdapter,
-    selector: stakeSelector,
-    encodedCallArgs: curveAaveStakeArgs({
-      outgoingLPTokenAmount,
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: curveStakeArgs({
+      amount,
+      incomingStakingToken,
+      pool,
     }),
+    selector: stakeSelector,
   });
 
   return comptrollerProxy
-    .connect(fundOwner)
+    .connect(signer)
     .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
 
-export function curveAaveUnstakeAndRedeem({
+export async function curveUnstake({
   comptrollerProxy,
   integrationManager,
-  fundOwner,
-  curveLiquidityAaveAdapter,
-  outgoingLiquidityGaugeTokenAmount,
-  minIncomingAaveDaiAmount = BigNumber.from(1),
-  minIncomingAaveUsdcAmount = BigNumber.from(1),
-  minIncomingAaveUsdtAmount = BigNumber.from(1),
-  receiveSingleAsset = false,
-  useUnderlyings = false,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  outgoingStakingToken,
+  amount,
 }: {
   comptrollerProxy: ComptrollerLib;
   integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
-  outgoingLiquidityGaugeTokenAmount: BigNumberish;
-  minIncomingAaveDaiAmount?: BigNumberish;
-  minIncomingAaveUsdcAmount?: BigNumberish;
-  minIncomingAaveUsdtAmount?: BigNumberish;
-  receiveSingleAsset?: boolean;
-  useUnderlyings?: boolean;
+  signer: SignerWithAddress;
+  curveLiquidityAdapter: CurveLiquidityAdapter;
+  pool: AddressLike;
+  outgoingStakingToken: AddressLike;
+  amount: BigNumberish;
 }) {
   const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityAaveAdapter,
-    selector: unstakeAndRedeemSelector,
-    encodedCallArgs: curveAaveUnstakeAndRedeemArgs({
-      outgoingLiquidityGaugeTokenAmount,
-      minIncomingAaveDaiAmount,
-      minIncomingAaveUsdcAmount,
-      minIncomingAaveUsdtAmount,
-      receiveSingleAsset,
-      useUnderlyings,
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: curveUnstakeArgs({
+      amount,
+      outgoingStakingToken,
+      pool,
     }),
+    selector: unstakeSelector,
   });
 
   return comptrollerProxy
-    .connect(fundOwner)
+    .connect(signer)
     .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
 
-export function curveAaveUnstake({
+export async function curveUnstakeAndRedeem({
   comptrollerProxy,
   integrationManager,
-  fundOwner,
-  curveLiquidityAaveAdapter,
-  outgoingLiquidityGaugeTokenAmount,
+  signer,
+  curveLiquidityAdapter,
+  pool,
+  outgoingStakingToken,
+  outgoingStakingTokenAmount,
+  useUnderlyings,
+  redeemType,
+  incomingAssetData,
 }: {
   comptrollerProxy: ComptrollerLib;
   integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
-  outgoingLiquidityGaugeTokenAmount: BigNumberish;
+  signer: SignerWithAddress;
+  curveLiquidityAdapter: CurveLiquidityAdapter;
+  pool: AddressLike;
+  outgoingStakingToken: StandardToken;
+  outgoingStakingTokenAmount: BigNumberish;
+  useUnderlyings: boolean;
+  redeemType: CurveRedeemType;
+  incomingAssetData: BytesLike;
 }) {
   const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityAaveAdapter,
-    selector: unstakeSelector,
-    encodedCallArgs: curveAaveUnstakeArgs({
-      outgoingLiquidityGaugeTokenAmount,
+    adapter: curveLiquidityAdapter,
+    encodedCallArgs: curveUnstakeAndRedeemArgs({
+      incomingAssetData,
+      outgoingStakingToken,
+      outgoingStakingTokenAmount,
+      pool,
+      redeemType,
+      useUnderlyings,
     }),
+    selector: unstakeAndRedeemSelector,
   });
 
   return comptrollerProxy
-    .connect(fundOwner)
+    .connect(signer)
     .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
 
-// eurs pool
+// aave pool
 
-export function curveEursClaimRewards({
+export function curveAaveClaimRewards({
   comptrollerProxy,
   integrationManager,
   fundOwner,
-  curveLiquidityEursAdapter,
+  curveLiquidityAaveAdapter,
 }: {
   comptrollerProxy: ComptrollerLib;
   integrationManager: IntegrationManager;
   fundOwner: SignerWithAddress;
-  curveLiquidityEursAdapter: CurveLiquidityEursAdapter;
+  curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
 }) {
   const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    selector: claimRewardsSelector,
+    adapter: curveLiquidityAaveAdapter,
     encodedCallArgs: constants.HashZero,
+    selector: claimRewardsSelector,
   });
 
   return comptrollerProxy
@@ -374,31 +398,37 @@ export function curveEursClaimRewards({
     .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
 
-export function curveEursLend({
+export function curveAaveLend({
   comptrollerProxy,
   integrationManager,
   fundOwner,
-  curveLiquidityEursAdapter,
-  outgoingEursAmount,
-  outgoingSeurAmount,
-  minIncomingLPTokenAmount,
+  curveLiquidityAaveAdapter,
+  outgoingAaveDaiAmount = BigNumber.from(0),
+  outgoingAaveUsdcAmount = BigNumber.from(0),
+  outgoingAaveUsdtAmount = BigNumber.from(0),
+  minIncomingLPTokenAmount = BigNumber.from(1),
+  useUnderlyings = false,
 }: {
   comptrollerProxy: ComptrollerLib;
   integrationManager: IntegrationManager;
   fundOwner: SignerWithAddress;
-  curveLiquidityEursAdapter: CurveLiquidityEursAdapter;
-  outgoingEursAmount: BigNumberish;
-  outgoingSeurAmount: BigNumberish;
-  minIncomingLPTokenAmount: BigNumberish;
+  curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
+  outgoingAaveDaiAmount?: BigNumberish;
+  outgoingAaveUsdcAmount?: BigNumberish;
+  outgoingAaveUsdtAmount?: BigNumberish;
+  minIncomingLPTokenAmount?: BigNumberish;
+  useUnderlyings?: boolean;
 }) {
   const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    selector: lendSelector,
-    encodedCallArgs: curveEursLendArgs({
-      outgoingEursAmount,
-      outgoingSeurAmount,
+    adapter: curveLiquidityAaveAdapter,
+    encodedCallArgs: curveAaveLendArgs({
       minIncomingLPTokenAmount,
+      outgoingAaveDaiAmount,
+      outgoingAaveUsdcAmount,
+      outgoingAaveUsdtAmount,
+      useUnderlyings,
     }),
+    selector: lendSelector,
   });
 
   return comptrollerProxy
@@ -406,31 +436,37 @@ export function curveEursLend({
     .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
 
-export function curveEursLendAndStake({
+export function curveAaveLendAndStake({
   comptrollerProxy,
   integrationManager,
   fundOwner,
-  curveLiquidityEursAdapter,
-  outgoingEursAmount,
-  outgoingSeurAmount,
-  minIncomingLiquidityGaugeTokenAmount,
+  curveLiquidityAaveAdapter,
+  outgoingAaveDaiAmount = BigNumber.from(0),
+  outgoingAaveUsdcAmount = BigNumber.from(0),
+  outgoingAaveUsdtAmount = BigNumber.from(0),
+  minIncomingLiquidityGaugeTokenAmount = BigNumber.from(1),
+  useUnderlyings = false,
 }: {
   comptrollerProxy: ComptrollerLib;
   integrationManager: IntegrationManager;
   fundOwner: SignerWithAddress;
-  curveLiquidityEursAdapter: CurveLiquidityEursAdapter;
-  outgoingEursAmount: BigNumberish;
-  outgoingSeurAmount: BigNumberish;
-  minIncomingLiquidityGaugeTokenAmount: BigNumberish;
+  curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
+  outgoingAaveDaiAmount?: BigNumberish;
+  outgoingAaveUsdcAmount?: BigNumberish;
+  outgoingAaveUsdtAmount?: BigNumberish;
+  minIncomingLiquidityGaugeTokenAmount?: BigNumberish;
+  useUnderlyings?: boolean;
 }) {
   const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    selector: lendAndStakeSelector,
-    encodedCallArgs: curveEursLendAndStakeArgs({
-      outgoingEursAmount,
-      outgoingSeurAmount,
+    adapter: curveLiquidityAaveAdapter,
+    encodedCallArgs: curveAaveLendAndStakeArgs({
       minIncomingLiquidityGaugeTokenAmount,
+      outgoingAaveDaiAmount,
+      outgoingAaveUsdcAmount,
+      outgoingAaveUsdtAmount,
+      useUnderlyings,
     }),
+    selector: lendAndStakeSelector,
   });
 
   return comptrollerProxy
@@ -438,34 +474,40 @@ export function curveEursLendAndStake({
     .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
 
-export function curveEursRedeem({
+export function curveAaveRedeem({
   comptrollerProxy,
   integrationManager,
   fundOwner,
-  curveLiquidityEursAdapter,
+  curveLiquidityAaveAdapter,
   outgoingLPTokenAmount,
-  minIncomingEursAmount,
-  minIncomingSeurAmount,
-  receiveSingleAsset,
+  minIncomingAaveDaiAmount = BigNumber.from(1),
+  minIncomingAaveUsdcAmount = BigNumber.from(1),
+  minIncomingAaveUsdtAmount = BigNumber.from(1),
+  receiveSingleAsset = false,
+  useUnderlyings = false,
 }: {
   comptrollerProxy: ComptrollerLib;
   integrationManager: IntegrationManager;
   fundOwner: SignerWithAddress;
-  curveLiquidityEursAdapter: CurveLiquidityEursAdapter;
+  curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
   outgoingLPTokenAmount: BigNumberish;
-  minIncomingEursAmount: BigNumberish;
-  minIncomingSeurAmount: BigNumberish;
-  receiveSingleAsset: boolean;
+  minIncomingAaveDaiAmount?: BigNumberish;
+  minIncomingAaveUsdcAmount?: BigNumberish;
+  minIncomingAaveUsdtAmount?: BigNumberish;
+  receiveSingleAsset?: boolean;
+  useUnderlyings?: boolean;
 }) {
   const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    selector: redeemSelector,
-    encodedCallArgs: curveEursRedeemArgs({
+    adapter: curveLiquidityAaveAdapter,
+    encodedCallArgs: curveAaveRedeemArgs({
+      minIncomingAaveDaiAmount,
+      minIncomingAaveUsdcAmount,
+      minIncomingAaveUsdtAmount,
       outgoingLPTokenAmount,
-      minIncomingEursAmount,
-      minIncomingSeurAmount,
       receiveSingleAsset,
+      useUnderlyings,
     }),
+    selector: redeemSelector,
   });
 
   return comptrollerProxy
@@ -473,25 +515,25 @@ export function curveEursRedeem({
     .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
 
-export function curveEursStake({
+export function curveAaveStake({
   comptrollerProxy,
   integrationManager,
   fundOwner,
-  curveLiquidityEursAdapter,
+  curveLiquidityAaveAdapter,
   outgoingLPTokenAmount,
 }: {
   comptrollerProxy: ComptrollerLib;
   integrationManager: IntegrationManager;
   fundOwner: SignerWithAddress;
-  curveLiquidityEursAdapter: CurveLiquidityEursAdapter;
+  curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
   outgoingLPTokenAmount: BigNumberish;
 }) {
   const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    selector: stakeSelector,
-    encodedCallArgs: curveEursStakeArgs({
+    adapter: curveLiquidityAaveAdapter,
+    encodedCallArgs: curveAaveStakeArgs({
       outgoingLPTokenAmount,
     }),
+    selector: stakeSelector,
   });
 
   return comptrollerProxy
@@ -499,34 +541,40 @@ export function curveEursStake({
     .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
 
-export function curveEursUnstakeAndRedeem({
+export function curveAaveUnstakeAndRedeem({
   comptrollerProxy,
   integrationManager,
   fundOwner,
-  curveLiquidityEursAdapter,
+  curveLiquidityAaveAdapter,
   outgoingLiquidityGaugeTokenAmount,
-  minIncomingEursAmount,
-  minIncomingSeurAmount,
-  receiveSingleAsset,
+  minIncomingAaveDaiAmount = BigNumber.from(1),
+  minIncomingAaveUsdcAmount = BigNumber.from(1),
+  minIncomingAaveUsdtAmount = BigNumber.from(1),
+  receiveSingleAsset = false,
+  useUnderlyings = false,
 }: {
   comptrollerProxy: ComptrollerLib;
   integrationManager: IntegrationManager;
   fundOwner: SignerWithAddress;
-  curveLiquidityEursAdapter: CurveLiquidityEursAdapter;
+  curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
   outgoingLiquidityGaugeTokenAmount: BigNumberish;
-  minIncomingEursAmount: BigNumberish;
-  minIncomingSeurAmount: BigNumberish;
-  receiveSingleAsset: boolean;
+  minIncomingAaveDaiAmount?: BigNumberish;
+  minIncomingAaveUsdcAmount?: BigNumberish;
+  minIncomingAaveUsdtAmount?: BigNumberish;
+  receiveSingleAsset?: boolean;
+  useUnderlyings?: boolean;
 }) {
   const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    selector: unstakeAndRedeemSelector,
-    encodedCallArgs: curveEursUnstakeAndRedeemArgs({
+    adapter: curveLiquidityAaveAdapter,
+    encodedCallArgs: curveAaveUnstakeAndRedeemArgs({
+      minIncomingAaveDaiAmount,
+      minIncomingAaveUsdcAmount,
+      minIncomingAaveUsdtAmount,
       outgoingLiquidityGaugeTokenAmount,
-      minIncomingEursAmount,
-      minIncomingSeurAmount,
       receiveSingleAsset,
+      useUnderlyings,
     }),
+    selector: unstakeAndRedeemSelector,
   });
 
   return comptrollerProxy
@@ -534,25 +582,25 @@ export function curveEursUnstakeAndRedeem({
     .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
 
-export function curveEursUnstake({
+export function curveAaveUnstake({
   comptrollerProxy,
   integrationManager,
   fundOwner,
-  curveLiquidityEursAdapter,
+  curveLiquidityAaveAdapter,
   outgoingLiquidityGaugeTokenAmount,
 }: {
   comptrollerProxy: ComptrollerLib;
   integrationManager: IntegrationManager;
   fundOwner: SignerWithAddress;
-  curveLiquidityEursAdapter: CurveLiquidityEursAdapter;
+  curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
   outgoingLiquidityGaugeTokenAmount: BigNumberish;
 }) {
   const callArgs = callOnIntegrationArgs({
-    adapter: curveLiquidityEursAdapter,
-    selector: unstakeSelector,
-    encodedCallArgs: curveEursUnstakeArgs({
+    adapter: curveLiquidityAaveAdapter,
+    encodedCallArgs: curveAaveUnstakeArgs({
       outgoingLiquidityGaugeTokenAmount,
     }),
+    selector: unstakeSelector,
   });
 
   return comptrollerProxy
@@ -575,8 +623,8 @@ export function curveSethClaimRewards({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: curveLiquiditySethAdapter,
-    selector: claimRewardsSelector,
     encodedCallArgs: constants.HashZero,
+    selector: claimRewardsSelector,
   });
 
   return comptrollerProxy
@@ -603,12 +651,12 @@ export function curveSethLend({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: curveLiquiditySethAdapter,
-    selector: lendSelector,
     encodedCallArgs: curveSethLendArgs({
-      outgoingWethAmount,
-      outgoingSethAmount,
       minIncomingLPTokenAmount,
+      outgoingSethAmount,
+      outgoingWethAmount,
     }),
+    selector: lendSelector,
   });
 
   return comptrollerProxy
@@ -635,12 +683,12 @@ export function curveSethLendAndStake({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: curveLiquiditySethAdapter,
-    selector: lendAndStakeSelector,
     encodedCallArgs: curveSethLendAndStakeArgs({
-      outgoingWethAmount,
-      outgoingSethAmount,
       minIncomingLiquidityGaugeTokenAmount,
+      outgoingSethAmount,
+      outgoingWethAmount,
     }),
+    selector: lendAndStakeSelector,
   });
 
   return comptrollerProxy
@@ -669,13 +717,13 @@ export function curveSethRedeem({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: curveLiquiditySethAdapter,
-    selector: redeemSelector,
     encodedCallArgs: curveSethRedeemArgs({
-      outgoingLPTokenAmount,
-      minIncomingWethAmount,
       minIncomingSethAmount,
+      minIncomingWethAmount,
+      outgoingLPTokenAmount,
       receiveSingleAsset,
     }),
+    selector: redeemSelector,
   });
 
   return comptrollerProxy
@@ -698,10 +746,10 @@ export function curveSethStake({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: curveLiquiditySethAdapter,
-    selector: stakeSelector,
     encodedCallArgs: curveSethStakeArgs({
       outgoingLPTokenAmount,
     }),
+    selector: stakeSelector,
   });
 
   return comptrollerProxy
@@ -730,13 +778,13 @@ export function curveSethUnstakeAndRedeem({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: curveLiquiditySethAdapter,
-    selector: unstakeAndRedeemSelector,
     encodedCallArgs: curveSethUnstakeAndRedeemArgs({
-      outgoingLiquidityGaugeTokenAmount,
-      minIncomingWethAmount,
       minIncomingSethAmount,
+      minIncomingWethAmount,
+      outgoingLiquidityGaugeTokenAmount,
       receiveSingleAsset,
     }),
+    selector: unstakeAndRedeemSelector,
   });
 
   return comptrollerProxy
@@ -759,10 +807,10 @@ export function curveSethUnstake({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: curveLiquiditySethAdapter,
-    selector: unstakeSelector,
     encodedCallArgs: curveSethUnstakeArgs({
       outgoingLiquidityGaugeTokenAmount,
     }),
+    selector: unstakeSelector,
   });
 
   return comptrollerProxy
@@ -785,8 +833,8 @@ export function curveStethClaimRewards({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: curveLiquidityStethAdapter,
-    selector: claimRewardsSelector,
     encodedCallArgs: constants.HashZero,
+    selector: claimRewardsSelector,
   });
 
   return comptrollerProxy
@@ -813,12 +861,12 @@ export function curveStethLend({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: curveLiquidityStethAdapter,
-    selector: lendSelector,
     encodedCallArgs: curveStethLendArgs({
-      outgoingWethAmount,
-      outgoingStethAmount,
       minIncomingLPTokenAmount,
+      outgoingStethAmount,
+      outgoingWethAmount,
     }),
+    selector: lendSelector,
   });
 
   return comptrollerProxy
@@ -845,12 +893,12 @@ export function curveStethLendAndStake({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: curveLiquidityStethAdapter,
-    selector: lendAndStakeSelector,
     encodedCallArgs: curveStethLendAndStakeArgs({
-      outgoingWethAmount,
-      outgoingStethAmount,
       minIncomingLiquidityGaugeTokenAmount,
+      outgoingStethAmount,
+      outgoingWethAmount,
     }),
+    selector: lendAndStakeSelector,
   });
 
   return comptrollerProxy
@@ -879,13 +927,13 @@ export function curveStethRedeem({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: curveLiquidityStethAdapter,
-    selector: redeemSelector,
     encodedCallArgs: curveStethRedeemArgs({
-      outgoingLPTokenAmount,
-      minIncomingWethAmount,
       minIncomingStethAmount,
+      minIncomingWethAmount,
+      outgoingLPTokenAmount,
       receiveSingleAsset,
     }),
+    selector: redeemSelector,
   });
 
   return comptrollerProxy
@@ -908,10 +956,10 @@ export function curveStethStake({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: curveLiquidityStethAdapter,
-    selector: stakeSelector,
     encodedCallArgs: curveStethStakeArgs({
       outgoingLPTokenAmount,
     }),
+    selector: stakeSelector,
   });
 
   return comptrollerProxy
@@ -940,13 +988,13 @@ export function curveStethUnstakeAndRedeem({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: curveLiquidityStethAdapter,
-    selector: unstakeAndRedeemSelector,
     encodedCallArgs: curveStethUnstakeAndRedeemArgs({
-      outgoingLiquidityGaugeTokenAmount,
-      minIncomingWethAmount,
       minIncomingStethAmount,
+      minIncomingWethAmount,
+      outgoingLiquidityGaugeTokenAmount,
       receiveSingleAsset,
     }),
+    selector: unstakeAndRedeemSelector,
   });
 
   return comptrollerProxy
@@ -969,10 +1017,10 @@ export function curveStethUnstake({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: curveLiquidityStethAdapter,
-    selector: unstakeSelector,
     encodedCallArgs: curveStethUnstakeArgs({
       outgoingLiquidityGaugeTokenAmount,
     }),
+    selector: unstakeSelector,
   });
 
   return comptrollerProxy