From b3ca2069c572a6e77a20ff2a4e4e9bdcaa650210 Mon Sep 17 00:00:00 2001
From: Priyam Anand <priyam27.anand@gmail.com>
Date: Tue, 25 Jun 2024 17:14:38 +0530
Subject: [PATCH 1/6] feat: added looping button

---
 .../SupplyAssetsList/SupplyAssetsListItem.tsx |  110 +
 src/ui-config/marketsConfig.tsx               |   16 +-
 src/utils/contracts/CreditDelegationToken.ts  |  362 ++
 src/utils/contracts/ERC20.ts                  |  707 +++
 src/utils/contracts/Leverage.ts               |  424 ++
 src/utils/contracts/Pool.ts                   | 4063 +++++++++++++++++
 src/utils/contracts/common.ts                 |   37 +
 7 files changed, 5713 insertions(+), 6 deletions(-)
 create mode 100644 src/utils/contracts/CreditDelegationToken.ts
 create mode 100644 src/utils/contracts/ERC20.ts
 create mode 100644 src/utils/contracts/Leverage.ts
 create mode 100644 src/utils/contracts/Pool.ts
 create mode 100644 src/utils/contracts/common.ts

diff --git a/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx b/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx
index f8954811..2339da78 100644
--- a/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx
+++ b/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx
@@ -1,5 +1,9 @@
 import { Trans } from '@lingui/macro';
 import { Button } from '@mui/material';
+import { useWeb3React } from '@web3-react/core';
+import { BigNumber, constants, Contract, providers } from 'ethers';
+import { parseEther } from 'ethers/lib/utils';
+import { useState } from 'react';
 import { useAssetCaps } from 'src/hooks/useAssetCaps';
 import { useModalContext } from 'src/hooks/useModal';
 import { useProtocolDataContext } from 'src/hooks/useProtocolDataContext';
@@ -8,6 +12,15 @@ import { DashboardReserve } from 'src/utils/dashboardSortUtils';
 import { CapsHint } from '../../../../components/caps/CapsHint';
 import { CapType } from '../../../../components/caps/helper';
 import { Link, ROUTES } from '../../../../components/primitives/Link';
+import { useAppDataContext } from '../../../../hooks/app-data-provider/useAppDataProvider';
+import { useWeb3Context } from '../../../../libs/hooks/useWeb3Context';
+import { marketsData } from '../../../../ui-config/marketsConfig';
+import {
+  CreditDelegationTokenABI,
+  ICreditDelegationToken,
+} from '../../../../utils/contracts/CreditDelegationToken';
+import { Leverage, LeverageABI } from '../../../../utils/contracts/Leverage';
+import { availableMarkets } from '../../../../utils/marketsAndNetworksConfig';
 import { SpkAirdropNoteInline } from '../BorrowAssetsList/BorrowAssetsListItem';
 import { ListAPRColumn } from '../ListAPRColumn';
 import { ListButtonsColumn } from '../ListButtonsColumn';
@@ -31,13 +44,94 @@ export const SupplyAssetsListItem = ({
   showSwap,
   hideSupply,
 }: DashboardReserve) => {
+  const { reserves } = useAppDataContext();
+  const { library: provider } = useWeb3React<providers.Web3Provider>();
+  const { currentAccount } = useWeb3Context();
   const { currentMarket } = useProtocolDataContext();
   const { openSupply, openPSMSwap } = useModalContext();
+  const [isLooping, setIsLooping] = useState(false);
 
   // Hide the asset to prevent it from being supplied if supply cap has been reached
   const { supplyCap: supplyCapUsage } = useAssetCaps();
   if (supplyCapUsage.isMaxed) return null;
 
+  const doLoopingAction = async () => {
+    try {
+      setIsLooping(true);
+      const currentMarketData = marketsData[availableMarkets[0]];
+      const signer = provider?.getSigner(currentAccount);
+      const interestRateMode = 2;
+      const leverageInstance = new Contract(
+        currentMarketData.addresses.LEVERAGE!,
+        LeverageABI,
+        signer
+      ) as Leverage;
+      // looping
+      const debtTokenAddress = reserves.filter(
+        (item) =>
+          item.underlyingAsset.toLowerCase() ===
+          currentMarketData.addresses.WRAPPED_TOKEN?.toLowerCase()
+      )[0].variableDebtTokenAddress;
+      const debtTokenInstance = new Contract(
+        debtTokenAddress,
+        CreditDelegationTokenABI,
+        signer
+      ) as ICreditDelegationToken;
+
+      const delegationAmount = await debtTokenInstance.borrowAllowance(
+        currentAccount,
+        currentMarketData.addresses.LEVERAGE!
+      );
+      console.log('delegation amount ', delegationAmount, delegationAmount.toString());
+      if (delegationAmount.eq(BigNumber.from('0'))) {
+        const txn = await debtTokenInstance.approveDelegation(
+          currentMarketData.addresses.LEVERAGE!,
+          constants.MaxUint256.toString()
+        );
+        await txn.wait(1);
+        console.log(txn);
+      }
+
+      const loopCount = 5;
+      const borrowRatio = 8000; // 80%
+
+      const loopingTxn = await leverageInstance.loop(loopCount, borrowRatio, interestRateMode, 0, {
+        value: parseEther('1'),
+      });
+
+      await loopingTxn.wait(1);
+      console.log(loopingTxn);
+
+      // unlooping
+      // const aTokenAddress = reserves.filter((item) => item.symbol === 'wstXTZ')[0].aTokenAddress;
+      // const aTokenInstance = new Contract(aTokenAddress, ERC20ABI, signer) as ERC20;
+
+      // const approvalAmt = await aTokenInstance.allowance(
+      //   currentAccount,
+      //   currentMarketData.addresses.LEVERAGE!
+      // );
+      // if (approvalAmt.eq(BigNumber.from('0'))) {
+      //   const aTokenTx = await aTokenInstance.approve(
+      //     currentMarketData.addresses.LEVERAGE!,
+      //     constants.MaxUint256.toString()
+      //   );
+      //   await aTokenTx.wait(2);
+      //   console.log(aTokenTx);
+      // }
+
+      // const unloop = await leverageInstance.unLoop(
+      //   BigNumber.from(parseEther('1')),
+      //   currentAccount,
+      //   interestRateMode
+      // );
+      // await unloop.wait(1);
+      // console.log(unloop);
+    } catch (error) {
+      console.error('Error in doing the looping action', error);
+    }
+    setIsLooping(false);
+  };
+
   return (
     <ListItemWrapper
       symbol={symbol}
@@ -85,6 +179,22 @@ export const SupplyAssetsListItem = ({
             <Trans>Deposit</Trans>
           </Button>
         )}
+        {!hideSupply && symbol === 'XTZ' && (
+          <Button
+            sx={(theme) => ({
+              color: theme.palette.common.white,
+              background: '#4caf50',
+              '&:hover, &.Mui-focusVisible': {
+                background: '#8bc34a',
+              },
+            })}
+            disabled={!isActive || isFreezed || Number(walletBalance) <= 0 || isLooping}
+            variant="contained"
+            onClick={() => doLoopingAction()}
+          >
+            <Trans>Loop</Trans>
+          </Button>
+        )}
         {showSwap && (
           <Button variant="contained" onClick={() => openPSMSwap(underlyingAsset)}>
             <Trans>Swap</Trans>
diff --git a/src/ui-config/marketsConfig.tsx b/src/ui-config/marketsConfig.tsx
index e8fb4653..c16a707c 100644
--- a/src/ui-config/marketsConfig.tsx
+++ b/src/ui-config/marketsConfig.tsx
@@ -38,6 +38,8 @@ export type MarketDataType = {
     CHAINLOG?: string;
     SAVINGS_DAI?: string;
     V3_MIGRATOR?: string;
+    LEVERAGE?: string;
+    WRAPPED_TOKEN?: string;
   };
   faucetUrl: string;
   /**
@@ -68,12 +70,14 @@ export const marketsData: {
       faucet: false,
     },
     addresses: {
-      LENDING_POOL_ADDRESS_PROVIDER: '0x5e580E0FF1981E7c916D6D9a036A8596E35fCE31'.toLowerCase(),
-      LENDING_POOL: '0x837286C1d05735448F7d1942144eE98602206773',
-      WALLET_BALANCE_PROVIDER: '0xAE0f454b171dA3C0e3B8a75c92A449964f90f7fd',
-      UI_POOL_DATA_PROVIDER: '0xA69C04756c604b63514cBF13466eCE70a5BF755b',
-      UI_INCENTIVE_DATA_PROVIDER: '0xdfe6cC78B0A1ed393246B9151c83036AD3e165b8',
-      WETH_GATEWAY: '0x2ae2308F17667980582c6580556317EBdb61cc68',
+      LENDING_POOL_ADDRESS_PROVIDER: '0x8780b9f46123A151f8325E0bEE5e8B977DEFf1FA'.toLowerCase(),
+      LENDING_POOL: '0xB3a5e66cF7Fd00C14E6DC9f57E4200BDd4d5ba8b',
+      WALLET_BALANCE_PROVIDER: '0xaD66495fBb102Bb5420326C20F92592a1bddf0d9',
+      UI_POOL_DATA_PROVIDER: '0x6A71659daBd47de688d5bD7eb18F7F599900c9a3',
+      UI_INCENTIVE_DATA_PROVIDER: '0x65374686E598ae4AA22E2E4780436C029EEc6E3b',
+      WETH_GATEWAY: '0xD9bf48dde1b08A6e13AA1b6F9E5Ac943898021E3',
+      LEVERAGE: '0x00398eB80CD3090fbCfad86B162d875Ac2AC5035',
+      WRAPPED_TOKEN: '0xc2ef9495272b43f5257b35a1b6dda78932839871',
     },
     faucetUrl: 'https://faucet.plend.finance/receiveFaucetTokens',
   },
diff --git a/src/utils/contracts/CreditDelegationToken.ts b/src/utils/contracts/CreditDelegationToken.ts
new file mode 100644
index 00000000..47b2cee1
--- /dev/null
+++ b/src/utils/contracts/CreditDelegationToken.ts
@@ -0,0 +1,362 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from 'ethers';
+import type { FunctionFragment, Result, EventFragment } from '@ethersproject/abi';
+import type { Listener, Provider } from '@ethersproject/providers';
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from './common';
+
+export interface ICreditDelegationTokenInterface extends utils.Interface {
+  functions: {
+    'approveDelegation(address,uint256)': FunctionFragment;
+    'borrowAllowance(address,address)': FunctionFragment;
+    'delegationWithSig(address,address,uint256,uint256,uint8,bytes32,bytes32)': FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic: 'approveDelegation' | 'borrowAllowance' | 'delegationWithSig'
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: 'approveDelegation',
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'borrowAllowance',
+    values: [PromiseOrValue<string>, PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'delegationWithSig',
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BytesLike>,
+      PromiseOrValue<BytesLike>
+    ]
+  ): string;
+
+  decodeFunctionResult(functionFragment: 'approveDelegation', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'borrowAllowance', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'delegationWithSig', data: BytesLike): Result;
+
+  events: {
+    'BorrowAllowanceDelegated(address,address,address,uint256)': EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: 'BorrowAllowanceDelegated'): EventFragment;
+}
+
+export interface BorrowAllowanceDelegatedEventObject {
+  fromUser: string;
+  toUser: string;
+  asset: string;
+  amount: BigNumber;
+}
+export type BorrowAllowanceDelegatedEvent = TypedEvent<
+  [string, string, string, BigNumber],
+  BorrowAllowanceDelegatedEventObject
+>;
+
+export type BorrowAllowanceDelegatedEventFilter = TypedEventFilter<BorrowAllowanceDelegatedEvent>;
+
+export interface ICreditDelegationToken extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: ICreditDelegationTokenInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    approveDelegation(
+      delegatee: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    borrowAllowance(
+      fromUser: PromiseOrValue<string>,
+      toUser: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    delegationWithSig(
+      delegator: PromiseOrValue<string>,
+      delegatee: PromiseOrValue<string>,
+      value: PromiseOrValue<BigNumberish>,
+      deadline: PromiseOrValue<BigNumberish>,
+      v: PromiseOrValue<BigNumberish>,
+      r: PromiseOrValue<BytesLike>,
+      s: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  approveDelegation(
+    delegatee: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  borrowAllowance(
+    fromUser: PromiseOrValue<string>,
+    toUser: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  delegationWithSig(
+    delegator: PromiseOrValue<string>,
+    delegatee: PromiseOrValue<string>,
+    value: PromiseOrValue<BigNumberish>,
+    deadline: PromiseOrValue<BigNumberish>,
+    v: PromiseOrValue<BigNumberish>,
+    r: PromiseOrValue<BytesLike>,
+    s: PromiseOrValue<BytesLike>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    approveDelegation(
+      delegatee: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    borrowAllowance(
+      fromUser: PromiseOrValue<string>,
+      toUser: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    delegationWithSig(
+      delegator: PromiseOrValue<string>,
+      delegatee: PromiseOrValue<string>,
+      value: PromiseOrValue<BigNumberish>,
+      deadline: PromiseOrValue<BigNumberish>,
+      v: PromiseOrValue<BigNumberish>,
+      r: PromiseOrValue<BytesLike>,
+      s: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {
+    'BorrowAllowanceDelegated(address,address,address,uint256)'(
+      fromUser?: PromiseOrValue<string> | null,
+      toUser?: PromiseOrValue<string> | null,
+      asset?: PromiseOrValue<string> | null,
+      amount?: null
+    ): BorrowAllowanceDelegatedEventFilter;
+    BorrowAllowanceDelegated(
+      fromUser?: PromiseOrValue<string> | null,
+      toUser?: PromiseOrValue<string> | null,
+      asset?: PromiseOrValue<string> | null,
+      amount?: null
+    ): BorrowAllowanceDelegatedEventFilter;
+  };
+
+  estimateGas: {
+    approveDelegation(
+      delegatee: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    borrowAllowance(
+      fromUser: PromiseOrValue<string>,
+      toUser: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    delegationWithSig(
+      delegator: PromiseOrValue<string>,
+      delegatee: PromiseOrValue<string>,
+      value: PromiseOrValue<BigNumberish>,
+      deadline: PromiseOrValue<BigNumberish>,
+      v: PromiseOrValue<BigNumberish>,
+      r: PromiseOrValue<BytesLike>,
+      s: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    approveDelegation(
+      delegatee: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    borrowAllowance(
+      fromUser: PromiseOrValue<string>,
+      toUser: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    delegationWithSig(
+      delegator: PromiseOrValue<string>,
+      delegatee: PromiseOrValue<string>,
+      value: PromiseOrValue<BigNumberish>,
+      deadline: PromiseOrValue<BigNumberish>,
+      v: PromiseOrValue<BigNumberish>,
+      r: PromiseOrValue<BytesLike>,
+      s: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}
+
+export const CreditDelegationTokenABI = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'fromUser',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'toUser',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+    ],
+    name: 'BorrowAllowanceDelegated',
+    type: 'event',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'delegatee',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+    ],
+    name: 'approveDelegation',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'fromUser',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'toUser',
+        type: 'address',
+      },
+    ],
+    name: 'borrowAllowance',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'delegator',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'delegatee',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'value',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'deadline',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint8',
+        name: 'v',
+        type: 'uint8',
+      },
+      {
+        internalType: 'bytes32',
+        name: 'r',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bytes32',
+        name: 's',
+        type: 'bytes32',
+      },
+    ],
+    name: 'delegationWithSig',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+];
diff --git a/src/utils/contracts/ERC20.ts b/src/utils/contracts/ERC20.ts
new file mode 100644
index 00000000..e3ddd21d
--- /dev/null
+++ b/src/utils/contracts/ERC20.ts
@@ -0,0 +1,707 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from 'ethers';
+import type { FunctionFragment, Result, EventFragment } from '@ethersproject/abi';
+import type { Listener, Provider } from '@ethersproject/providers';
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from './common';
+
+export interface ERC20Interface extends utils.Interface {
+  functions: {
+    'allowance(address,address)': FunctionFragment;
+    'approve(address,uint256)': FunctionFragment;
+    'balanceOf(address)': FunctionFragment;
+    'decimals()': FunctionFragment;
+    'decreaseAllowance(address,uint256)': FunctionFragment;
+    'increaseAllowance(address,uint256)': FunctionFragment;
+    'name()': FunctionFragment;
+    'symbol()': FunctionFragment;
+    'totalSupply()': FunctionFragment;
+    'transfer(address,uint256)': FunctionFragment;
+    'transferFrom(address,address,uint256)': FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | 'allowance'
+      | 'approve'
+      | 'balanceOf'
+      | 'decimals'
+      | 'decreaseAllowance'
+      | 'increaseAllowance'
+      | 'name'
+      | 'symbol'
+      | 'totalSupply'
+      | 'transfer'
+      | 'transferFrom'
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: 'allowance',
+    values: [PromiseOrValue<string>, PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'approve',
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(functionFragment: 'balanceOf', values: [PromiseOrValue<string>]): string;
+  encodeFunctionData(functionFragment: 'decimals', values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: 'decreaseAllowance',
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'increaseAllowance',
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(functionFragment: 'name', values?: undefined): string;
+  encodeFunctionData(functionFragment: 'symbol', values?: undefined): string;
+  encodeFunctionData(functionFragment: 'totalSupply', values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: 'transfer',
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'transferFrom',
+    values: [PromiseOrValue<string>, PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(functionFragment: 'allowance', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'approve', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'balanceOf', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'decimals', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'decreaseAllowance', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'increaseAllowance', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'name', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'symbol', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'totalSupply', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'transfer', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'transferFrom', data: BytesLike): Result;
+
+  events: {
+    'Approval(address,address,uint256)': EventFragment;
+    'Transfer(address,address,uint256)': EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: 'Approval'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'Transfer'): EventFragment;
+}
+
+export interface ApprovalEventObject {
+  owner: string;
+  spender: string;
+  value: BigNumber;
+}
+export type ApprovalEvent = TypedEvent<[string, string, BigNumber], ApprovalEventObject>;
+
+export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;
+
+export interface TransferEventObject {
+  from: string;
+  to: string;
+  value: BigNumber;
+}
+export type TransferEvent = TypedEvent<[string, string, BigNumber], TransferEventObject>;
+
+export type TransferEventFilter = TypedEventFilter<TransferEvent>;
+
+export interface ERC20 extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: ERC20Interface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    decimals(overrides?: CallOverrides): Promise<[number]>;
+
+    decreaseAllowance(
+      spender: PromiseOrValue<string>,
+      subtractedValue: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    increaseAllowance(
+      spender: PromiseOrValue<string>,
+      addedValue: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    name(overrides?: CallOverrides): Promise<[string]>;
+
+    symbol(overrides?: CallOverrides): Promise<[string]>;
+
+    totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    transfer(
+      recipient: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    transferFrom(
+      sender: PromiseOrValue<string>,
+      recipient: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  allowance(
+    owner: PromiseOrValue<string>,
+    spender: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  approve(
+    spender: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+
+  decimals(overrides?: CallOverrides): Promise<number>;
+
+  decreaseAllowance(
+    spender: PromiseOrValue<string>,
+    subtractedValue: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  increaseAllowance(
+    spender: PromiseOrValue<string>,
+    addedValue: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  name(overrides?: CallOverrides): Promise<string>;
+
+  symbol(overrides?: CallOverrides): Promise<string>;
+
+  totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+  transfer(
+    recipient: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  transferFrom(
+    sender: PromiseOrValue<string>,
+    recipient: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+
+    decimals(overrides?: CallOverrides): Promise<number>;
+
+    decreaseAllowance(
+      spender: PromiseOrValue<string>,
+      subtractedValue: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    increaseAllowance(
+      spender: PromiseOrValue<string>,
+      addedValue: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    name(overrides?: CallOverrides): Promise<string>;
+
+    symbol(overrides?: CallOverrides): Promise<string>;
+
+    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+    transfer(
+      recipient: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    transferFrom(
+      sender: PromiseOrValue<string>,
+      recipient: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+  };
+
+  filters: {
+    'Approval(address,address,uint256)'(
+      owner?: PromiseOrValue<string> | null,
+      spender?: PromiseOrValue<string> | null,
+      value?: null
+    ): ApprovalEventFilter;
+    Approval(
+      owner?: PromiseOrValue<string> | null,
+      spender?: PromiseOrValue<string> | null,
+      value?: null
+    ): ApprovalEventFilter;
+
+    'Transfer(address,address,uint256)'(
+      from?: PromiseOrValue<string> | null,
+      to?: PromiseOrValue<string> | null,
+      value?: null
+    ): TransferEventFilter;
+    Transfer(
+      from?: PromiseOrValue<string> | null,
+      to?: PromiseOrValue<string> | null,
+      value?: null
+    ): TransferEventFilter;
+  };
+
+  estimateGas: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+
+    decimals(overrides?: CallOverrides): Promise<BigNumber>;
+
+    decreaseAllowance(
+      spender: PromiseOrValue<string>,
+      subtractedValue: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    increaseAllowance(
+      spender: PromiseOrValue<string>,
+      addedValue: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    name(overrides?: CallOverrides): Promise<BigNumber>;
+
+    symbol(overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+    transfer(
+      recipient: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    transferFrom(
+      sender: PromiseOrValue<string>,
+      recipient: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    balanceOf(
+      account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    decreaseAllowance(
+      spender: PromiseOrValue<string>,
+      subtractedValue: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    increaseAllowance(
+      spender: PromiseOrValue<string>,
+      addedValue: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    symbol(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    transfer(
+      recipient: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    transferFrom(
+      sender: PromiseOrValue<string>,
+      recipient: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}
+
+export const ERC20ABI = [
+  {
+    inputs: [
+      {
+        internalType: 'string',
+        name: 'name',
+        type: 'string',
+      },
+      {
+        internalType: 'string',
+        name: 'symbol',
+        type: 'string',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'constructor',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'spender',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'value',
+        type: 'uint256',
+      },
+    ],
+    name: 'Approval',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'from',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'to',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'value',
+        type: 'uint256',
+      },
+    ],
+    name: 'Transfer',
+    type: 'event',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'spender',
+        type: 'address',
+      },
+    ],
+    name: 'allowance',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'spender',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+    ],
+    name: 'approve',
+    outputs: [
+      {
+        internalType: 'bool',
+        name: '',
+        type: 'bool',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'account',
+        type: 'address',
+      },
+    ],
+    name: 'balanceOf',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'decimals',
+    outputs: [
+      {
+        internalType: 'uint8',
+        name: '',
+        type: 'uint8',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'spender',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'subtractedValue',
+        type: 'uint256',
+      },
+    ],
+    name: 'decreaseAllowance',
+    outputs: [
+      {
+        internalType: 'bool',
+        name: '',
+        type: 'bool',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'spender',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'addedValue',
+        type: 'uint256',
+      },
+    ],
+    name: 'increaseAllowance',
+    outputs: [
+      {
+        internalType: 'bool',
+        name: '',
+        type: 'bool',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'name',
+    outputs: [
+      {
+        internalType: 'string',
+        name: '',
+        type: 'string',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'symbol',
+    outputs: [
+      {
+        internalType: 'string',
+        name: '',
+        type: 'string',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'totalSupply',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'recipient',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+    ],
+    name: 'transfer',
+    outputs: [
+      {
+        internalType: 'bool',
+        name: '',
+        type: 'bool',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'sender',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'recipient',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+    ],
+    name: 'transferFrom',
+    outputs: [
+      {
+        internalType: 'bool',
+        name: '',
+        type: 'bool',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+];
diff --git a/src/utils/contracts/Leverage.ts b/src/utils/contracts/Leverage.ts
new file mode 100644
index 00000000..f9152d78
--- /dev/null
+++ b/src/utils/contracts/Leverage.ts
@@ -0,0 +1,424 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PayableOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from 'ethers';
+import type { FunctionFragment, Result } from '@ethersproject/abi';
+import type { Listener, Provider } from '@ethersproject/providers';
+import type { Event, EventFilter } from 'ethers';
+
+export interface TypedEvent<TArgsArray extends Array<any> = any, TArgsObject = any> extends Event {
+  args: TArgsArray & TArgsObject;
+}
+
+export interface TypedEventFilter<_TEvent extends TypedEvent> extends EventFilter {}
+
+export interface TypedListener<TEvent extends TypedEvent> {
+  (...listenerArg: [...__TypechainArgsArray<TEvent>, TEvent]): void;
+}
+
+type __TypechainArgsArray<T> = T extends TypedEvent<infer U> ? U : never;
+
+export interface OnEvent<TRes> {
+  <TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>,
+    listener: TypedListener<TEvent>
+  ): TRes;
+  (eventName: string, listener: Listener): TRes;
+}
+
+export type MinEthersFactory<C, ARGS> = {
+  deploy(...a: ARGS[]): Promise<C>;
+};
+
+export type GetContractTypeFromFactory<F> = F extends MinEthersFactory<infer C, any> ? C : never;
+
+export type GetARGsTypeFromFactory<F> = F extends MinEthersFactory<any, any>
+  ? Parameters<F['deploy']>
+  : never;
+
+export type PromiseOrValue<T> = T | Promise<T>;
+
+export interface LeverageInterface extends utils.Interface {
+  functions: {
+    'BASE_CURRENCY_DECIMALS()': FunctionFragment;
+    'POOL()': FunctionFragment;
+    'RATIO_DIVISOR()': FunctionFragment;
+    'STAKED_TOKEN()': FunctionFragment;
+    'WRAPPED_STAKED_TOKEN()': FunctionFragment;
+    'WRAPPED_TOKEN()': FunctionFragment;
+    'WRAPPED_TOKEN_GATEWAY()': FunctionFragment;
+    'loop(uint256,uint256,uint256,uint16)': FunctionFragment;
+    'unLoop(uint256,address,uint256)': FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | 'BASE_CURRENCY_DECIMALS'
+      | 'POOL'
+      | 'RATIO_DIVISOR'
+      | 'STAKED_TOKEN'
+      | 'WRAPPED_STAKED_TOKEN'
+      | 'WRAPPED_TOKEN'
+      | 'WRAPPED_TOKEN_GATEWAY'
+      | 'loop'
+      | 'unLoop'
+  ): FunctionFragment;
+
+  encodeFunctionData(functionFragment: 'BASE_CURRENCY_DECIMALS', values?: undefined): string;
+  encodeFunctionData(functionFragment: 'POOL', values?: undefined): string;
+  encodeFunctionData(functionFragment: 'RATIO_DIVISOR', values?: undefined): string;
+  encodeFunctionData(functionFragment: 'STAKED_TOKEN', values?: undefined): string;
+  encodeFunctionData(functionFragment: 'WRAPPED_STAKED_TOKEN', values?: undefined): string;
+  encodeFunctionData(functionFragment: 'WRAPPED_TOKEN', values?: undefined): string;
+  encodeFunctionData(functionFragment: 'WRAPPED_TOKEN_GATEWAY', values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: 'loop',
+    values: [
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'unLoop',
+    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(functionFragment: 'BASE_CURRENCY_DECIMALS', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'POOL', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'RATIO_DIVISOR', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'STAKED_TOKEN', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'WRAPPED_STAKED_TOKEN', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'WRAPPED_TOKEN', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'WRAPPED_TOKEN_GATEWAY', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'loop', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'unLoop', data: BytesLike): Result;
+
+  events: {};
+}
+
+export interface Leverage extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: LeverageInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    BASE_CURRENCY_DECIMALS(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    POOL(overrides?: CallOverrides): Promise<[string]>;
+
+    RATIO_DIVISOR(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    STAKED_TOKEN(overrides?: CallOverrides): Promise<[string]>;
+
+    WRAPPED_STAKED_TOKEN(overrides?: CallOverrides): Promise<[string]>;
+
+    WRAPPED_TOKEN(overrides?: CallOverrides): Promise<[string]>;
+
+    WRAPPED_TOKEN_GATEWAY(overrides?: CallOverrides): Promise<[string]>;
+
+    loop(
+      loops: PromiseOrValue<BigNumberish>,
+      borrowRatio: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    unLoop(
+      amountToUnloop: PromiseOrValue<BigNumberish>,
+      to: PromiseOrValue<string>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  BASE_CURRENCY_DECIMALS(overrides?: CallOverrides): Promise<BigNumber>;
+
+  POOL(overrides?: CallOverrides): Promise<string>;
+
+  RATIO_DIVISOR(overrides?: CallOverrides): Promise<BigNumber>;
+
+  STAKED_TOKEN(overrides?: CallOverrides): Promise<string>;
+
+  WRAPPED_STAKED_TOKEN(overrides?: CallOverrides): Promise<string>;
+
+  WRAPPED_TOKEN(overrides?: CallOverrides): Promise<string>;
+
+  WRAPPED_TOKEN_GATEWAY(overrides?: CallOverrides): Promise<string>;
+
+  loop(
+    loops: PromiseOrValue<BigNumberish>,
+    borrowRatio: PromiseOrValue<BigNumberish>,
+    interestRateMode: PromiseOrValue<BigNumberish>,
+    referralCode: PromiseOrValue<BigNumberish>,
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  unLoop(
+    amountToUnloop: PromiseOrValue<BigNumberish>,
+    to: PromiseOrValue<string>,
+    interestRateMode: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    BASE_CURRENCY_DECIMALS(overrides?: CallOverrides): Promise<BigNumber>;
+
+    POOL(overrides?: CallOverrides): Promise<string>;
+
+    RATIO_DIVISOR(overrides?: CallOverrides): Promise<BigNumber>;
+
+    STAKED_TOKEN(overrides?: CallOverrides): Promise<string>;
+
+    WRAPPED_STAKED_TOKEN(overrides?: CallOverrides): Promise<string>;
+
+    WRAPPED_TOKEN(overrides?: CallOverrides): Promise<string>;
+
+    WRAPPED_TOKEN_GATEWAY(overrides?: CallOverrides): Promise<string>;
+
+    loop(
+      loops: PromiseOrValue<BigNumberish>,
+      borrowRatio: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    unLoop(
+      amountToUnloop: PromiseOrValue<BigNumberish>,
+      to: PromiseOrValue<string>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    BASE_CURRENCY_DECIMALS(overrides?: CallOverrides): Promise<BigNumber>;
+
+    POOL(overrides?: CallOverrides): Promise<BigNumber>;
+
+    RATIO_DIVISOR(overrides?: CallOverrides): Promise<BigNumber>;
+
+    STAKED_TOKEN(overrides?: CallOverrides): Promise<BigNumber>;
+
+    WRAPPED_STAKED_TOKEN(overrides?: CallOverrides): Promise<BigNumber>;
+
+    WRAPPED_TOKEN(overrides?: CallOverrides): Promise<BigNumber>;
+
+    WRAPPED_TOKEN_GATEWAY(overrides?: CallOverrides): Promise<BigNumber>;
+
+    loop(
+      loops: PromiseOrValue<BigNumberish>,
+      borrowRatio: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    unLoop(
+      amountToUnloop: PromiseOrValue<BigNumberish>,
+      to: PromiseOrValue<string>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    BASE_CURRENCY_DECIMALS(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    POOL(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    RATIO_DIVISOR(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    STAKED_TOKEN(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    WRAPPED_STAKED_TOKEN(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    WRAPPED_TOKEN(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    WRAPPED_TOKEN_GATEWAY(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    loop(
+      loops: PromiseOrValue<BigNumberish>,
+      borrowRatio: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    unLoop(
+      amountToUnloop: PromiseOrValue<BigNumberish>,
+      to: PromiseOrValue<string>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}
+
+export const LeverageABI = [
+  {
+    type: 'constructor',
+    inputs: [
+      {
+        name: '_stakedToken',
+        type: 'address',
+        internalType: 'address',
+      },
+      {
+        name: '_wrappedStakedToken',
+        type: 'address',
+        internalType: 'address',
+      },
+      { name: '_pool', type: 'address', internalType: 'address' },
+      {
+        name: '_wrappedToken',
+        type: 'address',
+        internalType: 'address',
+      },
+      {
+        name: '_wrappedTokenGateway',
+        type: 'address',
+        internalType: 'address',
+      },
+    ],
+    stateMutability: 'nonpayable',
+  },
+  { type: 'receive', stateMutability: 'payable' },
+  {
+    type: 'function',
+    name: 'BASE_CURRENCY_DECIMALS',
+    inputs: [],
+    outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    name: 'POOL',
+    inputs: [],
+    outputs: [{ name: '', type: 'address', internalType: 'contract IPool' }],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    name: 'RATIO_DIVISOR',
+    inputs: [],
+    outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    name: 'STAKED_TOKEN',
+    inputs: [],
+    outputs: [
+      {
+        name: '',
+        type: 'address',
+        internalType: 'contract IEtherfiETH',
+      },
+    ],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    name: 'WRAPPED_STAKED_TOKEN',
+    inputs: [],
+    outputs: [
+      {
+        name: '',
+        type: 'address',
+        internalType: 'contract IWrappedEtherfiETH',
+      },
+    ],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    name: 'WRAPPED_TOKEN',
+    inputs: [],
+    outputs: [{ name: '', type: 'address', internalType: 'contract WETH9' }],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    name: 'WRAPPED_TOKEN_GATEWAY',
+    inputs: [],
+    outputs: [
+      {
+        name: '',
+        type: 'address',
+        internalType: 'contract IWrappedTokenGatewayV3',
+      },
+    ],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    name: 'loop',
+    inputs: [
+      { name: 'loops', type: 'uint256', internalType: 'uint256' },
+      { name: 'borrowRatio', type: 'uint256', internalType: 'uint256' },
+      {
+        name: 'interestRateMode',
+        type: 'uint256',
+        internalType: 'uint256',
+      },
+      { name: 'referralCode', type: 'uint16', internalType: 'uint16' },
+    ],
+    outputs: [],
+    stateMutability: 'payable',
+  },
+  {
+    type: 'function',
+    name: 'unLoop',
+    inputs: [
+      {
+        name: 'amountToUnloop',
+        type: 'uint256',
+        internalType: 'uint256',
+      },
+      { name: 'to', type: 'address', internalType: 'address' },
+      {
+        name: 'interestRateMode',
+        type: 'uint256',
+        internalType: 'uint256',
+      },
+    ],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+];
diff --git a/src/utils/contracts/Pool.ts b/src/utils/contracts/Pool.ts
new file mode 100644
index 00000000..6f3acdf5
--- /dev/null
+++ b/src/utils/contracts/Pool.ts
@@ -0,0 +1,4063 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from 'ethers';
+import type { FunctionFragment, Result, EventFragment } from '@ethersproject/abi';
+import type { Listener, Provider } from '@ethersproject/providers';
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from './common';
+
+export declare namespace DataTypes {
+  export type EModeCategoryStruct = {
+    ltv: PromiseOrValue<BigNumberish>;
+    liquidationThreshold: PromiseOrValue<BigNumberish>;
+    liquidationBonus: PromiseOrValue<BigNumberish>;
+    priceSource: PromiseOrValue<string>;
+    label: PromiseOrValue<string>;
+  };
+
+  export type EModeCategoryStructOutput = [number, number, number, string, string] & {
+    ltv: number;
+    liquidationThreshold: number;
+    liquidationBonus: number;
+    priceSource: string;
+    label: string;
+  };
+
+  export type ReserveConfigurationMapStruct = {
+    data: PromiseOrValue<BigNumberish>;
+  };
+
+  export type ReserveConfigurationMapStructOutput = [BigNumber] & {
+    data: BigNumber;
+  };
+
+  export type ReserveDataStruct = {
+    configuration: DataTypes.ReserveConfigurationMapStruct;
+    liquidityIndex: PromiseOrValue<BigNumberish>;
+    currentLiquidityRate: PromiseOrValue<BigNumberish>;
+    variableBorrowIndex: PromiseOrValue<BigNumberish>;
+    currentVariableBorrowRate: PromiseOrValue<BigNumberish>;
+    currentStableBorrowRate: PromiseOrValue<BigNumberish>;
+    lastUpdateTimestamp: PromiseOrValue<BigNumberish>;
+    id: PromiseOrValue<BigNumberish>;
+    aTokenAddress: PromiseOrValue<string>;
+    stableDebtTokenAddress: PromiseOrValue<string>;
+    variableDebtTokenAddress: PromiseOrValue<string>;
+    interestRateStrategyAddress: PromiseOrValue<string>;
+    accruedToTreasury: PromiseOrValue<BigNumberish>;
+    unbacked: PromiseOrValue<BigNumberish>;
+    isolationModeTotalDebt: PromiseOrValue<BigNumberish>;
+  };
+
+  export type ReserveDataStructOutput = [
+    DataTypes.ReserveConfigurationMapStructOutput,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    number,
+    number,
+    string,
+    string,
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber
+  ] & {
+    configuration: DataTypes.ReserveConfigurationMapStructOutput;
+    liquidityIndex: BigNumber;
+    currentLiquidityRate: BigNumber;
+    variableBorrowIndex: BigNumber;
+    currentVariableBorrowRate: BigNumber;
+    currentStableBorrowRate: BigNumber;
+    lastUpdateTimestamp: number;
+    id: number;
+    aTokenAddress: string;
+    stableDebtTokenAddress: string;
+    variableDebtTokenAddress: string;
+    interestRateStrategyAddress: string;
+    accruedToTreasury: BigNumber;
+    unbacked: BigNumber;
+    isolationModeTotalDebt: BigNumber;
+  };
+
+  export type UserConfigurationMapStruct = {
+    data: PromiseOrValue<BigNumberish>;
+  };
+
+  export type UserConfigurationMapStructOutput = [BigNumber] & {
+    data: BigNumber;
+  };
+}
+
+export interface PoolInterface extends utils.Interface {
+  functions: {
+    'ADDRESSES_PROVIDER()': FunctionFragment;
+    'BRIDGE_PROTOCOL_FEE()': FunctionFragment;
+    'FLASHLOAN_PREMIUM_TOTAL()': FunctionFragment;
+    'FLASHLOAN_PREMIUM_TO_PROTOCOL()': FunctionFragment;
+    'MAX_NUMBER_RESERVES()': FunctionFragment;
+    'MAX_STABLE_RATE_BORROW_SIZE_PERCENT()': FunctionFragment;
+    'POOL_REVISION()': FunctionFragment;
+    'backUnbacked(address,uint256,uint256)': FunctionFragment;
+    'borrow(address,uint256,uint256,uint16,address)': FunctionFragment;
+    'configureEModeCategory(uint8,(uint16,uint16,uint16,address,string))': FunctionFragment;
+    'deposit(address,uint256,address,uint16)': FunctionFragment;
+    'dropReserve(address)': FunctionFragment;
+    'finalizeTransfer(address,address,address,uint256,uint256,uint256)': FunctionFragment;
+    'flashLoan(address,address[],uint256[],uint256[],address,bytes,uint16)': FunctionFragment;
+    'flashLoanSimple(address,address,uint256,bytes,uint16)': FunctionFragment;
+    'getConfiguration(address)': FunctionFragment;
+    'getEModeCategoryData(uint8)': FunctionFragment;
+    'getReserveAddressById(uint16)': FunctionFragment;
+    'getReserveData(address)': FunctionFragment;
+    'getReserveNormalizedIncome(address)': FunctionFragment;
+    'getReserveNormalizedVariableDebt(address)': FunctionFragment;
+    'getReservesList()': FunctionFragment;
+    'getUserAccountData(address)': FunctionFragment;
+    'getUserConfiguration(address)': FunctionFragment;
+    'getUserEMode(address)': FunctionFragment;
+    'initReserve(address,address,address,address,address)': FunctionFragment;
+    'initialize(address)': FunctionFragment;
+    'liquidationCall(address,address,address,uint256,bool)': FunctionFragment;
+    'mintToTreasury(address[])': FunctionFragment;
+    'mintUnbacked(address,uint256,address,uint16)': FunctionFragment;
+    'rebalanceStableBorrowRate(address,address)': FunctionFragment;
+    'repay(address,uint256,uint256,address)': FunctionFragment;
+    'repayWithATokens(address,uint256,uint256)': FunctionFragment;
+    'repayWithPermit(address,uint256,uint256,address,uint256,uint8,bytes32,bytes32)': FunctionFragment;
+    'rescueTokens(address,address,uint256)': FunctionFragment;
+    'resetIsolationModeTotalDebt(address)': FunctionFragment;
+    'setConfiguration(address,(uint256))': FunctionFragment;
+    'setReserveInterestRateStrategyAddress(address,address)': FunctionFragment;
+    'setUserEMode(uint8)': FunctionFragment;
+    'setUserUseReserveAsCollateral(address,bool)': FunctionFragment;
+    'supply(address,uint256,address,uint16)': FunctionFragment;
+    'supplyWithPermit(address,uint256,address,uint16,uint256,uint8,bytes32,bytes32)': FunctionFragment;
+    'swapBorrowRateMode(address,uint256)': FunctionFragment;
+    'updateBridgeProtocolFee(uint256)': FunctionFragment;
+    'updateFlashloanPremiums(uint128,uint128)': FunctionFragment;
+    'withdraw(address,uint256,address)': FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | 'ADDRESSES_PROVIDER'
+      | 'BRIDGE_PROTOCOL_FEE'
+      | 'FLASHLOAN_PREMIUM_TOTAL'
+      | 'FLASHLOAN_PREMIUM_TO_PROTOCOL'
+      | 'MAX_NUMBER_RESERVES'
+      | 'MAX_STABLE_RATE_BORROW_SIZE_PERCENT'
+      | 'POOL_REVISION'
+      | 'backUnbacked'
+      | 'borrow'
+      | 'configureEModeCategory'
+      | 'deposit'
+      | 'dropReserve'
+      | 'finalizeTransfer'
+      | 'flashLoan'
+      | 'flashLoanSimple'
+      | 'getConfiguration'
+      | 'getEModeCategoryData'
+      | 'getReserveAddressById'
+      | 'getReserveData'
+      | 'getReserveNormalizedIncome'
+      | 'getReserveNormalizedVariableDebt'
+      | 'getReservesList'
+      | 'getUserAccountData'
+      | 'getUserConfiguration'
+      | 'getUserEMode'
+      | 'initReserve'
+      | 'initialize'
+      | 'liquidationCall'
+      | 'mintToTreasury'
+      | 'mintUnbacked'
+      | 'rebalanceStableBorrowRate'
+      | 'repay'
+      | 'repayWithATokens'
+      | 'repayWithPermit'
+      | 'rescueTokens'
+      | 'resetIsolationModeTotalDebt'
+      | 'setConfiguration'
+      | 'setReserveInterestRateStrategyAddress'
+      | 'setUserEMode'
+      | 'setUserUseReserveAsCollateral'
+      | 'supply'
+      | 'supplyWithPermit'
+      | 'swapBorrowRateMode'
+      | 'updateBridgeProtocolFee'
+      | 'updateFlashloanPremiums'
+      | 'withdraw'
+  ): FunctionFragment;
+
+  encodeFunctionData(functionFragment: 'ADDRESSES_PROVIDER', values?: undefined): string;
+  encodeFunctionData(functionFragment: 'BRIDGE_PROTOCOL_FEE', values?: undefined): string;
+  encodeFunctionData(functionFragment: 'FLASHLOAN_PREMIUM_TOTAL', values?: undefined): string;
+  encodeFunctionData(functionFragment: 'FLASHLOAN_PREMIUM_TO_PROTOCOL', values?: undefined): string;
+  encodeFunctionData(functionFragment: 'MAX_NUMBER_RESERVES', values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: 'MAX_STABLE_RATE_BORROW_SIZE_PERCENT',
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: 'POOL_REVISION', values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: 'backUnbacked',
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'borrow',
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<string>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'configureEModeCategory',
+    values: [PromiseOrValue<BigNumberish>, DataTypes.EModeCategoryStruct]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'deposit',
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(functionFragment: 'dropReserve', values: [PromiseOrValue<string>]): string;
+  encodeFunctionData(
+    functionFragment: 'finalizeTransfer',
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'flashLoan',
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<string>[],
+      PromiseOrValue<BigNumberish>[],
+      PromiseOrValue<BigNumberish>[],
+      PromiseOrValue<string>,
+      PromiseOrValue<BytesLike>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'flashLoanSimple',
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BytesLike>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'getConfiguration',
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'getEModeCategoryData',
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'getReserveAddressById',
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(functionFragment: 'getReserveData', values: [PromiseOrValue<string>]): string;
+  encodeFunctionData(
+    functionFragment: 'getReserveNormalizedIncome',
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'getReserveNormalizedVariableDebt',
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(functionFragment: 'getReservesList', values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: 'getUserAccountData',
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'getUserConfiguration',
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(functionFragment: 'getUserEMode', values: [PromiseOrValue<string>]): string;
+  encodeFunctionData(
+    functionFragment: 'initReserve',
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<string>
+    ]
+  ): string;
+  encodeFunctionData(functionFragment: 'initialize', values: [PromiseOrValue<string>]): string;
+  encodeFunctionData(
+    functionFragment: 'liquidationCall',
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<boolean>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'mintToTreasury',
+    values: [PromiseOrValue<string>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'mintUnbacked',
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'rebalanceStableBorrowRate',
+    values: [PromiseOrValue<string>, PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'repay',
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<string>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'repayWithATokens',
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'repayWithPermit',
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BytesLike>,
+      PromiseOrValue<BytesLike>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'rescueTokens',
+    values: [PromiseOrValue<string>, PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'resetIsolationModeTotalDebt',
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'setConfiguration',
+    values: [PromiseOrValue<string>, DataTypes.ReserveConfigurationMapStruct]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'setReserveInterestRateStrategyAddress',
+    values: [PromiseOrValue<string>, PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'setUserEMode',
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'setUserUseReserveAsCollateral',
+    values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'supply',
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'supplyWithPermit',
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BytesLike>,
+      PromiseOrValue<BytesLike>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'swapBorrowRateMode',
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'updateBridgeProtocolFee',
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'updateFlashloanPremiums',
+    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: 'withdraw',
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>, PromiseOrValue<string>]
+  ): string;
+
+  decodeFunctionResult(functionFragment: 'ADDRESSES_PROVIDER', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'BRIDGE_PROTOCOL_FEE', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'FLASHLOAN_PREMIUM_TOTAL', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'FLASHLOAN_PREMIUM_TO_PROTOCOL', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'MAX_NUMBER_RESERVES', data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: 'MAX_STABLE_RATE_BORROW_SIZE_PERCENT',
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: 'POOL_REVISION', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'backUnbacked', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'borrow', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'configureEModeCategory', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'deposit', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'dropReserve', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'finalizeTransfer', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'flashLoan', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'flashLoanSimple', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'getConfiguration', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'getEModeCategoryData', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'getReserveAddressById', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'getReserveData', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'getReserveNormalizedIncome', data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: 'getReserveNormalizedVariableDebt',
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: 'getReservesList', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'getUserAccountData', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'getUserConfiguration', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'getUserEMode', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'initReserve', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'initialize', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'liquidationCall', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'mintToTreasury', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'mintUnbacked', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'rebalanceStableBorrowRate', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'repay', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'repayWithATokens', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'repayWithPermit', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'rescueTokens', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'resetIsolationModeTotalDebt', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'setConfiguration', data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: 'setReserveInterestRateStrategyAddress',
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: 'setUserEMode', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'setUserUseReserveAsCollateral', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'supply', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'supplyWithPermit', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'swapBorrowRateMode', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'updateBridgeProtocolFee', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'updateFlashloanPremiums', data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: 'withdraw', data: BytesLike): Result;
+
+  events: {
+    'BackUnbacked(address,address,uint256,uint256)': EventFragment;
+    'Borrow(address,address,address,uint256,uint8,uint256,uint16)': EventFragment;
+    'FlashLoan(address,address,address,uint256,uint8,uint256,uint16)': EventFragment;
+    'IsolationModeTotalDebtUpdated(address,uint256)': EventFragment;
+    'LiquidationCall(address,address,address,uint256,uint256,address,bool)': EventFragment;
+    'MintUnbacked(address,address,address,uint256,uint16)': EventFragment;
+    'MintedToTreasury(address,uint256)': EventFragment;
+    'RebalanceStableBorrowRate(address,address)': EventFragment;
+    'Repay(address,address,address,uint256,bool)': EventFragment;
+    'ReserveDataUpdated(address,uint256,uint256,uint256,uint256,uint256)': EventFragment;
+    'ReserveUsedAsCollateralDisabled(address,address)': EventFragment;
+    'ReserveUsedAsCollateralEnabled(address,address)': EventFragment;
+    'Supply(address,address,address,uint256,uint16)': EventFragment;
+    'SwapBorrowRateMode(address,address,uint8)': EventFragment;
+    'UserEModeSet(address,uint8)': EventFragment;
+    'Withdraw(address,address,address,uint256)': EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: 'BackUnbacked'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'Borrow'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'FlashLoan'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'IsolationModeTotalDebtUpdated'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'LiquidationCall'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'MintUnbacked'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'MintedToTreasury'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'RebalanceStableBorrowRate'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'Repay'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'ReserveDataUpdated'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'ReserveUsedAsCollateralDisabled'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'ReserveUsedAsCollateralEnabled'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'Supply'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'SwapBorrowRateMode'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'UserEModeSet'): EventFragment;
+  getEvent(nameOrSignatureOrTopic: 'Withdraw'): EventFragment;
+}
+
+export interface BackUnbackedEventObject {
+  reserve: string;
+  backer: string;
+  amount: BigNumber;
+  fee: BigNumber;
+}
+export type BackUnbackedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber],
+  BackUnbackedEventObject
+>;
+
+export type BackUnbackedEventFilter = TypedEventFilter<BackUnbackedEvent>;
+
+export interface BorrowEventObject {
+  reserve: string;
+  user: string;
+  onBehalfOf: string;
+  amount: BigNumber;
+  interestRateMode: number;
+  borrowRate: BigNumber;
+  referralCode: number;
+}
+export type BorrowEvent = TypedEvent<
+  [string, string, string, BigNumber, number, BigNumber, number],
+  BorrowEventObject
+>;
+
+export type BorrowEventFilter = TypedEventFilter<BorrowEvent>;
+
+export interface FlashLoanEventObject {
+  target: string;
+  initiator: string;
+  asset: string;
+  amount: BigNumber;
+  interestRateMode: number;
+  premium: BigNumber;
+  referralCode: number;
+}
+export type FlashLoanEvent = TypedEvent<
+  [string, string, string, BigNumber, number, BigNumber, number],
+  FlashLoanEventObject
+>;
+
+export type FlashLoanEventFilter = TypedEventFilter<FlashLoanEvent>;
+
+export interface IsolationModeTotalDebtUpdatedEventObject {
+  asset: string;
+  totalDebt: BigNumber;
+}
+export type IsolationModeTotalDebtUpdatedEvent = TypedEvent<
+  [string, BigNumber],
+  IsolationModeTotalDebtUpdatedEventObject
+>;
+
+export type IsolationModeTotalDebtUpdatedEventFilter =
+  TypedEventFilter<IsolationModeTotalDebtUpdatedEvent>;
+
+export interface LiquidationCallEventObject {
+  collateralAsset: string;
+  debtAsset: string;
+  user: string;
+  debtToCover: BigNumber;
+  liquidatedCollateralAmount: BigNumber;
+  liquidator: string;
+  receiveAToken: boolean;
+}
+export type LiquidationCallEvent = TypedEvent<
+  [string, string, string, BigNumber, BigNumber, string, boolean],
+  LiquidationCallEventObject
+>;
+
+export type LiquidationCallEventFilter = TypedEventFilter<LiquidationCallEvent>;
+
+export interface MintUnbackedEventObject {
+  reserve: string;
+  user: string;
+  onBehalfOf: string;
+  amount: BigNumber;
+  referralCode: number;
+}
+export type MintUnbackedEvent = TypedEvent<
+  [string, string, string, BigNumber, number],
+  MintUnbackedEventObject
+>;
+
+export type MintUnbackedEventFilter = TypedEventFilter<MintUnbackedEvent>;
+
+export interface MintedToTreasuryEventObject {
+  reserve: string;
+  amountMinted: BigNumber;
+}
+export type MintedToTreasuryEvent = TypedEvent<[string, BigNumber], MintedToTreasuryEventObject>;
+
+export type MintedToTreasuryEventFilter = TypedEventFilter<MintedToTreasuryEvent>;
+
+export interface RebalanceStableBorrowRateEventObject {
+  reserve: string;
+  user: string;
+}
+export type RebalanceStableBorrowRateEvent = TypedEvent<
+  [string, string],
+  RebalanceStableBorrowRateEventObject
+>;
+
+export type RebalanceStableBorrowRateEventFilter = TypedEventFilter<RebalanceStableBorrowRateEvent>;
+
+export interface RepayEventObject {
+  reserve: string;
+  user: string;
+  repayer: string;
+  amount: BigNumber;
+  useATokens: boolean;
+}
+export type RepayEvent = TypedEvent<[string, string, string, BigNumber, boolean], RepayEventObject>;
+
+export type RepayEventFilter = TypedEventFilter<RepayEvent>;
+
+export interface ReserveDataUpdatedEventObject {
+  reserve: string;
+  liquidityRate: BigNumber;
+  stableBorrowRate: BigNumber;
+  variableBorrowRate: BigNumber;
+  liquidityIndex: BigNumber;
+  variableBorrowIndex: BigNumber;
+}
+export type ReserveDataUpdatedEvent = TypedEvent<
+  [string, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber],
+  ReserveDataUpdatedEventObject
+>;
+
+export type ReserveDataUpdatedEventFilter = TypedEventFilter<ReserveDataUpdatedEvent>;
+
+export interface ReserveUsedAsCollateralDisabledEventObject {
+  reserve: string;
+  user: string;
+}
+export type ReserveUsedAsCollateralDisabledEvent = TypedEvent<
+  [string, string],
+  ReserveUsedAsCollateralDisabledEventObject
+>;
+
+export type ReserveUsedAsCollateralDisabledEventFilter =
+  TypedEventFilter<ReserveUsedAsCollateralDisabledEvent>;
+
+export interface ReserveUsedAsCollateralEnabledEventObject {
+  reserve: string;
+  user: string;
+}
+export type ReserveUsedAsCollateralEnabledEvent = TypedEvent<
+  [string, string],
+  ReserveUsedAsCollateralEnabledEventObject
+>;
+
+export type ReserveUsedAsCollateralEnabledEventFilter =
+  TypedEventFilter<ReserveUsedAsCollateralEnabledEvent>;
+
+export interface SupplyEventObject {
+  reserve: string;
+  user: string;
+  onBehalfOf: string;
+  amount: BigNumber;
+  referralCode: number;
+}
+export type SupplyEvent = TypedEvent<
+  [string, string, string, BigNumber, number],
+  SupplyEventObject
+>;
+
+export type SupplyEventFilter = TypedEventFilter<SupplyEvent>;
+
+export interface SwapBorrowRateModeEventObject {
+  reserve: string;
+  user: string;
+  interestRateMode: number;
+}
+export type SwapBorrowRateModeEvent = TypedEvent<
+  [string, string, number],
+  SwapBorrowRateModeEventObject
+>;
+
+export type SwapBorrowRateModeEventFilter = TypedEventFilter<SwapBorrowRateModeEvent>;
+
+export interface UserEModeSetEventObject {
+  user: string;
+  categoryId: number;
+}
+export type UserEModeSetEvent = TypedEvent<[string, number], UserEModeSetEventObject>;
+
+export type UserEModeSetEventFilter = TypedEventFilter<UserEModeSetEvent>;
+
+export interface WithdrawEventObject {
+  reserve: string;
+  user: string;
+  to: string;
+  amount: BigNumber;
+}
+export type WithdrawEvent = TypedEvent<[string, string, string, BigNumber], WithdrawEventObject>;
+
+export type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;
+
+export interface Pool extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: PoolInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    ADDRESSES_PROVIDER(overrides?: CallOverrides): Promise<[string]>;
+
+    BRIDGE_PROTOCOL_FEE(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    FLASHLOAN_PREMIUM_TOTAL(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    FLASHLOAN_PREMIUM_TO_PROTOCOL(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    MAX_NUMBER_RESERVES(overrides?: CallOverrides): Promise<[number]>;
+
+    MAX_STABLE_RATE_BORROW_SIZE_PERCENT(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    POOL_REVISION(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    backUnbacked(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      fee: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    borrow(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    configureEModeCategory(
+      id: PromiseOrValue<BigNumberish>,
+      category: DataTypes.EModeCategoryStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    deposit(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    dropReserve(
+      asset: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    finalizeTransfer(
+      asset: PromiseOrValue<string>,
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      balanceFromBefore: PromiseOrValue<BigNumberish>,
+      balanceToBefore: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    flashLoan(
+      receiverAddress: PromiseOrValue<string>,
+      assets: PromiseOrValue<string>[],
+      amounts: PromiseOrValue<BigNumberish>[],
+      interestRateModes: PromiseOrValue<BigNumberish>[],
+      onBehalfOf: PromiseOrValue<string>,
+      params: PromiseOrValue<BytesLike>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    flashLoanSimple(
+      receiverAddress: PromiseOrValue<string>,
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      params: PromiseOrValue<BytesLike>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    getConfiguration(
+      asset: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[DataTypes.ReserveConfigurationMapStructOutput]>;
+
+    getEModeCategoryData(
+      id: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[DataTypes.EModeCategoryStructOutput]>;
+
+    getReserveAddressById(
+      id: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    getReserveData(
+      asset: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[DataTypes.ReserveDataStructOutput]>;
+
+    getReserveNormalizedIncome(
+      asset: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getReserveNormalizedVariableDebt(
+      asset: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getReservesList(overrides?: CallOverrides): Promise<[string[]]>;
+
+    getUserAccountData(
+      user: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        totalCollateralBase: BigNumber;
+        totalDebtBase: BigNumber;
+        availableBorrowsBase: BigNumber;
+        currentLiquidationThreshold: BigNumber;
+        ltv: BigNumber;
+        healthFactor: BigNumber;
+      }
+    >;
+
+    getUserConfiguration(
+      user: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[DataTypes.UserConfigurationMapStructOutput]>;
+
+    getUserEMode(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    initReserve(
+      asset: PromiseOrValue<string>,
+      aTokenAddress: PromiseOrValue<string>,
+      stableDebtAddress: PromiseOrValue<string>,
+      variableDebtAddress: PromiseOrValue<string>,
+      interestRateStrategyAddress: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    initialize(
+      provider: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    liquidationCall(
+      collateralAsset: PromiseOrValue<string>,
+      debtAsset: PromiseOrValue<string>,
+      user: PromiseOrValue<string>,
+      debtToCover: PromiseOrValue<BigNumberish>,
+      receiveAToken: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    mintToTreasury(
+      assets: PromiseOrValue<string>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    mintUnbacked(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    rebalanceStableBorrowRate(
+      asset: PromiseOrValue<string>,
+      user: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    repay(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    repayWithATokens(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    repayWithPermit(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      deadline: PromiseOrValue<BigNumberish>,
+      permitV: PromiseOrValue<BigNumberish>,
+      permitR: PromiseOrValue<BytesLike>,
+      permitS: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    rescueTokens(
+      token: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    resetIsolationModeTotalDebt(
+      asset: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    setConfiguration(
+      asset: PromiseOrValue<string>,
+      configuration: DataTypes.ReserveConfigurationMapStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    setReserveInterestRateStrategyAddress(
+      asset: PromiseOrValue<string>,
+      rateStrategyAddress: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    setUserEMode(
+      categoryId: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    setUserUseReserveAsCollateral(
+      asset: PromiseOrValue<string>,
+      useAsCollateral: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    supply(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    supplyWithPermit(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      deadline: PromiseOrValue<BigNumberish>,
+      permitV: PromiseOrValue<BigNumberish>,
+      permitR: PromiseOrValue<BytesLike>,
+      permitS: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    swapBorrowRateMode(
+      asset: PromiseOrValue<string>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    updateBridgeProtocolFee(
+      protocolFee: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    updateFlashloanPremiums(
+      flashLoanPremiumTotal: PromiseOrValue<BigNumberish>,
+      flashLoanPremiumToProtocol: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    withdraw(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      to: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  ADDRESSES_PROVIDER(overrides?: CallOverrides): Promise<string>;
+
+  BRIDGE_PROTOCOL_FEE(overrides?: CallOverrides): Promise<BigNumber>;
+
+  FLASHLOAN_PREMIUM_TOTAL(overrides?: CallOverrides): Promise<BigNumber>;
+
+  FLASHLOAN_PREMIUM_TO_PROTOCOL(overrides?: CallOverrides): Promise<BigNumber>;
+
+  MAX_NUMBER_RESERVES(overrides?: CallOverrides): Promise<number>;
+
+  MAX_STABLE_RATE_BORROW_SIZE_PERCENT(overrides?: CallOverrides): Promise<BigNumber>;
+
+  POOL_REVISION(overrides?: CallOverrides): Promise<BigNumber>;
+
+  backUnbacked(
+    asset: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    fee: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  borrow(
+    asset: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    interestRateMode: PromiseOrValue<BigNumberish>,
+    referralCode: PromiseOrValue<BigNumberish>,
+    onBehalfOf: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  configureEModeCategory(
+    id: PromiseOrValue<BigNumberish>,
+    category: DataTypes.EModeCategoryStruct,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  deposit(
+    asset: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    onBehalfOf: PromiseOrValue<string>,
+    referralCode: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  dropReserve(
+    asset: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  finalizeTransfer(
+    asset: PromiseOrValue<string>,
+    from: PromiseOrValue<string>,
+    to: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    balanceFromBefore: PromiseOrValue<BigNumberish>,
+    balanceToBefore: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  flashLoan(
+    receiverAddress: PromiseOrValue<string>,
+    assets: PromiseOrValue<string>[],
+    amounts: PromiseOrValue<BigNumberish>[],
+    interestRateModes: PromiseOrValue<BigNumberish>[],
+    onBehalfOf: PromiseOrValue<string>,
+    params: PromiseOrValue<BytesLike>,
+    referralCode: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  flashLoanSimple(
+    receiverAddress: PromiseOrValue<string>,
+    asset: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    params: PromiseOrValue<BytesLike>,
+    referralCode: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  getConfiguration(
+    asset: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<DataTypes.ReserveConfigurationMapStructOutput>;
+
+  getEModeCategoryData(
+    id: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<DataTypes.EModeCategoryStructOutput>;
+
+  getReserveAddressById(
+    id: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getReserveData(
+    asset: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<DataTypes.ReserveDataStructOutput>;
+
+  getReserveNormalizedIncome(
+    asset: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getReserveNormalizedVariableDebt(
+    asset: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getReservesList(overrides?: CallOverrides): Promise<string[]>;
+
+  getUserAccountData(
+    user: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+      totalCollateralBase: BigNumber;
+      totalDebtBase: BigNumber;
+      availableBorrowsBase: BigNumber;
+      currentLiquidationThreshold: BigNumber;
+      ltv: BigNumber;
+      healthFactor: BigNumber;
+    }
+  >;
+
+  getUserConfiguration(
+    user: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<DataTypes.UserConfigurationMapStructOutput>;
+
+  getUserEMode(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+
+  initReserve(
+    asset: PromiseOrValue<string>,
+    aTokenAddress: PromiseOrValue<string>,
+    stableDebtAddress: PromiseOrValue<string>,
+    variableDebtAddress: PromiseOrValue<string>,
+    interestRateStrategyAddress: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  initialize(
+    provider: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  liquidationCall(
+    collateralAsset: PromiseOrValue<string>,
+    debtAsset: PromiseOrValue<string>,
+    user: PromiseOrValue<string>,
+    debtToCover: PromiseOrValue<BigNumberish>,
+    receiveAToken: PromiseOrValue<boolean>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  mintToTreasury(
+    assets: PromiseOrValue<string>[],
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  mintUnbacked(
+    asset: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    onBehalfOf: PromiseOrValue<string>,
+    referralCode: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  rebalanceStableBorrowRate(
+    asset: PromiseOrValue<string>,
+    user: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  repay(
+    asset: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    interestRateMode: PromiseOrValue<BigNumberish>,
+    onBehalfOf: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  repayWithATokens(
+    asset: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    interestRateMode: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  repayWithPermit(
+    asset: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    interestRateMode: PromiseOrValue<BigNumberish>,
+    onBehalfOf: PromiseOrValue<string>,
+    deadline: PromiseOrValue<BigNumberish>,
+    permitV: PromiseOrValue<BigNumberish>,
+    permitR: PromiseOrValue<BytesLike>,
+    permitS: PromiseOrValue<BytesLike>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  rescueTokens(
+    token: PromiseOrValue<string>,
+    to: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  resetIsolationModeTotalDebt(
+    asset: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  setConfiguration(
+    asset: PromiseOrValue<string>,
+    configuration: DataTypes.ReserveConfigurationMapStruct,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  setReserveInterestRateStrategyAddress(
+    asset: PromiseOrValue<string>,
+    rateStrategyAddress: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  setUserEMode(
+    categoryId: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  setUserUseReserveAsCollateral(
+    asset: PromiseOrValue<string>,
+    useAsCollateral: PromiseOrValue<boolean>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  supply(
+    asset: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    onBehalfOf: PromiseOrValue<string>,
+    referralCode: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  supplyWithPermit(
+    asset: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    onBehalfOf: PromiseOrValue<string>,
+    referralCode: PromiseOrValue<BigNumberish>,
+    deadline: PromiseOrValue<BigNumberish>,
+    permitV: PromiseOrValue<BigNumberish>,
+    permitR: PromiseOrValue<BytesLike>,
+    permitS: PromiseOrValue<BytesLike>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  swapBorrowRateMode(
+    asset: PromiseOrValue<string>,
+    interestRateMode: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  updateBridgeProtocolFee(
+    protocolFee: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  updateFlashloanPremiums(
+    flashLoanPremiumTotal: PromiseOrValue<BigNumberish>,
+    flashLoanPremiumToProtocol: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  withdraw(
+    asset: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    to: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    ADDRESSES_PROVIDER(overrides?: CallOverrides): Promise<string>;
+
+    BRIDGE_PROTOCOL_FEE(overrides?: CallOverrides): Promise<BigNumber>;
+
+    FLASHLOAN_PREMIUM_TOTAL(overrides?: CallOverrides): Promise<BigNumber>;
+
+    FLASHLOAN_PREMIUM_TO_PROTOCOL(overrides?: CallOverrides): Promise<BigNumber>;
+
+    MAX_NUMBER_RESERVES(overrides?: CallOverrides): Promise<number>;
+
+    MAX_STABLE_RATE_BORROW_SIZE_PERCENT(overrides?: CallOverrides): Promise<BigNumber>;
+
+    POOL_REVISION(overrides?: CallOverrides): Promise<BigNumber>;
+
+    backUnbacked(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      fee: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    borrow(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    configureEModeCategory(
+      id: PromiseOrValue<BigNumberish>,
+      category: DataTypes.EModeCategoryStruct,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    deposit(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    dropReserve(asset: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+
+    finalizeTransfer(
+      asset: PromiseOrValue<string>,
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      balanceFromBefore: PromiseOrValue<BigNumberish>,
+      balanceToBefore: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    flashLoan(
+      receiverAddress: PromiseOrValue<string>,
+      assets: PromiseOrValue<string>[],
+      amounts: PromiseOrValue<BigNumberish>[],
+      interestRateModes: PromiseOrValue<BigNumberish>[],
+      onBehalfOf: PromiseOrValue<string>,
+      params: PromiseOrValue<BytesLike>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    flashLoanSimple(
+      receiverAddress: PromiseOrValue<string>,
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      params: PromiseOrValue<BytesLike>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    getConfiguration(
+      asset: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<DataTypes.ReserveConfigurationMapStructOutput>;
+
+    getEModeCategoryData(
+      id: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<DataTypes.EModeCategoryStructOutput>;
+
+    getReserveAddressById(
+      id: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getReserveData(
+      asset: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<DataTypes.ReserveDataStructOutput>;
+
+    getReserveNormalizedIncome(
+      asset: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getReserveNormalizedVariableDebt(
+      asset: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getReservesList(overrides?: CallOverrides): Promise<string[]>;
+
+    getUserAccountData(
+      user: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        totalCollateralBase: BigNumber;
+        totalDebtBase: BigNumber;
+        availableBorrowsBase: BigNumber;
+        currentLiquidationThreshold: BigNumber;
+        ltv: BigNumber;
+        healthFactor: BigNumber;
+      }
+    >;
+
+    getUserConfiguration(
+      user: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<DataTypes.UserConfigurationMapStructOutput>;
+
+    getUserEMode(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+
+    initReserve(
+      asset: PromiseOrValue<string>,
+      aTokenAddress: PromiseOrValue<string>,
+      stableDebtAddress: PromiseOrValue<string>,
+      variableDebtAddress: PromiseOrValue<string>,
+      interestRateStrategyAddress: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    initialize(provider: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+
+    liquidationCall(
+      collateralAsset: PromiseOrValue<string>,
+      debtAsset: PromiseOrValue<string>,
+      user: PromiseOrValue<string>,
+      debtToCover: PromiseOrValue<BigNumberish>,
+      receiveAToken: PromiseOrValue<boolean>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    mintToTreasury(assets: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<void>;
+
+    mintUnbacked(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    rebalanceStableBorrowRate(
+      asset: PromiseOrValue<string>,
+      user: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    repay(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    repayWithATokens(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    repayWithPermit(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      deadline: PromiseOrValue<BigNumberish>,
+      permitV: PromiseOrValue<BigNumberish>,
+      permitR: PromiseOrValue<BytesLike>,
+      permitS: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    rescueTokens(
+      token: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    resetIsolationModeTotalDebt(
+      asset: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    setConfiguration(
+      asset: PromiseOrValue<string>,
+      configuration: DataTypes.ReserveConfigurationMapStruct,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    setReserveInterestRateStrategyAddress(
+      asset: PromiseOrValue<string>,
+      rateStrategyAddress: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    setUserEMode(
+      categoryId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    setUserUseReserveAsCollateral(
+      asset: PromiseOrValue<string>,
+      useAsCollateral: PromiseOrValue<boolean>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    supply(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    supplyWithPermit(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      deadline: PromiseOrValue<BigNumberish>,
+      permitV: PromiseOrValue<BigNumberish>,
+      permitR: PromiseOrValue<BytesLike>,
+      permitS: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    swapBorrowRateMode(
+      asset: PromiseOrValue<string>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    updateBridgeProtocolFee(
+      protocolFee: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    updateFlashloanPremiums(
+      flashLoanPremiumTotal: PromiseOrValue<BigNumberish>,
+      flashLoanPremiumToProtocol: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    withdraw(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      to: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {
+    'BackUnbacked(address,address,uint256,uint256)'(
+      reserve?: PromiseOrValue<string> | null,
+      backer?: PromiseOrValue<string> | null,
+      amount?: null,
+      fee?: null
+    ): BackUnbackedEventFilter;
+    BackUnbacked(
+      reserve?: PromiseOrValue<string> | null,
+      backer?: PromiseOrValue<string> | null,
+      amount?: null,
+      fee?: null
+    ): BackUnbackedEventFilter;
+
+    'Borrow(address,address,address,uint256,uint8,uint256,uint16)'(
+      reserve?: PromiseOrValue<string> | null,
+      user?: null,
+      onBehalfOf?: PromiseOrValue<string> | null,
+      amount?: null,
+      interestRateMode?: null,
+      borrowRate?: null,
+      referralCode?: PromiseOrValue<BigNumberish> | null
+    ): BorrowEventFilter;
+    Borrow(
+      reserve?: PromiseOrValue<string> | null,
+      user?: null,
+      onBehalfOf?: PromiseOrValue<string> | null,
+      amount?: null,
+      interestRateMode?: null,
+      borrowRate?: null,
+      referralCode?: PromiseOrValue<BigNumberish> | null
+    ): BorrowEventFilter;
+
+    'FlashLoan(address,address,address,uint256,uint8,uint256,uint16)'(
+      target?: PromiseOrValue<string> | null,
+      initiator?: null,
+      asset?: PromiseOrValue<string> | null,
+      amount?: null,
+      interestRateMode?: null,
+      premium?: null,
+      referralCode?: PromiseOrValue<BigNumberish> | null
+    ): FlashLoanEventFilter;
+    FlashLoan(
+      target?: PromiseOrValue<string> | null,
+      initiator?: null,
+      asset?: PromiseOrValue<string> | null,
+      amount?: null,
+      interestRateMode?: null,
+      premium?: null,
+      referralCode?: PromiseOrValue<BigNumberish> | null
+    ): FlashLoanEventFilter;
+
+    'IsolationModeTotalDebtUpdated(address,uint256)'(
+      asset?: PromiseOrValue<string> | null,
+      totalDebt?: null
+    ): IsolationModeTotalDebtUpdatedEventFilter;
+    IsolationModeTotalDebtUpdated(
+      asset?: PromiseOrValue<string> | null,
+      totalDebt?: null
+    ): IsolationModeTotalDebtUpdatedEventFilter;
+
+    'LiquidationCall(address,address,address,uint256,uint256,address,bool)'(
+      collateralAsset?: PromiseOrValue<string> | null,
+      debtAsset?: PromiseOrValue<string> | null,
+      user?: PromiseOrValue<string> | null,
+      debtToCover?: null,
+      liquidatedCollateralAmount?: null,
+      liquidator?: null,
+      receiveAToken?: null
+    ): LiquidationCallEventFilter;
+    LiquidationCall(
+      collateralAsset?: PromiseOrValue<string> | null,
+      debtAsset?: PromiseOrValue<string> | null,
+      user?: PromiseOrValue<string> | null,
+      debtToCover?: null,
+      liquidatedCollateralAmount?: null,
+      liquidator?: null,
+      receiveAToken?: null
+    ): LiquidationCallEventFilter;
+
+    'MintUnbacked(address,address,address,uint256,uint16)'(
+      reserve?: PromiseOrValue<string> | null,
+      user?: null,
+      onBehalfOf?: PromiseOrValue<string> | null,
+      amount?: null,
+      referralCode?: PromiseOrValue<BigNumberish> | null
+    ): MintUnbackedEventFilter;
+    MintUnbacked(
+      reserve?: PromiseOrValue<string> | null,
+      user?: null,
+      onBehalfOf?: PromiseOrValue<string> | null,
+      amount?: null,
+      referralCode?: PromiseOrValue<BigNumberish> | null
+    ): MintUnbackedEventFilter;
+
+    'MintedToTreasury(address,uint256)'(
+      reserve?: PromiseOrValue<string> | null,
+      amountMinted?: null
+    ): MintedToTreasuryEventFilter;
+    MintedToTreasury(
+      reserve?: PromiseOrValue<string> | null,
+      amountMinted?: null
+    ): MintedToTreasuryEventFilter;
+
+    'RebalanceStableBorrowRate(address,address)'(
+      reserve?: PromiseOrValue<string> | null,
+      user?: PromiseOrValue<string> | null
+    ): RebalanceStableBorrowRateEventFilter;
+    RebalanceStableBorrowRate(
+      reserve?: PromiseOrValue<string> | null,
+      user?: PromiseOrValue<string> | null
+    ): RebalanceStableBorrowRateEventFilter;
+
+    'Repay(address,address,address,uint256,bool)'(
+      reserve?: PromiseOrValue<string> | null,
+      user?: PromiseOrValue<string> | null,
+      repayer?: PromiseOrValue<string> | null,
+      amount?: null,
+      useATokens?: null
+    ): RepayEventFilter;
+    Repay(
+      reserve?: PromiseOrValue<string> | null,
+      user?: PromiseOrValue<string> | null,
+      repayer?: PromiseOrValue<string> | null,
+      amount?: null,
+      useATokens?: null
+    ): RepayEventFilter;
+
+    'ReserveDataUpdated(address,uint256,uint256,uint256,uint256,uint256)'(
+      reserve?: PromiseOrValue<string> | null,
+      liquidityRate?: null,
+      stableBorrowRate?: null,
+      variableBorrowRate?: null,
+      liquidityIndex?: null,
+      variableBorrowIndex?: null
+    ): ReserveDataUpdatedEventFilter;
+    ReserveDataUpdated(
+      reserve?: PromiseOrValue<string> | null,
+      liquidityRate?: null,
+      stableBorrowRate?: null,
+      variableBorrowRate?: null,
+      liquidityIndex?: null,
+      variableBorrowIndex?: null
+    ): ReserveDataUpdatedEventFilter;
+
+    'ReserveUsedAsCollateralDisabled(address,address)'(
+      reserve?: PromiseOrValue<string> | null,
+      user?: PromiseOrValue<string> | null
+    ): ReserveUsedAsCollateralDisabledEventFilter;
+    ReserveUsedAsCollateralDisabled(
+      reserve?: PromiseOrValue<string> | null,
+      user?: PromiseOrValue<string> | null
+    ): ReserveUsedAsCollateralDisabledEventFilter;
+
+    'ReserveUsedAsCollateralEnabled(address,address)'(
+      reserve?: PromiseOrValue<string> | null,
+      user?: PromiseOrValue<string> | null
+    ): ReserveUsedAsCollateralEnabledEventFilter;
+    ReserveUsedAsCollateralEnabled(
+      reserve?: PromiseOrValue<string> | null,
+      user?: PromiseOrValue<string> | null
+    ): ReserveUsedAsCollateralEnabledEventFilter;
+
+    'Supply(address,address,address,uint256,uint16)'(
+      reserve?: PromiseOrValue<string> | null,
+      user?: null,
+      onBehalfOf?: PromiseOrValue<string> | null,
+      amount?: null,
+      referralCode?: PromiseOrValue<BigNumberish> | null
+    ): SupplyEventFilter;
+    Supply(
+      reserve?: PromiseOrValue<string> | null,
+      user?: null,
+      onBehalfOf?: PromiseOrValue<string> | null,
+      amount?: null,
+      referralCode?: PromiseOrValue<BigNumberish> | null
+    ): SupplyEventFilter;
+
+    'SwapBorrowRateMode(address,address,uint8)'(
+      reserve?: PromiseOrValue<string> | null,
+      user?: PromiseOrValue<string> | null,
+      interestRateMode?: null
+    ): SwapBorrowRateModeEventFilter;
+    SwapBorrowRateMode(
+      reserve?: PromiseOrValue<string> | null,
+      user?: PromiseOrValue<string> | null,
+      interestRateMode?: null
+    ): SwapBorrowRateModeEventFilter;
+
+    'UserEModeSet(address,uint8)'(
+      user?: PromiseOrValue<string> | null,
+      categoryId?: null
+    ): UserEModeSetEventFilter;
+    UserEModeSet(user?: PromiseOrValue<string> | null, categoryId?: null): UserEModeSetEventFilter;
+
+    'Withdraw(address,address,address,uint256)'(
+      reserve?: PromiseOrValue<string> | null,
+      user?: PromiseOrValue<string> | null,
+      to?: PromiseOrValue<string> | null,
+      amount?: null
+    ): WithdrawEventFilter;
+    Withdraw(
+      reserve?: PromiseOrValue<string> | null,
+      user?: PromiseOrValue<string> | null,
+      to?: PromiseOrValue<string> | null,
+      amount?: null
+    ): WithdrawEventFilter;
+  };
+
+  estimateGas: {
+    ADDRESSES_PROVIDER(overrides?: CallOverrides): Promise<BigNumber>;
+
+    BRIDGE_PROTOCOL_FEE(overrides?: CallOverrides): Promise<BigNumber>;
+
+    FLASHLOAN_PREMIUM_TOTAL(overrides?: CallOverrides): Promise<BigNumber>;
+
+    FLASHLOAN_PREMIUM_TO_PROTOCOL(overrides?: CallOverrides): Promise<BigNumber>;
+
+    MAX_NUMBER_RESERVES(overrides?: CallOverrides): Promise<BigNumber>;
+
+    MAX_STABLE_RATE_BORROW_SIZE_PERCENT(overrides?: CallOverrides): Promise<BigNumber>;
+
+    POOL_REVISION(overrides?: CallOverrides): Promise<BigNumber>;
+
+    backUnbacked(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      fee: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    borrow(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    configureEModeCategory(
+      id: PromiseOrValue<BigNumberish>,
+      category: DataTypes.EModeCategoryStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    deposit(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    dropReserve(
+      asset: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    finalizeTransfer(
+      asset: PromiseOrValue<string>,
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      balanceFromBefore: PromiseOrValue<BigNumberish>,
+      balanceToBefore: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    flashLoan(
+      receiverAddress: PromiseOrValue<string>,
+      assets: PromiseOrValue<string>[],
+      amounts: PromiseOrValue<BigNumberish>[],
+      interestRateModes: PromiseOrValue<BigNumberish>[],
+      onBehalfOf: PromiseOrValue<string>,
+      params: PromiseOrValue<BytesLike>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    flashLoanSimple(
+      receiverAddress: PromiseOrValue<string>,
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      params: PromiseOrValue<BytesLike>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    getConfiguration(asset: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+
+    getEModeCategoryData(
+      id: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getReserveAddressById(
+      id: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getReserveData(asset: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+
+    getReserveNormalizedIncome(
+      asset: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getReserveNormalizedVariableDebt(
+      asset: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getReservesList(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getUserAccountData(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+
+    getUserConfiguration(
+      user: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getUserEMode(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+
+    initReserve(
+      asset: PromiseOrValue<string>,
+      aTokenAddress: PromiseOrValue<string>,
+      stableDebtAddress: PromiseOrValue<string>,
+      variableDebtAddress: PromiseOrValue<string>,
+      interestRateStrategyAddress: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    initialize(
+      provider: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    liquidationCall(
+      collateralAsset: PromiseOrValue<string>,
+      debtAsset: PromiseOrValue<string>,
+      user: PromiseOrValue<string>,
+      debtToCover: PromiseOrValue<BigNumberish>,
+      receiveAToken: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    mintToTreasury(
+      assets: PromiseOrValue<string>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    mintUnbacked(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    rebalanceStableBorrowRate(
+      asset: PromiseOrValue<string>,
+      user: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    repay(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    repayWithATokens(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    repayWithPermit(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      deadline: PromiseOrValue<BigNumberish>,
+      permitV: PromiseOrValue<BigNumberish>,
+      permitR: PromiseOrValue<BytesLike>,
+      permitS: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    rescueTokens(
+      token: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    resetIsolationModeTotalDebt(
+      asset: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    setConfiguration(
+      asset: PromiseOrValue<string>,
+      configuration: DataTypes.ReserveConfigurationMapStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    setReserveInterestRateStrategyAddress(
+      asset: PromiseOrValue<string>,
+      rateStrategyAddress: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    setUserEMode(
+      categoryId: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    setUserUseReserveAsCollateral(
+      asset: PromiseOrValue<string>,
+      useAsCollateral: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    supply(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    supplyWithPermit(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      deadline: PromiseOrValue<BigNumberish>,
+      permitV: PromiseOrValue<BigNumberish>,
+      permitR: PromiseOrValue<BytesLike>,
+      permitS: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    swapBorrowRateMode(
+      asset: PromiseOrValue<string>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    updateBridgeProtocolFee(
+      protocolFee: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    updateFlashloanPremiums(
+      flashLoanPremiumTotal: PromiseOrValue<BigNumberish>,
+      flashLoanPremiumToProtocol: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    withdraw(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      to: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    ADDRESSES_PROVIDER(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    BRIDGE_PROTOCOL_FEE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    FLASHLOAN_PREMIUM_TOTAL(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    FLASHLOAN_PREMIUM_TO_PROTOCOL(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    MAX_NUMBER_RESERVES(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    MAX_STABLE_RATE_BORROW_SIZE_PERCENT(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    POOL_REVISION(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    backUnbacked(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      fee: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    borrow(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    configureEModeCategory(
+      id: PromiseOrValue<BigNumberish>,
+      category: DataTypes.EModeCategoryStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    deposit(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    dropReserve(
+      asset: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    finalizeTransfer(
+      asset: PromiseOrValue<string>,
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      balanceFromBefore: PromiseOrValue<BigNumberish>,
+      balanceToBefore: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    flashLoan(
+      receiverAddress: PromiseOrValue<string>,
+      assets: PromiseOrValue<string>[],
+      amounts: PromiseOrValue<BigNumberish>[],
+      interestRateModes: PromiseOrValue<BigNumberish>[],
+      onBehalfOf: PromiseOrValue<string>,
+      params: PromiseOrValue<BytesLike>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    flashLoanSimple(
+      receiverAddress: PromiseOrValue<string>,
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      params: PromiseOrValue<BytesLike>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getConfiguration(
+      asset: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getEModeCategoryData(
+      id: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getReserveAddressById(
+      id: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getReserveData(
+      asset: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getReserveNormalizedIncome(
+      asset: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getReserveNormalizedVariableDebt(
+      asset: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getReservesList(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getUserAccountData(
+      user: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getUserConfiguration(
+      user: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getUserEMode(
+      user: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    initReserve(
+      asset: PromiseOrValue<string>,
+      aTokenAddress: PromiseOrValue<string>,
+      stableDebtAddress: PromiseOrValue<string>,
+      variableDebtAddress: PromiseOrValue<string>,
+      interestRateStrategyAddress: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    initialize(
+      provider: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    liquidationCall(
+      collateralAsset: PromiseOrValue<string>,
+      debtAsset: PromiseOrValue<string>,
+      user: PromiseOrValue<string>,
+      debtToCover: PromiseOrValue<BigNumberish>,
+      receiveAToken: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    mintToTreasury(
+      assets: PromiseOrValue<string>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    mintUnbacked(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    rebalanceStableBorrowRate(
+      asset: PromiseOrValue<string>,
+      user: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    repay(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    repayWithATokens(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    repayWithPermit(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      deadline: PromiseOrValue<BigNumberish>,
+      permitV: PromiseOrValue<BigNumberish>,
+      permitR: PromiseOrValue<BytesLike>,
+      permitS: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    rescueTokens(
+      token: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    resetIsolationModeTotalDebt(
+      asset: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    setConfiguration(
+      asset: PromiseOrValue<string>,
+      configuration: DataTypes.ReserveConfigurationMapStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    setReserveInterestRateStrategyAddress(
+      asset: PromiseOrValue<string>,
+      rateStrategyAddress: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    setUserEMode(
+      categoryId: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    setUserUseReserveAsCollateral(
+      asset: PromiseOrValue<string>,
+      useAsCollateral: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    supply(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    supplyWithPermit(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      onBehalfOf: PromiseOrValue<string>,
+      referralCode: PromiseOrValue<BigNumberish>,
+      deadline: PromiseOrValue<BigNumberish>,
+      permitV: PromiseOrValue<BigNumberish>,
+      permitR: PromiseOrValue<BytesLike>,
+      permitS: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapBorrowRateMode(
+      asset: PromiseOrValue<string>,
+      interestRateMode: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    updateBridgeProtocolFee(
+      protocolFee: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    updateFlashloanPremiums(
+      flashLoanPremiumTotal: PromiseOrValue<BigNumberish>,
+      flashLoanPremiumToProtocol: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    withdraw(
+      asset: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      to: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}
+
+export const PoolABI = [
+  {
+    inputs: [
+      {
+        internalType: 'contract IPoolAddressesProvider',
+        name: 'provider',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'constructor',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'reserve',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'backer',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'fee',
+        type: 'uint256',
+      },
+    ],
+    name: 'BackUnbacked',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'reserve',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'onBehalfOf',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        indexed: false,
+        internalType: 'enum DataTypes.InterestRateMode',
+        name: 'interestRateMode',
+        type: 'uint8',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'borrowRate',
+        type: 'uint256',
+      },
+      {
+        indexed: true,
+        internalType: 'uint16',
+        name: 'referralCode',
+        type: 'uint16',
+      },
+    ],
+    name: 'Borrow',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'target',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'address',
+        name: 'initiator',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        indexed: false,
+        internalType: 'enum DataTypes.InterestRateMode',
+        name: 'interestRateMode',
+        type: 'uint8',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'premium',
+        type: 'uint256',
+      },
+      {
+        indexed: true,
+        internalType: 'uint16',
+        name: 'referralCode',
+        type: 'uint16',
+      },
+    ],
+    name: 'FlashLoan',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'totalDebt',
+        type: 'uint256',
+      },
+    ],
+    name: 'IsolationModeTotalDebtUpdated',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'collateralAsset',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'debtAsset',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'debtToCover',
+        type: 'uint256',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'liquidatedCollateralAmount',
+        type: 'uint256',
+      },
+      {
+        indexed: false,
+        internalType: 'address',
+        name: 'liquidator',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'bool',
+        name: 'receiveAToken',
+        type: 'bool',
+      },
+    ],
+    name: 'LiquidationCall',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'reserve',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'onBehalfOf',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        indexed: true,
+        internalType: 'uint16',
+        name: 'referralCode',
+        type: 'uint16',
+      },
+    ],
+    name: 'MintUnbacked',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'reserve',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'amountMinted',
+        type: 'uint256',
+      },
+    ],
+    name: 'MintedToTreasury',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'reserve',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+    ],
+    name: 'RebalanceStableBorrowRate',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'reserve',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'repayer',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        indexed: false,
+        internalType: 'bool',
+        name: 'useATokens',
+        type: 'bool',
+      },
+    ],
+    name: 'Repay',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'reserve',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'liquidityRate',
+        type: 'uint256',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'stableBorrowRate',
+        type: 'uint256',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'variableBorrowRate',
+        type: 'uint256',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'liquidityIndex',
+        type: 'uint256',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'variableBorrowIndex',
+        type: 'uint256',
+      },
+    ],
+    name: 'ReserveDataUpdated',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'reserve',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+    ],
+    name: 'ReserveUsedAsCollateralDisabled',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'reserve',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+    ],
+    name: 'ReserveUsedAsCollateralEnabled',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'reserve',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'onBehalfOf',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        indexed: true,
+        internalType: 'uint16',
+        name: 'referralCode',
+        type: 'uint16',
+      },
+    ],
+    name: 'Supply',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'reserve',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'enum DataTypes.InterestRateMode',
+        name: 'interestRateMode',
+        type: 'uint8',
+      },
+    ],
+    name: 'SwapBorrowRateMode',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint8',
+        name: 'categoryId',
+        type: 'uint8',
+      },
+    ],
+    name: 'UserEModeSet',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'reserve',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'to',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+    ],
+    name: 'Withdraw',
+    type: 'event',
+  },
+  {
+    inputs: [],
+    name: 'ADDRESSES_PROVIDER',
+    outputs: [
+      {
+        internalType: 'contract IPoolAddressesProvider',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'BRIDGE_PROTOCOL_FEE',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'FLASHLOAN_PREMIUM_TOTAL',
+    outputs: [
+      {
+        internalType: 'uint128',
+        name: '',
+        type: 'uint128',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'FLASHLOAN_PREMIUM_TO_PROTOCOL',
+    outputs: [
+      {
+        internalType: 'uint128',
+        name: '',
+        type: 'uint128',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'MAX_NUMBER_RESERVES',
+    outputs: [
+      {
+        internalType: 'uint16',
+        name: '',
+        type: 'uint16',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'MAX_STABLE_RATE_BORROW_SIZE_PERCENT',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'POOL_REVISION',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'fee',
+        type: 'uint256',
+      },
+    ],
+    name: 'backUnbacked',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'interestRateMode',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint16',
+        name: 'referralCode',
+        type: 'uint16',
+      },
+      {
+        internalType: 'address',
+        name: 'onBehalfOf',
+        type: 'address',
+      },
+    ],
+    name: 'borrow',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'uint8',
+        name: 'id',
+        type: 'uint8',
+      },
+      {
+        components: [
+          {
+            internalType: 'uint16',
+            name: 'ltv',
+            type: 'uint16',
+          },
+          {
+            internalType: 'uint16',
+            name: 'liquidationThreshold',
+            type: 'uint16',
+          },
+          {
+            internalType: 'uint16',
+            name: 'liquidationBonus',
+            type: 'uint16',
+          },
+          {
+            internalType: 'address',
+            name: 'priceSource',
+            type: 'address',
+          },
+          {
+            internalType: 'string',
+            name: 'label',
+            type: 'string',
+          },
+        ],
+        internalType: 'struct DataTypes.EModeCategory',
+        name: 'category',
+        type: 'tuple',
+      },
+    ],
+    name: 'configureEModeCategory',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'address',
+        name: 'onBehalfOf',
+        type: 'address',
+      },
+      {
+        internalType: 'uint16',
+        name: 'referralCode',
+        type: 'uint16',
+      },
+    ],
+    name: 'deposit',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+    ],
+    name: 'dropReserve',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'from',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'to',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'balanceFromBefore',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'balanceToBefore',
+        type: 'uint256',
+      },
+    ],
+    name: 'finalizeTransfer',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'receiverAddress',
+        type: 'address',
+      },
+      {
+        internalType: 'address[]',
+        name: 'assets',
+        type: 'address[]',
+      },
+      {
+        internalType: 'uint256[]',
+        name: 'amounts',
+        type: 'uint256[]',
+      },
+      {
+        internalType: 'uint256[]',
+        name: 'interestRateModes',
+        type: 'uint256[]',
+      },
+      {
+        internalType: 'address',
+        name: 'onBehalfOf',
+        type: 'address',
+      },
+      {
+        internalType: 'bytes',
+        name: 'params',
+        type: 'bytes',
+      },
+      {
+        internalType: 'uint16',
+        name: 'referralCode',
+        type: 'uint16',
+      },
+    ],
+    name: 'flashLoan',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'receiverAddress',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'bytes',
+        name: 'params',
+        type: 'bytes',
+      },
+      {
+        internalType: 'uint16',
+        name: 'referralCode',
+        type: 'uint16',
+      },
+    ],
+    name: 'flashLoanSimple',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+    ],
+    name: 'getConfiguration',
+    outputs: [
+      {
+        components: [
+          {
+            internalType: 'uint256',
+            name: 'data',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct DataTypes.ReserveConfigurationMap',
+        name: '',
+        type: 'tuple',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'uint8',
+        name: 'id',
+        type: 'uint8',
+      },
+    ],
+    name: 'getEModeCategoryData',
+    outputs: [
+      {
+        components: [
+          {
+            internalType: 'uint16',
+            name: 'ltv',
+            type: 'uint16',
+          },
+          {
+            internalType: 'uint16',
+            name: 'liquidationThreshold',
+            type: 'uint16',
+          },
+          {
+            internalType: 'uint16',
+            name: 'liquidationBonus',
+            type: 'uint16',
+          },
+          {
+            internalType: 'address',
+            name: 'priceSource',
+            type: 'address',
+          },
+          {
+            internalType: 'string',
+            name: 'label',
+            type: 'string',
+          },
+        ],
+        internalType: 'struct DataTypes.EModeCategory',
+        name: '',
+        type: 'tuple',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'uint16',
+        name: 'id',
+        type: 'uint16',
+      },
+    ],
+    name: 'getReserveAddressById',
+    outputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+    ],
+    name: 'getReserveData',
+    outputs: [
+      {
+        components: [
+          {
+            components: [
+              {
+                internalType: 'uint256',
+                name: 'data',
+                type: 'uint256',
+              },
+            ],
+            internalType: 'struct DataTypes.ReserveConfigurationMap',
+            name: 'configuration',
+            type: 'tuple',
+          },
+          {
+            internalType: 'uint128',
+            name: 'liquidityIndex',
+            type: 'uint128',
+          },
+          {
+            internalType: 'uint128',
+            name: 'currentLiquidityRate',
+            type: 'uint128',
+          },
+          {
+            internalType: 'uint128',
+            name: 'variableBorrowIndex',
+            type: 'uint128',
+          },
+          {
+            internalType: 'uint128',
+            name: 'currentVariableBorrowRate',
+            type: 'uint128',
+          },
+          {
+            internalType: 'uint128',
+            name: 'currentStableBorrowRate',
+            type: 'uint128',
+          },
+          {
+            internalType: 'uint40',
+            name: 'lastUpdateTimestamp',
+            type: 'uint40',
+          },
+          {
+            internalType: 'uint16',
+            name: 'id',
+            type: 'uint16',
+          },
+          {
+            internalType: 'address',
+            name: 'aTokenAddress',
+            type: 'address',
+          },
+          {
+            internalType: 'address',
+            name: 'stableDebtTokenAddress',
+            type: 'address',
+          },
+          {
+            internalType: 'address',
+            name: 'variableDebtTokenAddress',
+            type: 'address',
+          },
+          {
+            internalType: 'address',
+            name: 'interestRateStrategyAddress',
+            type: 'address',
+          },
+          {
+            internalType: 'uint128',
+            name: 'accruedToTreasury',
+            type: 'uint128',
+          },
+          {
+            internalType: 'uint128',
+            name: 'unbacked',
+            type: 'uint128',
+          },
+          {
+            internalType: 'uint128',
+            name: 'isolationModeTotalDebt',
+            type: 'uint128',
+          },
+        ],
+        internalType: 'struct DataTypes.ReserveData',
+        name: '',
+        type: 'tuple',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+    ],
+    name: 'getReserveNormalizedIncome',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+    ],
+    name: 'getReserveNormalizedVariableDebt',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'getReservesList',
+    outputs: [
+      {
+        internalType: 'address[]',
+        name: '',
+        type: 'address[]',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+    ],
+    name: 'getUserAccountData',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: 'totalCollateralBase',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'totalDebtBase',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'availableBorrowsBase',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'currentLiquidationThreshold',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'ltv',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'healthFactor',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+    ],
+    name: 'getUserConfiguration',
+    outputs: [
+      {
+        components: [
+          {
+            internalType: 'uint256',
+            name: 'data',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct DataTypes.UserConfigurationMap',
+        name: '',
+        type: 'tuple',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+    ],
+    name: 'getUserEMode',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'aTokenAddress',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'stableDebtAddress',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'variableDebtAddress',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'interestRateStrategyAddress',
+        type: 'address',
+      },
+    ],
+    name: 'initReserve',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'contract IPoolAddressesProvider',
+        name: 'provider',
+        type: 'address',
+      },
+    ],
+    name: 'initialize',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'collateralAsset',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'debtAsset',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'debtToCover',
+        type: 'uint256',
+      },
+      {
+        internalType: 'bool',
+        name: 'receiveAToken',
+        type: 'bool',
+      },
+    ],
+    name: 'liquidationCall',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address[]',
+        name: 'assets',
+        type: 'address[]',
+      },
+    ],
+    name: 'mintToTreasury',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'address',
+        name: 'onBehalfOf',
+        type: 'address',
+      },
+      {
+        internalType: 'uint16',
+        name: 'referralCode',
+        type: 'uint16',
+      },
+    ],
+    name: 'mintUnbacked',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'user',
+        type: 'address',
+      },
+    ],
+    name: 'rebalanceStableBorrowRate',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'interestRateMode',
+        type: 'uint256',
+      },
+      {
+        internalType: 'address',
+        name: 'onBehalfOf',
+        type: 'address',
+      },
+    ],
+    name: 'repay',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'interestRateMode',
+        type: 'uint256',
+      },
+    ],
+    name: 'repayWithATokens',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'interestRateMode',
+        type: 'uint256',
+      },
+      {
+        internalType: 'address',
+        name: 'onBehalfOf',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'deadline',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint8',
+        name: 'permitV',
+        type: 'uint8',
+      },
+      {
+        internalType: 'bytes32',
+        name: 'permitR',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bytes32',
+        name: 'permitS',
+        type: 'bytes32',
+      },
+    ],
+    name: 'repayWithPermit',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'token',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'to',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+    ],
+    name: 'rescueTokens',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+    ],
+    name: 'resetIsolationModeTotalDebt',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        components: [
+          {
+            internalType: 'uint256',
+            name: 'data',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct DataTypes.ReserveConfigurationMap',
+        name: 'configuration',
+        type: 'tuple',
+      },
+    ],
+    name: 'setConfiguration',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'rateStrategyAddress',
+        type: 'address',
+      },
+    ],
+    name: 'setReserveInterestRateStrategyAddress',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'uint8',
+        name: 'categoryId',
+        type: 'uint8',
+      },
+    ],
+    name: 'setUserEMode',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'bool',
+        name: 'useAsCollateral',
+        type: 'bool',
+      },
+    ],
+    name: 'setUserUseReserveAsCollateral',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'address',
+        name: 'onBehalfOf',
+        type: 'address',
+      },
+      {
+        internalType: 'uint16',
+        name: 'referralCode',
+        type: 'uint16',
+      },
+    ],
+    name: 'supply',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'address',
+        name: 'onBehalfOf',
+        type: 'address',
+      },
+      {
+        internalType: 'uint16',
+        name: 'referralCode',
+        type: 'uint16',
+      },
+      {
+        internalType: 'uint256',
+        name: 'deadline',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint8',
+        name: 'permitV',
+        type: 'uint8',
+      },
+      {
+        internalType: 'bytes32',
+        name: 'permitR',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bytes32',
+        name: 'permitS',
+        type: 'bytes32',
+      },
+    ],
+    name: 'supplyWithPermit',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'interestRateMode',
+        type: 'uint256',
+      },
+    ],
+    name: 'swapBorrowRateMode',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'uint256',
+        name: 'protocolFee',
+        type: 'uint256',
+      },
+    ],
+    name: 'updateBridgeProtocolFee',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'uint128',
+        name: 'flashLoanPremiumTotal',
+        type: 'uint128',
+      },
+      {
+        internalType: 'uint128',
+        name: 'flashLoanPremiumToProtocol',
+        type: 'uint128',
+      },
+    ],
+    name: 'updateFlashloanPremiums',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'asset',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'address',
+        name: 'to',
+        type: 'address',
+      },
+    ],
+    name: 'withdraw',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+];
diff --git a/src/utils/contracts/common.ts b/src/utils/contracts/common.ts
new file mode 100644
index 00000000..fb24922d
--- /dev/null
+++ b/src/utils/contracts/common.ts
@@ -0,0 +1,37 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type { Listener } from '@ethersproject/providers';
+import type { Event, EventFilter } from 'ethers';
+
+export interface TypedEvent<TArgsArray extends Array<any> = any, TArgsObject = any> extends Event {
+  args: TArgsArray & TArgsObject;
+}
+
+export interface TypedEventFilter<_TEvent extends TypedEvent> extends EventFilter {}
+
+export interface TypedListener<TEvent extends TypedEvent> {
+  (...listenerArg: [...__TypechainArgsArray<TEvent>, TEvent]): void;
+}
+
+type __TypechainArgsArray<T> = T extends TypedEvent<infer U> ? U : never;
+
+export interface OnEvent<TRes> {
+  <TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>,
+    listener: TypedListener<TEvent>
+  ): TRes;
+  (eventName: string, listener: Listener): TRes;
+}
+
+export type MinEthersFactory<C, ARGS> = {
+  deploy(...a: ARGS[]): Promise<C>;
+};
+
+export type GetContractTypeFromFactory<F> = F extends MinEthersFactory<infer C, any> ? C : never;
+
+export type GetARGsTypeFromFactory<F> = F extends MinEthersFactory<any, any>
+  ? Parameters<F['deploy']>
+  : never;
+
+export type PromiseOrValue<T> = T | Promise<T>;

From b60f519182011f97ac47663e0971f7b61237015d Mon Sep 17 00:00:00 2001
From: Priyam Anand <priyam27.anand@gmail.com>
Date: Tue, 25 Jun 2024 19:41:44 +0530
Subject: [PATCH 2/6] added button for looping and unlooping

---
 .../BorrowAssetsList/BorrowAssetsListItem.tsx |  6 +-
 .../BorrowedPositionsListItem.tsx             | 84 ++++++++++++++++---
 .../SupplyAssetsList/SupplyAssetsListItem.tsx | 36 ++------
 3 files changed, 83 insertions(+), 43 deletions(-)

diff --git a/src/modules/dashboard/lists/BorrowAssetsList/BorrowAssetsListItem.tsx b/src/modules/dashboard/lists/BorrowAssetsList/BorrowAssetsListItem.tsx
index 0d999b26..0632fbbf 100644
--- a/src/modules/dashboard/lists/BorrowAssetsList/BorrowAssetsListItem.tsx
+++ b/src/modules/dashboard/lists/BorrowAssetsList/BorrowAssetsListItem.tsx
@@ -24,11 +24,10 @@ export const BorrowAssetsListItem = ({
   variableBorrowRate,
   vIncentivesData,
   underlyingAsset,
-  isFreezed,
 }: DashboardReserve) => {
   const { openBorrow } = useModalContext();
   const { currentMarket } = useProtocolDataContext();
-  const borrowButtonDisable = isFreezed || Number(availableBorrows) <= 0;
+  // const borrowButtonDisable = isFreezed || Number(availableBorrows) <= 0;
 
   return (
     <ListItemWrapper
@@ -73,7 +72,8 @@ export const BorrowAssetsListItem = ({
 
       <ListButtonsColumn>
         <Button
-          disabled={borrowButtonDisable}
+          disabled={true}
+          // borrowButtonDisable}
           variant="contained"
           onClick={() => openBorrow(underlyingAsset)}
         >
diff --git a/src/modules/dashboard/lists/BorrowedPositionsList/BorrowedPositionsListItem.tsx b/src/modules/dashboard/lists/BorrowedPositionsList/BorrowedPositionsListItem.tsx
index daa7d57b..6c6dde5c 100644
--- a/src/modules/dashboard/lists/BorrowedPositionsList/BorrowedPositionsListItem.tsx
+++ b/src/modules/dashboard/lists/BorrowedPositionsList/BorrowedPositionsListItem.tsx
@@ -1,11 +1,21 @@
 import { InterestRate } from '@aave/contract-helpers';
 import { Trans } from '@lingui/macro';
 import { Button } from '@mui/material';
-import { useAssetCaps } from 'src/hooks/useAssetCaps';
+import { useWeb3React } from '@web3-react/core';
+import { BigNumber, constants, Contract, providers } from 'ethers';
+import { parseEther } from 'ethers/lib/utils';
+import { useRouter } from 'next/router';
+import { useState } from 'react';
 import { useModalContext } from 'src/hooks/useModal';
 import { useProtocolDataContext } from 'src/hooks/useProtocolDataContext';
 import { DashboardReserve } from 'src/utils/dashboardSortUtils';
 
+import { useAppDataContext } from '../../../../hooks/app-data-provider/useAppDataProvider';
+import { useWeb3Context } from '../../../../libs/hooks/useWeb3Context';
+import { marketsData } from '../../../../ui-config/marketsConfig';
+import { ERC20, ERC20ABI } from '../../../../utils/contracts/ERC20';
+import { Leverage, LeverageABI } from '../../../../utils/contracts/Leverage';
+import { availableMarkets } from '../../../../utils/marketsAndNetworksConfig';
 import { SpkAirdropNoteInline } from '../BorrowAssetsList/BorrowAssetsListItem';
 import { ListAPRColumn } from '../ListAPRColumn';
 import { ListButtonsColumn } from '../ListButtonsColumn';
@@ -21,17 +31,58 @@ export const BorrowedPositionsListItem = ({
   borrowRateMode,
   stableBorrowAPY,
 }: DashboardReserve) => {
+  const { reserves } = useAppDataContext();
   const { openBorrow, openRepay } = useModalContext();
   const { currentMarket } = useProtocolDataContext();
-  const { borrowCap } = useAssetCaps();
-  const {
-    isActive,
-    isFrozen,
-    borrowingEnabled,
-    sIncentivesData,
-    vIncentivesData,
-    variableBorrowAPY,
-  } = reserve;
+  const [isUnlooping, setIsUnlooping] = useState(false);
+  const { library: provider } = useWeb3React<providers.Web3Provider>();
+  const { currentAccount } = useWeb3Context();
+  const router = useRouter();
+
+  const { isActive, isFrozen, sIncentivesData, vIncentivesData, variableBorrowAPY } = reserve;
+
+  const handleUnloopingAction = async () => {
+    try {
+      setIsUnlooping(true);
+      const currentMarketData = marketsData[availableMarkets[0]];
+      const signer = provider?.getSigner(currentAccount);
+      const interestRateMode = 2;
+      const leverageInstance = new Contract(
+        currentMarketData.addresses.LEVERAGE!,
+        LeverageABI,
+        signer
+      ) as Leverage;
+      // unlooping;
+      const aTokenAddress = reserves.filter((item) => item.symbol === 'wstXTZ')[0].aTokenAddress;
+      const aTokenInstance = new Contract(aTokenAddress, ERC20ABI, signer) as ERC20;
+
+      const approvalAmt = await aTokenInstance.allowance(
+        currentAccount,
+        currentMarketData.addresses.LEVERAGE!
+      );
+      if (approvalAmt.eq(BigNumber.from('0'))) {
+        const aTokenTx = await aTokenInstance.approve(
+          currentMarketData.addresses.LEVERAGE!,
+          constants.MaxUint256.toString()
+        );
+        await aTokenTx.wait(2);
+        console.log(aTokenTx);
+      }
+
+      const unloop = await leverageInstance.unLoop(
+        BigNumber.from(parseEther('1')),
+        currentAccount,
+        interestRateMode
+      );
+      console.log(unloop);
+      await unloop.wait(2);
+
+      router.reload();
+    } catch (error) {
+      console.error('Error in doing the un looping action', error);
+    }
+    setIsUnlooping(false);
+  };
 
   return (
     <ListItemWrapper
@@ -73,14 +124,23 @@ export const BorrowedPositionsListItem = ({
 
       <ListButtonsColumn>
         <Button
-          disabled={!isActive}
+          disabled={true}
+          // !isActive}
           variant="contained"
           onClick={() => openRepay(reserve.underlyingAsset, borrowRateMode, isFrozen)}
         >
           <Trans>Repay</Trans>
         </Button>
         <Button
-          disabled={!isActive || !borrowingEnabled || isFrozen || borrowCap.isMaxed}
+          disabled={!isActive || isUnlooping}
+          variant="contained"
+          onClick={() => handleUnloopingAction()}
+        >
+          <Trans>Unloop</Trans>
+        </Button>
+        <Button
+          disabled={true}
+          // !isActive || !borrowingEnabled || isFrozen || borrowCap.isMaxed}
           variant="outlined"
           onClick={() => openBorrow(reserve.underlyingAsset)}
         >
diff --git a/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx b/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx
index 2339da78..08e4a618 100644
--- a/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx
+++ b/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx
@@ -3,6 +3,7 @@ import { Button } from '@mui/material';
 import { useWeb3React } from '@web3-react/core';
 import { BigNumber, constants, Contract, providers } from 'ethers';
 import { parseEther } from 'ethers/lib/utils';
+import { useRouter } from 'next/router';
 import { useState } from 'react';
 import { useAssetCaps } from 'src/hooks/useAssetCaps';
 import { useModalContext } from 'src/hooks/useModal';
@@ -51,11 +52,13 @@ export const SupplyAssetsListItem = ({
   const { openSupply, openPSMSwap } = useModalContext();
   const [isLooping, setIsLooping] = useState(false);
 
+  const router = useRouter();
+
   // Hide the asset to prevent it from being supplied if supply cap has been reached
   const { supplyCap: supplyCapUsage } = useAssetCaps();
   if (supplyCapUsage.isMaxed) return null;
 
-  const doLoopingAction = async () => {
+  const handleLoopingAction = async () => {
     try {
       setIsLooping(true);
       const currentMarketData = marketsData[availableMarkets[0]];
@@ -99,33 +102,9 @@ export const SupplyAssetsListItem = ({
         value: parseEther('1'),
       });
 
-      await loopingTxn.wait(1);
       console.log(loopingTxn);
 
-      // unlooping
-      // const aTokenAddress = reserves.filter((item) => item.symbol === 'wstXTZ')[0].aTokenAddress;
-      // const aTokenInstance = new Contract(aTokenAddress, ERC20ABI, signer) as ERC20;
-
-      // const approvalAmt = await aTokenInstance.allowance(
-      //   currentAccount,
-      //   currentMarketData.addresses.LEVERAGE!
-      // );
-      // if (approvalAmt.eq(BigNumber.from('0'))) {
-      //   const aTokenTx = await aTokenInstance.approve(
-      //     currentMarketData.addresses.LEVERAGE!,
-      //     constants.MaxUint256.toString()
-      //   );
-      //   await aTokenTx.wait(2);
-      //   console.log(aTokenTx);
-      // }
-
-      // const unloop = await leverageInstance.unLoop(
-      //   BigNumber.from(parseEther('1')),
-      //   currentAccount,
-      //   interestRateMode
-      // );
-      // await unloop.wait(1);
-      // console.log(unloop);
+      router.reload();
     } catch (error) {
       console.error('Error in doing the looping action', error);
     }
@@ -172,7 +151,8 @@ export const SupplyAssetsListItem = ({
                 background: '#8bc34a',
               },
             })}
-            disabled={!isActive || isFreezed || Number(walletBalance) <= 0}
+            disabled={true}
+            // !isActive || isFreezed || Number(walletBalance) <= 0}
             variant="contained"
             onClick={() => openSupply(underlyingAsset)}
           >
@@ -190,7 +170,7 @@ export const SupplyAssetsListItem = ({
             })}
             disabled={!isActive || isFreezed || Number(walletBalance) <= 0 || isLooping}
             variant="contained"
-            onClick={() => doLoopingAction()}
+            onClick={() => handleLoopingAction()}
           >
             <Trans>Loop</Trans>
           </Button>

From c42c18a0495038c995cde1a08c1a5d4a49405337 Mon Sep 17 00:00:00 2001
From: Priyam Anand <priyam27.anand@gmail.com>
Date: Tue, 25 Jun 2024 22:25:21 +0530
Subject: [PATCH 3/6] added new market configs

---
 src/ui-config/marketsConfig.tsx | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/ui-config/marketsConfig.tsx b/src/ui-config/marketsConfig.tsx
index c16a707c..a56209eb 100644
--- a/src/ui-config/marketsConfig.tsx
+++ b/src/ui-config/marketsConfig.tsx
@@ -70,13 +70,13 @@ export const marketsData: {
       faucet: false,
     },
     addresses: {
-      LENDING_POOL_ADDRESS_PROVIDER: '0x8780b9f46123A151f8325E0bEE5e8B977DEFf1FA'.toLowerCase(),
-      LENDING_POOL: '0xB3a5e66cF7Fd00C14E6DC9f57E4200BDd4d5ba8b',
-      WALLET_BALANCE_PROVIDER: '0xaD66495fBb102Bb5420326C20F92592a1bddf0d9',
-      UI_POOL_DATA_PROVIDER: '0x6A71659daBd47de688d5bD7eb18F7F599900c9a3',
+      LENDING_POOL_ADDRESS_PROVIDER: '0xB58cF2e8BBBE691f27f96eA32F54A21E7F75fD0C'.toLowerCase(),
+      LENDING_POOL: '0x717E0e99E4c71d896804bD2cF0532d3112ffd5D5',
+      WALLET_BALANCE_PROVIDER: '0x6B92955469e184F1eeF5567748f6F12D608bB698',
+      UI_POOL_DATA_PROVIDER: '0x325C2184D59bcB687eb777fd5FbB192fb8dD6CEB',
       UI_INCENTIVE_DATA_PROVIDER: '0x65374686E598ae4AA22E2E4780436C029EEc6E3b',
-      WETH_GATEWAY: '0xD9bf48dde1b08A6e13AA1b6F9E5Ac943898021E3',
-      LEVERAGE: '0x00398eB80CD3090fbCfad86B162d875Ac2AC5035',
+      WETH_GATEWAY: '0xB39537551422D916e6B0013Ef7Dd257D07a17FE3',
+      LEVERAGE: '0xd4864b20bfA721c7201E53E6AF52b1c3498EB5E6',
       WRAPPED_TOKEN: '0xc2ef9495272b43f5257b35a1b6dda78932839871',
     },
     faucetUrl: 'https://faucet.plend.finance/receiveFaucetTokens',

From 426da98840aaafd39d4190c18d6efb416d2fae8b Mon Sep 17 00:00:00 2001
From: Priyam Anand <priyam27.anand@gmail.com>
Date: Wed, 26 Jun 2024 11:46:50 +0530
Subject: [PATCH 4/6] fix: added wait time for txns and loaders

---
 .../BorrowedPositionsListItem.tsx              | 17 ++++++++++-------
 .../SupplyAssetsList/SupplyAssetsListItem.tsx  | 18 ++++++++++--------
 2 files changed, 20 insertions(+), 15 deletions(-)

diff --git a/src/modules/dashboard/lists/BorrowedPositionsList/BorrowedPositionsListItem.tsx b/src/modules/dashboard/lists/BorrowedPositionsList/BorrowedPositionsListItem.tsx
index 6c6dde5c..63af1023 100644
--- a/src/modules/dashboard/lists/BorrowedPositionsList/BorrowedPositionsListItem.tsx
+++ b/src/modules/dashboard/lists/BorrowedPositionsList/BorrowedPositionsListItem.tsx
@@ -1,6 +1,6 @@
 import { InterestRate } from '@aave/contract-helpers';
 import { Trans } from '@lingui/macro';
-import { Button } from '@mui/material';
+import { Button, CircularProgress } from '@mui/material';
 import { useWeb3React } from '@web3-react/core';
 import { BigNumber, constants, Contract, providers } from 'ethers';
 import { parseEther } from 'ethers/lib/utils';
@@ -61,12 +61,10 @@ export const BorrowedPositionsListItem = ({
         currentMarketData.addresses.LEVERAGE!
       );
       if (approvalAmt.eq(BigNumber.from('0'))) {
-        const aTokenTx = await aTokenInstance.approve(
+        await aTokenInstance.approve(
           currentMarketData.addresses.LEVERAGE!,
           constants.MaxUint256.toString()
         );
-        await aTokenTx.wait(2);
-        console.log(aTokenTx);
       }
 
       const unloop = await leverageInstance.unLoop(
@@ -74,8 +72,7 @@ export const BorrowedPositionsListItem = ({
         currentAccount,
         interestRateMode
       );
-      console.log(unloop);
-      await unloop.wait(2);
+      await unloop.wait(1);
 
       router.reload();
     } catch (error) {
@@ -136,7 +133,13 @@ export const BorrowedPositionsListItem = ({
           variant="contained"
           onClick={() => handleUnloopingAction()}
         >
-          <Trans>Unloop</Trans>
+          {isUnlooping ? (
+            <Trans>
+              <CircularProgress sx={{ color: 'white' }} size="1.5rem" />
+            </Trans>
+          ) : (
+            <Trans>Unloop</Trans>
+          )}
         </Button>
         <Button
           disabled={true}
diff --git a/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx b/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx
index 08e4a618..36fd01c1 100644
--- a/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx
+++ b/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx
@@ -1,5 +1,5 @@
 import { Trans } from '@lingui/macro';
-import { Button } from '@mui/material';
+import { Button, CircularProgress } from '@mui/material';
 import { useWeb3React } from '@web3-react/core';
 import { BigNumber, constants, Contract, providers } from 'ethers';
 import { parseEther } from 'ethers/lib/utils';
@@ -85,14 +85,11 @@ export const SupplyAssetsListItem = ({
         currentAccount,
         currentMarketData.addresses.LEVERAGE!
       );
-      console.log('delegation amount ', delegationAmount, delegationAmount.toString());
       if (delegationAmount.eq(BigNumber.from('0'))) {
-        const txn = await debtTokenInstance.approveDelegation(
+        await debtTokenInstance.approveDelegation(
           currentMarketData.addresses.LEVERAGE!,
           constants.MaxUint256.toString()
         );
-        await txn.wait(1);
-        console.log(txn);
       }
 
       const loopCount = 5;
@@ -101,8 +98,7 @@ export const SupplyAssetsListItem = ({
       const loopingTxn = await leverageInstance.loop(loopCount, borrowRatio, interestRateMode, 0, {
         value: parseEther('1'),
       });
-
-      console.log(loopingTxn);
+      await loopingTxn.wait(1);
 
       router.reload();
     } catch (error) {
@@ -172,7 +168,13 @@ export const SupplyAssetsListItem = ({
             variant="contained"
             onClick={() => handleLoopingAction()}
           >
-            <Trans>Loop</Trans>
+            {isLooping ? (
+              <Trans>
+                <CircularProgress sx={{ color: 'white' }} size="1.5rem" />
+              </Trans>
+            ) : (
+              <Trans>Loop</Trans>
+            )}
           </Button>
         )}
         {showSwap && (

From f7a48e6dedc95121b35bdf53aa8a470df7ff1fe3 Mon Sep 17 00:00:00 2001
From: Priyam Anand <priyam27.anand@gmail.com>
Date: Fri, 28 Jun 2024 15:53:25 +0530
Subject: [PATCH 5/6] fix: updated leverge contract address for new bug fixed
 contract

---
 .../BorrowAssetsList/BorrowAssetsListItem.tsx      |  6 +++---
 .../BorrowedPositionsListItem.tsx                  | 14 +++++++++++---
 .../SupplyAssetsList/SupplyAssetsListItem.tsx      |  3 +--
 src/ui-config/marketsConfig.tsx                    |  2 +-
 4 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/src/modules/dashboard/lists/BorrowAssetsList/BorrowAssetsListItem.tsx b/src/modules/dashboard/lists/BorrowAssetsList/BorrowAssetsListItem.tsx
index 0632fbbf..0d999b26 100644
--- a/src/modules/dashboard/lists/BorrowAssetsList/BorrowAssetsListItem.tsx
+++ b/src/modules/dashboard/lists/BorrowAssetsList/BorrowAssetsListItem.tsx
@@ -24,10 +24,11 @@ export const BorrowAssetsListItem = ({
   variableBorrowRate,
   vIncentivesData,
   underlyingAsset,
+  isFreezed,
 }: DashboardReserve) => {
   const { openBorrow } = useModalContext();
   const { currentMarket } = useProtocolDataContext();
-  // const borrowButtonDisable = isFreezed || Number(availableBorrows) <= 0;
+  const borrowButtonDisable = isFreezed || Number(availableBorrows) <= 0;
 
   return (
     <ListItemWrapper
@@ -72,8 +73,7 @@ export const BorrowAssetsListItem = ({
 
       <ListButtonsColumn>
         <Button
-          disabled={true}
-          // borrowButtonDisable}
+          disabled={borrowButtonDisable}
           variant="contained"
           onClick={() => openBorrow(underlyingAsset)}
         >
diff --git a/src/modules/dashboard/lists/BorrowedPositionsList/BorrowedPositionsListItem.tsx b/src/modules/dashboard/lists/BorrowedPositionsList/BorrowedPositionsListItem.tsx
index 63af1023..ee64a58a 100644
--- a/src/modules/dashboard/lists/BorrowedPositionsList/BorrowedPositionsListItem.tsx
+++ b/src/modules/dashboard/lists/BorrowedPositionsList/BorrowedPositionsListItem.tsx
@@ -11,6 +11,7 @@ import { useProtocolDataContext } from 'src/hooks/useProtocolDataContext';
 import { DashboardReserve } from 'src/utils/dashboardSortUtils';
 
 import { useAppDataContext } from '../../../../hooks/app-data-provider/useAppDataProvider';
+import { useAssetCaps } from '../../../../hooks/useAssetCaps';
 import { useWeb3Context } from '../../../../libs/hooks/useWeb3Context';
 import { marketsData } from '../../../../ui-config/marketsConfig';
 import { ERC20, ERC20ABI } from '../../../../utils/contracts/ERC20';
@@ -38,8 +39,16 @@ export const BorrowedPositionsListItem = ({
   const { library: provider } = useWeb3React<providers.Web3Provider>();
   const { currentAccount } = useWeb3Context();
   const router = useRouter();
+  const { borrowCap } = useAssetCaps();
 
-  const { isActive, isFrozen, sIncentivesData, vIncentivesData, variableBorrowAPY } = reserve;
+  const {
+    isActive,
+    isFrozen,
+    sIncentivesData,
+    vIncentivesData,
+    variableBorrowAPY,
+    borrowingEnabled,
+  } = reserve;
 
   const handleUnloopingAction = async () => {
     try {
@@ -142,8 +151,7 @@ export const BorrowedPositionsListItem = ({
           )}
         </Button>
         <Button
-          disabled={true}
-          // !isActive || !borrowingEnabled || isFrozen || borrowCap.isMaxed}
+          disabled={!isActive || !borrowingEnabled || isFrozen || borrowCap.isMaxed}
           variant="outlined"
           onClick={() => openBorrow(reserve.underlyingAsset)}
         >
diff --git a/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx b/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx
index 36fd01c1..19a800cb 100644
--- a/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx
+++ b/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx
@@ -147,8 +147,7 @@ export const SupplyAssetsListItem = ({
                 background: '#8bc34a',
               },
             })}
-            disabled={true}
-            // !isActive || isFreezed || Number(walletBalance) <= 0}
+            disabled={!isActive || isFreezed || Number(walletBalance) <= 0}
             variant="contained"
             onClick={() => openSupply(underlyingAsset)}
           >
diff --git a/src/ui-config/marketsConfig.tsx b/src/ui-config/marketsConfig.tsx
index a56209eb..e4d54dec 100644
--- a/src/ui-config/marketsConfig.tsx
+++ b/src/ui-config/marketsConfig.tsx
@@ -76,7 +76,7 @@ export const marketsData: {
       UI_POOL_DATA_PROVIDER: '0x325C2184D59bcB687eb777fd5FbB192fb8dD6CEB',
       UI_INCENTIVE_DATA_PROVIDER: '0x65374686E598ae4AA22E2E4780436C029EEc6E3b',
       WETH_GATEWAY: '0xB39537551422D916e6B0013Ef7Dd257D07a17FE3',
-      LEVERAGE: '0xd4864b20bfA721c7201E53E6AF52b1c3498EB5E6',
+      LEVERAGE: '0x7f70F6212b1FE38DC51Ca689Db0392783F5c7641',
       WRAPPED_TOKEN: '0xc2ef9495272b43f5257b35a1b6dda78932839871',
     },
     faucetUrl: 'https://faucet.plend.finance/receiveFaucetTokens',

From 39d624c07a102cf08699a0781096027cc00ec984 Mon Sep 17 00:00:00 2001
From: Priyam Anand <priyam27.anand@gmail.com>
Date: Fri, 28 Jun 2024 17:54:09 +0530
Subject: [PATCH 6/6] adjusted the looping to be 4x

---
 .../dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx b/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx
index 19a800cb..fbb36b5c 100644
--- a/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx
+++ b/src/modules/dashboard/lists/SupplyAssetsList/SupplyAssetsListItem.tsx
@@ -93,7 +93,7 @@ export const SupplyAssetsListItem = ({
       }
 
       const loopCount = 5;
-      const borrowRatio = 8000; // 80%
+      const borrowRatio = 8350; // 83.5%
 
       const loopingTxn = await leverageInstance.loop(loopCount, borrowRatio, interestRateMode, 0, {
         value: parseEther('1'),