@cowprotocol/sdk-flash-loans 1.0.0

package/dist/index.js

@@ -0,0 +1,663 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AAVE_ADAPTER_FACTORY: () => AAVE_ADAPTER_FACTORY,
+  AAVE_COLLATERAL_SWAP_ADAPTER_HOOK: () => AAVE_COLLATERAL_SWAP_ADAPTER_HOOK,
+  AAVE_POOL_ADDRESS: () => AAVE_POOL_ADDRESS,
+  ADAPTER_DOMAIN_NAME: () => ADAPTER_DOMAIN_NAME,
+  ADAPTER_DOMAIN_VERSION: () => ADAPTER_DOMAIN_VERSION,
+  ADAPTER_SIGNATURE_TYPES: () => ADAPTER_SIGNATURE_TYPES,
+  AaveCollateralSwapSdk: () => AaveCollateralSwapSdk,
+  DEFAULT_HOOK_GAS_LIMIT: () => DEFAULT_HOOK_GAS_LIMIT,
+  DEFAULT_VALIDITY: () => DEFAULT_VALIDITY,
+  EMPTY_PERMIT: () => EMPTY_PERMIT,
+  GAS_ESTIMATION_ADDITION_PERCENT: () => GAS_ESTIMATION_ADDITION_PERCENT,
+  HASH_ZERO: () => HASH_ZERO,
+  PERCENT_SCALE: () => PERCENT_SCALE
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/aave/AaveCollateralSwapSdk.ts
+var import_sdk_common = require("@cowprotocol/sdk-common");
+var import_sdk_order_signing = require("@cowprotocol/sdk-order-signing");
+var import_sdk_order_book = require("@cowprotocol/sdk-order-book");
+
+// src/aave/const.ts
+var import_sdk_config = require("@cowprotocol/sdk-config");
+var HASH_ZERO = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var AAVE_POOL_ADDRESS = (0, import_sdk_config.mapAddressToSupportedNetworks)("0xb50201558B00496A145fE76f7424749556E326D8");
+var AAVE_ADAPTER_FACTORY = {
+  ...(0, import_sdk_config.mapAddressToSupportedNetworks)("0x1186B5ad42E3e6d6c6901FC53b4A367540E6EcFE"),
+  [import_sdk_config.SupportedChainId.GNOSIS_CHAIN]: "0x889ee28C0a8a41a312546A8eeD77b4b097C84016"
+};
+var AAVE_COLLATERAL_SWAP_ADAPTER_HOOK = {
+  ...(0, import_sdk_config.mapAddressToSupportedNetworks)("0xe80eE1e73f120b1106179Ae3D582CA4Fd768d517"),
+  [import_sdk_config.SupportedChainId.GNOSIS_CHAIN]: "0x0aeC794e544B81D96149a4C8C1cC57c6F31A978A"
+};
+var DEFAULT_HOOK_GAS_LIMIT = {
+  pre: 300000n,
+  post: 600000n
+};
+var PERCENT_SCALE = 1e4;
+var DEFAULT_VALIDITY = 10 * 60;
+var GAS_ESTIMATION_ADDITION_PERCENT = 10;
+var ADAPTER_DOMAIN_NAME = "AaveAdapterFactory";
+var ADAPTER_DOMAIN_VERSION = "1";
+var ADAPTER_SIGNATURE_TYPES = {
+  AdapterOrderSig: [
+    { name: "instance", type: "address" },
+    { name: "sellToken", type: "address" },
+    { name: "buyToken", type: "address" },
+    { name: "sellAmount", type: "uint256" },
+    { name: "buyAmount", type: "uint256" },
+    { name: "kind", type: "bytes32" },
+    { name: "validTo", type: "uint32" },
+    { name: "appData", type: "bytes32" }
+  ]
+};
+var EMPTY_PERMIT = {
+  amount: "0",
+  deadline: 0,
+  v: 0,
+  r: HASH_ZERO,
+  s: HASH_ZERO
+};
+
+// src/aave/abi/AaveAdapterFactory.ts
+var aaveAdapterFactoryAbi = [
+  {
+    type: "function",
+    name: "getInstanceDeterministicAddress",
+    inputs: [
+      {
+        name: "adapterImplementation",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "hookData",
+        type: "tuple",
+        internalType: "struct DataTypes.HookOrderData",
+        components: [
+          {
+            name: "owner",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "receiver",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "sellToken",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "buyToken",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "sellAmount",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "buyAmount",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "kind",
+            type: "bytes32",
+            internalType: "bytes32"
+          },
+          {
+            name: "validTo",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "flashLoanAmount",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "flashLoanFeeAmount",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "hookSellTokenAmount",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "hookBuyTokenAmount",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "deployAndTransferFlashLoan",
+    inputs: [
+      {
+        name: "adapterImplementation",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "hookData",
+        type: "tuple",
+        internalType: "struct DataTypes.HookOrderData",
+        components: [
+          {
+            name: "owner",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "receiver",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "sellToken",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "buyToken",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "sellAmount",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "buyAmount",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "kind",
+            type: "bytes32",
+            internalType: "bytes32"
+          },
+          {
+            name: "validTo",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "flashLoanAmount",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "flashLoanFeeAmount",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "hookSellTokenAmount",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "hookBuyTokenAmount",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    inputs: [],
+    name: "DOMAIN_SEPARATOR",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/aave/abi/CollateralSwapAdapterHook.ts
+var collateralSwapAdapterHookAbi = [
+  {
+    type: "function",
+    name: "collateralSwapWithFlashLoan",
+    inputs: [
+      {
+        name: "erc20Permit",
+        type: "tuple",
+        internalType: "struct DataTypes.Permit",
+        components: [
+          {
+            name: "amount",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "deadline",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "v",
+            type: "uint8",
+            internalType: "uint8"
+          },
+          {
+            name: "r",
+            type: "bytes32",
+            internalType: "bytes32"
+          },
+          {
+            name: "s",
+            type: "bytes32",
+            internalType: "bytes32"
+          }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  }
+];
+
+// src/aave/AaveCollateralSwapSdk.ts
+var AaveCollateralSwapSdk = class {
+  /**
+   * Executes a collateral swap using Aave flash loans.
+   *
+   * @remarks This method orchestrates a complex flash loan operation:
+   *          1. Borrows the sell token via Aave flash loan
+   *          2. Uses CoW hooks to deploy adapter contracts and manage the swap
+   *          3. Executes a CoW Protocol swap to the buy token
+   *          4. Repays the flash loan with fees
+   *
+   *          The order is signed using EIP-1271 with a deterministically generated
+   *          smart contract address as the signer.
+   *
+   * @param {CollateralSwapParams} params - Configuration for the collateral swap.
+   * @param {TradingSdk} tradingSdk - @cowprotocol/sdk-trading.
+   * @returns {Promise<OrderPostingResult>} The result of posting the order to CoW Protocol.
+   *
+   * @throws Will throw if the quote fails, contract deployment fails, or gas estimation fails.
+   * ```
+   */
+  async collateralSwap(params, tradingSdk) {
+    const quoteParams = await this.getSwapQuoteParams(params);
+    const {
+      collateralToken,
+      tradeParameters: { amount },
+      settings
+    } = params;
+    const sellAmount = BigInt(amount);
+    const quoteAndPost = await tradingSdk.getQuote(quoteParams);
+    const { quoteResults, postSwapOrderFromQuote } = quoteAndPost;
+    const { swapSettings, instanceAddress } = await this.getOrderPostingSettings(quoteParams, {
+      sellAmount,
+      buyAmount: quoteResults.amountsAndCosts.afterSlippage.buyAmount,
+      orderToSign: quoteResults.orderToSign,
+      collateralPermit: settings?.collateralPermit
+    });
+    const collateralParams = {
+      instanceAddress,
+      trader: quoteParams.owner,
+      collateralToken,
+      amount: sellAmount
+    };
+    if (!settings?.preventApproval && !settings?.collateralPermit) {
+      await this.approveCollateralIfNeeded(collateralParams, sellAmount);
+    }
+    return postSwapOrderFromQuote(swapSettings);
+  }
+  /**
+   * Prepares quote parameters for the collateral swap operation.
+   *
+   * @remarks This method calculates the adjusted swap amount after deducting the flash loan fee,
+   *          resolves the trader address, and computes the order validity timestamp. The flash
+   *          loan fee is deducted from the sell amount before requesting a quote to ensure the
+   *          final swap amount covers both the desired output and the flash loan repayment.
+   *
+   * @param {CollateralSwapParams} params - The collateral swap parameters including chain ID,
+   *                                         trade parameters, and optional flash loan fee percentage.
+   * @returns {Promise<CollateralSwapQuoteParams>} Quote parameters with adjusted amounts and
+   *                                                 computed validity period.
+   * ```
+   */
+  async getSwapQuoteParams(params) {
+    const { chainId, tradeParameters, flashLoanFeePercent = 0 } = params;
+    const { validFor = DEFAULT_VALIDITY, owner, amount } = tradeParameters;
+    const adapter = (0, import_sdk_common.getGlobalAdapter)();
+    const trader = owner ?? await adapter.signer.getAddress();
+    const validTo = tradeParameters.validTo ?? Math.ceil(Date.now() / 1e3) + validFor;
+    const sellAmount = BigInt(amount);
+    if (!Number.isFinite(flashLoanFeePercent) || flashLoanFeePercent < 0 || flashLoanFeePercent > 100) {
+      throw new Error(`flashLoanFeePercent must be between 0 and 100, got: ${flashLoanFeePercent}`);
+    }
+    const { flashLoanFeeAmount, sellAmountToSign } = this.calculateFlashLoanAmounts({ flashLoanFeePercent, sellAmount });
+    const { validFor: _, ...restParameters } = tradeParameters;
+    return {
+      ...restParameters,
+      flashLoanFeeAmount,
+      chainId,
+      owner: trader,
+      amount: sellAmountToSign.toString(),
+      validTo
+    };
+  }
+  /**
+   * Generates order posting settings including hooks and flash loan metadata.
+   *
+   * @remarks This method constructs the complete order posting configuration for a flash loan-based
+   *          collateral swap. It:
+   *          - Encodes the order data for EIP-1271 signature verification
+   *          - Calculates the deterministic address for the adapter contract
+   *          - Configures pre and post-execution hooks for flash loan management
+   *          - Generates flash loan hint metadata conforming to the flashloan v0.2.0 schema
+   *          - Sets up EIP-1271 signing scheme with the expected instance address
+   *          - Includes hooks configuration following the hooks v0.2.0 schema
+   *
+   *          The flash loan metadata includes information about the Aave pool, protocol adapter,
+   *          and token amounts required for execution. The hooks enable the order to trigger
+   *          flash loan deployment (pre-hook) and collateral swap execution (post-hook).
+   *
+   * @param {CollateralSwapTradeParams} params - Trade parameters including chain ID, validity period,
+   *                                              owner address, and flash loan fee amount.
+   * @param {CollateralSwapOrder} settings - Order configuration including sell/buy amounts, the
+   *                                          unsigned order to sign, and optional collateral permit data.
+   * @returns {Promise<CollateralSwapPostParams>} Object containing swap advanced settings with
+   *                                               appData metadata (flashloan + hooks) and the
+   *                                               deterministic adapter instance address.
+   *
+   * @throws Will throw if contract address calculation fails or gas estimation fails.
+   * ```
+   */
+  async getOrderPostingSettings(params, settings) {
+    const { sellAmount, buyAmount, orderToSign, collateralPermit } = settings;
+    const { chainId, flashLoanFeeAmount, validTo, owner: trader } = params;
+    const amount = sellAmount.toString();
+    const encodedOrder = {
+      ...import_sdk_order_signing.OrderSigningUtils.encodeUnsignedOrder(orderToSign),
+      appData: HASH_ZERO,
+      validTo
+    };
+    const hookAmounts = {
+      flashLoanAmount: amount,
+      flashLoanFeeAmount: flashLoanFeeAmount.toString(),
+      sellAssetAmount: amount,
+      buyAssetAmount: buyAmount.toString()
+    };
+    const instanceAddress = await this.getExpectedInstanceAddress(chainId, trader, hookAmounts, encodedOrder);
+    const flashLoanHint = {
+      amount,
+      // this is actually in UNDERLYING but aave tokens are 1:1
+      receiver: AAVE_ADAPTER_FACTORY[chainId],
+      liquidityProvider: AAVE_POOL_ADDRESS[chainId],
+      protocolAdapter: AAVE_ADAPTER_FACTORY[chainId],
+      token: orderToSign.sellToken
+    };
+    const hooks = await this.getOrderHooks(
+      chainId,
+      trader,
+      instanceAddress,
+      hookAmounts,
+      {
+        ...encodedOrder,
+        receiver: instanceAddress
+      },
+      collateralPermit
+    );
+    const swapSettings = {
+      quoteRequest: {
+        validTo,
+        receiver: instanceAddress,
+        from: instanceAddress
+      },
+      additionalParams: {
+        signingScheme: import_sdk_order_book.SigningScheme.EIP1271,
+        customEIP1271Signature: (orderToSign2, signer) => {
+          return this.adapterEIP1271Signature(chainId, instanceAddress, orderToSign2, signer);
+        }
+      },
+      appData: {
+        metadata: {
+          flashloan: flashLoanHint,
+          hooks
+        }
+      }
+    };
+    return {
+      swapSettings,
+      instanceAddress
+    };
+  }
+  /**
+   * Checks the current allowance for the flash loan adapter to spend collateral tokens.
+   *
+   * @remarks This method queries the ERC-20 token contract to determine how many tokens
+   *          the deterministic adapter instance address is approved to spend on behalf
+   *          of the trader. This is useful for verifying if approval is needed before
+   *          executing a collateral swap.
+   *
+   * @param {CollateralParameters} params - Parameters including trader address, collateral
+   *                                         token address, and adapter instance address.
+   * @returns {Promise<bigint>} The current allowance amount in token's smallest unit (wei).
+   *
+   * @example
+   * ```typescript
+   * const allowance = await sdk.getCollateralAllowance({
+   *   trader: '0x...',
+   *   collateralToken: '0x...',
+   *   amount: BigInt('1000000000000000000'),
+   *   instanceAddress: '0x...',
+   * })
+   * console.log('Current allowance:', allowance.toString())
+   * ```
+   */
+  async getCollateralAllowance(params) {
+    const { collateralToken, trader, instanceAddress } = params;
+    const adapter = (0, import_sdk_common.getGlobalAdapter)();
+    return await adapter.readContract({
+      address: collateralToken,
+      abi: import_sdk_common.ERC20_ALLOWANCE_ABI,
+      functionName: "allowance",
+      args: [trader, instanceAddress]
+    });
+  }
+  /**
+   * Approves the flash loan adapter to spend collateral tokens.
+   *
+   * @remarks This method sends an on-chain approval transaction to allow the deterministic
+   *          adapter instance address to spend the specified amount of collateral tokens.
+   *          The approval is required before executing a collateral swap unless using
+   *          EIP-2612 permit or preventApproval settings.
+   *
+   * @param {CollateralParameters} params - Parameters including trader address, collateral
+   *                                         token address, amount to approve, and adapter
+   *                                         instance address.
+   * @returns {Promise<TransactionResponse>} The transaction response from the approval transaction.
+   *
+   * @throws Will throw if the approval transaction fails or is rejected.
+   *
+   * @example
+   * ```typescript
+   * const txResponse = await sdk.approveCollateral({
+   *   trader: '0x...',
+   *   collateralToken: '0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d',
+   *   amount: BigInt('20000000000000000000'),
+   *   instanceAddress: '0x...',
+   * })
+   * console.log('Approval transaction hash:', txResponse.hash)
+   * ```
+   */
+  async approveCollateral(params) {
+    const { collateralToken, amount, instanceAddress } = params;
+    const adapter = (0, import_sdk_common.getGlobalAdapter)();
+    const txParams = {
+      to: collateralToken,
+      data: adapter.utils.encodeFunction(import_sdk_common.ERC20_APPROVE_ABI, "approve", [instanceAddress, "0x" + amount.toString(16)])
+    };
+    return adapter.signer.sendTransaction(txParams);
+  }
+  async getExpectedInstanceAddress(chainId, trader, hookAmounts, order) {
+    const hookData = this.buildHookOrderData(trader, hookAmounts, order);
+    return await (0, import_sdk_common.getGlobalAdapter)().readContract({
+      address: AAVE_ADAPTER_FACTORY[chainId],
+      args: [AAVE_COLLATERAL_SWAP_ADAPTER_HOOK[chainId], hookData],
+      functionName: "getInstanceDeterministicAddress",
+      abi: aaveAdapterFactoryAbi
+    });
+  }
+  async approveCollateralIfNeeded(collateralParams, sellAmount) {
+    const allowance = await this.getCollateralAllowance(collateralParams).catch((error) => {
+      console.error("[AaveCollateralSwapSdk] Could not get allowance for collateral token", error);
+      return null;
+    });
+    if (!allowance || allowance < sellAmount) {
+      await this.approveCollateral(collateralParams);
+    }
+  }
+  calculateFlashLoanAmounts({ sellAmount, flashLoanFeePercent }) {
+    const flashLoanFeeAmount = sellAmount * BigInt(Math.round(flashLoanFeePercent * PERCENT_SCALE)) / BigInt(100 * PERCENT_SCALE);
+    return {
+      flashLoanFeeAmount,
+      sellAmountToSign: sellAmount - flashLoanFeeAmount
+    };
+  }
+  getPreHookCallData(chainId, trader, hookAmounts, order, instanceAddress) {
+    const hookData = this.buildHookOrderData(trader, hookAmounts, order);
+    const adapterImplementation = AAVE_COLLATERAL_SWAP_ADAPTER_HOOK[chainId];
+    return (0, import_sdk_common.getGlobalAdapter)().utils.encodeFunction(aaveAdapterFactoryAbi, "deployAndTransferFlashLoan", [
+      adapterImplementation,
+      { ...hookData, receiver: instanceAddress }
+    ]);
+  }
+  buildHookOrderData(trader, hookAmounts, order) {
+    const { sellToken, buyToken, sellAmount, buyAmount, kind, validTo } = order;
+    const parsedValidTo = typeof validTo === "number" ? validTo : Number(validTo ?? 0);
+    return {
+      owner: trader,
+      receiver: import_sdk_common.ZERO_ADDRESS,
+      sellToken: String(sellToken),
+      buyToken: String(buyToken),
+      sellAmount: String(sellAmount),
+      buyAmount: String(buyAmount),
+      kind: String(kind),
+      validTo: parsedValidTo,
+      flashLoanAmount: hookAmounts.flashLoanAmount,
+      flashLoanFeeAmount: hookAmounts.flashLoanFeeAmount,
+      hookSellTokenAmount: hookAmounts.sellAssetAmount,
+      hookBuyTokenAmount: hookAmounts.buyAssetAmount
+    };
+  }
+  getPostHookCallData(collateralPermit = EMPTY_PERMIT) {
+    return (0, import_sdk_common.getGlobalAdapter)().utils.encodeFunction(collateralSwapAdapterHookAbi, "collateralSwapWithFlashLoan", [
+      collateralPermit
+    ]);
+  }
+  async getOrderHooks(chainId, trader, expectedInstanceAddress, hookAmounts, order, collateralPermit) {
+    const preHookCallData = this.getPreHookCallData(chainId, trader, hookAmounts, order, expectedInstanceAddress);
+    const postHookCallData = this.getPostHookCallData(collateralPermit);
+    return {
+      pre: [
+        {
+          target: AAVE_ADAPTER_FACTORY[chainId],
+          callData: preHookCallData,
+          gasLimit: DEFAULT_HOOK_GAS_LIMIT.pre.toString()
+        }
+      ],
+      post: [
+        {
+          target: expectedInstanceAddress,
+          callData: postHookCallData,
+          gasLimit: DEFAULT_HOOK_GAS_LIMIT.post.toString()
+        }
+      ]
+    };
+  }
+  async adapterEIP1271Signature(chainId, instanceAddress, orderToSign, signer) {
+    const adapterFactoryAddress = AAVE_ADAPTER_FACTORY[chainId];
+    const encodedOrder = import_sdk_order_signing.OrderSigningUtils.encodeUnsignedOrder(orderToSign);
+    const domain = {
+      name: ADAPTER_DOMAIN_NAME,
+      version: ADAPTER_DOMAIN_VERSION,
+      chainId,
+      verifyingContract: adapterFactoryAddress
+    };
+    const message = {
+      instance: instanceAddress,
+      sellToken: encodedOrder.sellToken,
+      buyToken: encodedOrder.buyToken,
+      sellAmount: encodedOrder.sellAmount,
+      buyAmount: encodedOrder.buyAmount,
+      kind: encodedOrder.kind,
+      validTo: encodedOrder.validTo,
+      appData: encodedOrder.appData
+    };
+    const ecdsaSignature = await signer.signTypedData(domain, ADAPTER_SIGNATURE_TYPES, message);
+    return import_sdk_order_signing.OrderSigningUtils.getEip1271Signature(orderToSign, ecdsaSignature);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AAVE_ADAPTER_FACTORY,
+  AAVE_COLLATERAL_SWAP_ADAPTER_HOOK,
+  AAVE_POOL_ADDRESS,
+  ADAPTER_DOMAIN_NAME,
+  ADAPTER_DOMAIN_VERSION,
+  ADAPTER_SIGNATURE_TYPES,
+  AaveCollateralSwapSdk,
+  DEFAULT_HOOK_GAS_LIMIT,
+  DEFAULT_VALIDITY,
+  EMPTY_PERMIT,
+  GAS_ESTIMATION_ADDITION_PERCENT,
+  HASH_ZERO,
+  PERCENT_SCALE
+});