Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at Arbiscan.io on 2026-02-15
*/

// SPDX-License-Identifier: MIT
pragma solidity >=0.4.16 >=0.5.0 >=0.6.2 ^0.8.0 ^0.8.20;

// lib/aave-v3-core/contracts/protocol/libraries/types/DataTypes.sol

library DataTypes {
  struct ReserveData {
    //stores the reserve configuration
    ReserveConfigurationMap configuration;
    //the liquidity index. Expressed in ray
    uint128 liquidityIndex;
    //the current supply rate. Expressed in ray
    uint128 currentLiquidityRate;
    //variable borrow index. Expressed in ray
    uint128 variableBorrowIndex;
    //the current variable borrow rate. Expressed in ray
    uint128 currentVariableBorrowRate;
    //the current stable borrow rate. Expressed in ray
    uint128 currentStableBorrowRate;
    //timestamp of last update
    uint40 lastUpdateTimestamp;
    //the id of the reserve. Represents the position in the list of the active reserves
    uint16 id;
    //aToken address
    address aTokenAddress;
    //stableDebtToken address
    address stableDebtTokenAddress;
    //variableDebtToken address
    address variableDebtTokenAddress;
    //address of the interest rate strategy
    address interestRateStrategyAddress;
    //the current treasury balance, scaled
    uint128 accruedToTreasury;
    //the outstanding unbacked aTokens minted through the bridging feature
    uint128 unbacked;
    //the outstanding debt borrowed against this asset in isolation mode
    uint128 isolationModeTotalDebt;
  }

  struct ReserveConfigurationMap {
    //bit 0-15: LTV
    //bit 16-31: Liq. threshold
    //bit 32-47: Liq. bonus
    //bit 48-55: Decimals
    //bit 56: reserve is active
    //bit 57: reserve is frozen
    //bit 58: borrowing is enabled
    //bit 59: stable rate borrowing enabled
    //bit 60: asset is paused
    //bit 61: borrowing in isolation mode is enabled
    //bit 62: siloed borrowing enabled
    //bit 63: flashloaning enabled
    //bit 64-79: reserve factor
    //bit 80-115 borrow cap in whole tokens, borrowCap == 0 => no cap
    //bit 116-151 supply cap in whole tokens, supplyCap == 0 => no cap
    //bit 152-167 liquidation protocol fee
    //bit 168-175 eMode category
    //bit 176-211 unbacked mint cap in whole tokens, unbackedMintCap == 0 => minting disabled
    //bit 212-251 debt ceiling for isolation mode with (ReserveConfiguration::DEBT_CEILING_DECIMALS) decimals
    //bit 252-255 unused

    uint256 data;
  }

  struct UserConfigurationMap {
    /**
     * @dev Bitmap of the users collaterals and borrows. It is divided in pairs of bits, one pair per asset.
     * The first bit indicates if an asset is used as collateral by the user, the second whether an
     * asset is borrowed by the user.
     */
    uint256 data;
  }

  struct EModeCategory {
    // each eMode category has a custom ltv and liquidation threshold
    uint16 ltv;
    uint16 liquidationThreshold;
    uint16 liquidationBonus;
    // each eMode category may or may not have a custom oracle to override the individual assets price oracles
    address priceSource;
    string label;
  }

  enum InterestRateMode {NONE, STABLE, VARIABLE}

  struct ReserveCache {
    uint256 currScaledVariableDebt;
    uint256 nextScaledVariableDebt;
    uint256 currPrincipalStableDebt;
    uint256 currAvgStableBorrowRate;
    uint256 currTotalStableDebt;
    uint256 nextAvgStableBorrowRate;
    uint256 nextTotalStableDebt;
    uint256 currLiquidityIndex;
    uint256 nextLiquidityIndex;
    uint256 currVariableBorrowIndex;
    uint256 nextVariableBorrowIndex;
    uint256 currLiquidityRate;
    uint256 currVariableBorrowRate;
    uint256 reserveFactor;
    ReserveConfigurationMap reserveConfiguration;
    address aTokenAddress;
    address stableDebtTokenAddress;
    address variableDebtTokenAddress;
    uint40 reserveLastUpdateTimestamp;
    uint40 stableDebtLastUpdateTimestamp;
  }

  struct ExecuteLiquidationCallParams {
    uint256 reservesCount;
    uint256 debtToCover;
    address collateralAsset;
    address debtAsset;
    address user;
    bool receiveAToken;
    address priceOracle;
    uint8 userEModeCategory;
    address priceOracleSentinel;
  }

  struct ExecuteSupplyParams {
    address asset;
    uint256 amount;
    address onBehalfOf;
    uint16 referralCode;
  }

  struct ExecuteBorrowParams {
    address asset;
    address user;
    address onBehalfOf;
    uint256 amount;
    InterestRateMode interestRateMode;
    uint16 referralCode;
    bool releaseUnderlying;
    uint256 maxStableRateBorrowSizePercent;
    uint256 reservesCount;
    address oracle;
    uint8 userEModeCategory;
    address priceOracleSentinel;
  }

  struct ExecuteRepayParams {
    address asset;
    uint256 amount;
    InterestRateMode interestRateMode;
    address onBehalfOf;
    bool useATokens;
  }

  struct ExecuteWithdrawParams {
    address asset;
    uint256 amount;
    address to;
    uint256 reservesCount;
    address oracle;
    uint8 userEModeCategory;
  }

  struct ExecuteSetUserEModeParams {
    uint256 reservesCount;
    address oracle;
    uint8 categoryId;
  }

  struct FinalizeTransferParams {
    address asset;
    address from;
    address to;
    uint256 amount;
    uint256 balanceFromBefore;
    uint256 balanceToBefore;
    uint256 reservesCount;
    address oracle;
    uint8 fromEModeCategory;
  }

  struct FlashloanParams {
    address receiverAddress;
    address[] assets;
    uint256[] amounts;
    uint256[] interestRateModes;
    address onBehalfOf;
    bytes params;
    uint16 referralCode;
    uint256 flashLoanPremiumToProtocol;
    uint256 flashLoanPremiumTotal;
    uint256 maxStableRateBorrowSizePercent;
    uint256 reservesCount;
    address addressesProvider;
    uint8 userEModeCategory;
    bool isAuthorizedFlashBorrower;
  }

  struct FlashloanSimpleParams {
    address receiverAddress;
    address asset;
    uint256 amount;
    bytes params;
    uint16 referralCode;
    uint256 flashLoanPremiumToProtocol;
    uint256 flashLoanPremiumTotal;
  }

  struct FlashLoanRepaymentParams {
    uint256 amount;
    uint256 totalPremium;
    uint256 flashLoanPremiumToProtocol;
    address asset;
    address receiverAddress;
    uint16 referralCode;
  }

  struct CalculateUserAccountDataParams {
    UserConfigurationMap userConfig;
    uint256 reservesCount;
    address user;
    address oracle;
    uint8 userEModeCategory;
  }

  struct ValidateBorrowParams {
    ReserveCache reserveCache;
    UserConfigurationMap userConfig;
    address asset;
    address userAddress;
    uint256 amount;
    InterestRateMode interestRateMode;
    uint256 maxStableLoanPercent;
    uint256 reservesCount;
    address oracle;
    uint8 userEModeCategory;
    address priceOracleSentinel;
    bool isolationModeActive;
    address isolationModeCollateralAddress;
    uint256 isolationModeDebtCeiling;
  }

  struct ValidateLiquidationCallParams {
    ReserveCache debtReserveCache;
    uint256 totalDebt;
    uint256 healthFactor;
    address priceOracleSentinel;
  }

  struct CalculateInterestRatesParams {
    uint256 unbacked;
    uint256 liquidityAdded;
    uint256 liquidityTaken;
    uint256 totalStableDebt;
    uint256 totalVariableDebt;
    uint256 averageStableBorrowRate;
    uint256 reserveFactor;
    address reserve;
    address aToken;
  }

  struct InitReserveParams {
    address asset;
    address aTokenAddress;
    address stableDebtAddress;
    address variableDebtAddress;
    address interestRateStrategyAddress;
    uint16 reservesCount;
    uint16 maxNumberReserves;
  }
}

// lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol

// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol

// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// lib/aave-v3-core/contracts/interfaces/IPoolAddressesProvider.sol

/**
 * @title IPoolAddressesProvider
 * @author Aave
 * @notice Defines the basic interface for a Pool Addresses Provider.
 */
interface IPoolAddressesProvider {
  /**
   * @dev Emitted when the market identifier is updated.
   * @param oldMarketId The old id of the market
   * @param newMarketId The new id of the market
   */
  event MarketIdSet(string indexed oldMarketId, string indexed newMarketId);

  /**
   * @dev Emitted when the pool is updated.
   * @param oldAddress The old address of the Pool
   * @param newAddress The new address of the Pool
   */
  event PoolUpdated(address indexed oldAddress, address indexed newAddress);

  /**
   * @dev Emitted when the pool configurator is updated.
   * @param oldAddress The old address of the PoolConfigurator
   * @param newAddress The new address of the PoolConfigurator
   */
  event PoolConfiguratorUpdated(address indexed oldAddress, address indexed newAddress);

  /**
   * @dev Emitted when the price oracle is updated.
   * @param oldAddress The old address of the PriceOracle
   * @param newAddress The new address of the PriceOracle
   */
  event PriceOracleUpdated(address indexed oldAddress, address indexed newAddress);

  /**
   * @dev Emitted when the ACL manager is updated.
   * @param oldAddress The old address of the ACLManager
   * @param newAddress The new address of the ACLManager
   */
  event ACLManagerUpdated(address indexed oldAddress, address indexed newAddress);

  /**
   * @dev Emitted when the ACL admin is updated.
   * @param oldAddress The old address of the ACLAdmin
   * @param newAddress The new address of the ACLAdmin
   */
  event ACLAdminUpdated(address indexed oldAddress, address indexed newAddress);

  /**
   * @dev Emitted when the price oracle sentinel is updated.
   * @param oldAddress The old address of the PriceOracleSentinel
   * @param newAddress The new address of the PriceOracleSentinel
   */
  event PriceOracleSentinelUpdated(address indexed oldAddress, address indexed newAddress);

  /**
   * @dev Emitted when the pool data provider is updated.
   * @param oldAddress The old address of the PoolDataProvider
   * @param newAddress The new address of the PoolDataProvider
   */
  event PoolDataProviderUpdated(address indexed oldAddress, address indexed newAddress);

  /**
   * @dev Emitted when a new proxy is created.
   * @param id The identifier of the proxy
   * @param proxyAddress The address of the created proxy contract
   * @param implementationAddress The address of the implementation contract
   */
  event ProxyCreated(
    bytes32 indexed id,
    address indexed proxyAddress,
    address indexed implementationAddress
  );

  /**
   * @dev Emitted when a new non-proxied contract address is registered.
   * @param id The identifier of the contract
   * @param oldAddress The address of the old contract
   * @param newAddress The address of the new contract
   */
  event AddressSet(bytes32 indexed id, address indexed oldAddress, address indexed newAddress);

  /**
   * @dev Emitted when the implementation of the proxy registered with id is updated
   * @param id The identifier of the contract
   * @param proxyAddress The address of the proxy contract
   * @param oldImplementationAddress The address of the old implementation contract
   * @param newImplementationAddress The address of the new implementation contract
   */
  event AddressSetAsProxy(
    bytes32 indexed id,
    address indexed proxyAddress,
    address oldImplementationAddress,
    address indexed newImplementationAddress
  );

  /**
   * @notice Returns the id of the Aave market to which this contract points to.
   * @return The market id
   */
  function getMarketId() external view returns (string memory);

  /**
   * @notice Associates an id with a specific PoolAddressesProvider.
   * @dev This can be used to create an onchain registry of PoolAddressesProviders to
   * identify and validate multiple Aave markets.
   * @param newMarketId The market id
   */
  function setMarketId(string calldata newMarketId) external;

  /**
   * @notice Returns an address by its identifier.
   * @dev The returned address might be an EOA or a contract, potentially proxied
   * @dev It returns ZERO if there is no registered address with the given id
   * @param id The id
   * @return The address of the registered for the specified id
   */
  function getAddress(bytes32 id) external view returns (address);

  /**
   * @notice General function to update the implementation of a proxy registered with
   * certain `id`. If there is no proxy registered, it will instantiate one and
   * set as implementation the `newImplementationAddress`.
   * @dev IMPORTANT Use this function carefully, only for ids that don't have an explicit
   * setter function, in order to avoid unexpected consequences
   * @param id The id
   * @param newImplementationAddress The address of the new implementation
   */
  function setAddressAsProxy(bytes32 id, address newImplementationAddress) external;

  /**
   * @notice Sets an address for an id replacing the address saved in the addresses map.
   * @dev IMPORTANT Use this function carefully, as it will do a hard replacement
   * @param id The id
   * @param newAddress The address to set
   */
  function setAddress(bytes32 id, address newAddress) external;

  /**
   * @notice Returns the address of the Pool proxy.
   * @return The Pool proxy address
   */
  function getPool() external view returns (address);

  /**
   * @notice Updates the implementation of the Pool, or creates a proxy
   * setting the new `pool` implementation when the function is called for the first time.
   * @param newPoolImpl The new Pool implementation
   */
  function setPoolImpl(address newPoolImpl) external;

  /**
   * @notice Returns the address of the PoolConfigurator proxy.
   * @return The PoolConfigurator proxy address
   */
  function getPoolConfigurator() external view returns (address);

  /**
   * @notice Updates the implementation of the PoolConfigurator, or creates a proxy
   * setting the new `PoolConfigurator` implementation when the function is called for the first time.
   * @param newPoolConfiguratorImpl The new PoolConfigurator implementation
   */
  function setPoolConfiguratorImpl(address newPoolConfiguratorImpl) external;

  /**
   * @notice Returns the address of the price oracle.
   * @return The address of the PriceOracle
   */
  function getPriceOracle() external view returns (address);

  /**
   * @notice Updates the address of the price oracle.
   * @param newPriceOracle The address of the new PriceOracle
   */
  function setPriceOracle(address newPriceOracle) external;

  /**
   * @notice Returns the address of the ACL manager.
   * @return The address of the ACLManager
   */
  function getACLManager() external view returns (address);

  /**
   * @notice Updates the address of the ACL manager.
   * @param newAclManager The address of the new ACLManager
   */
  function setACLManager(address newAclManager) external;

  /**
   * @notice Returns the address of the ACL admin.
   * @return The address of the ACL admin
   */
  function getACLAdmin() external view returns (address);

  /**
   * @notice Updates the address of the ACL admin.
   * @param newAclAdmin The address of the new ACL admin
   */
  function setACLAdmin(address newAclAdmin) external;

  /**
   * @notice Returns the address of the price oracle sentinel.
   * @return The address of the PriceOracleSentinel
   */
  function getPriceOracleSentinel() external view returns (address);

  /**
   * @notice Updates the address of the price oracle sentinel.
   * @param newPriceOracleSentinel The address of the new PriceOracleSentinel
   */
  function setPriceOracleSentinel(address newPriceOracleSentinel) external;

  /**
   * @notice Returns the address of the data provider.
   * @return The address of the DataProvider
   */
  function getPoolDataProvider() external view returns (address);

  /**
   * @notice Updates the address of the data provider.
   * @param newDataProvider The address of the new DataProvider
   */
  function setPoolDataProvider(address newDataProvider) external;
}

// lib/v3-core/contracts/interfaces/callback/IUniswapV3FlashCallback.sol

/// @title Callback for IUniswapV3PoolActions#flash
/// @notice Any contract that calls IUniswapV3PoolActions#flash must implement this interface
interface IUniswapV3FlashCallback {
    /// @notice Called to `msg.sender` after transferring to the recipient from IUniswapV3Pool#flash.
    /// @dev In the implementation you must repay the pool the tokens sent by flash plus the computed fee amounts.
    /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
    /// @param fee0 The fee amount in token0 due to the pool by the end of the flash
    /// @param fee1 The fee amount in token1 due to the pool by the end of the flash
    /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#flash call
    function uniswapV3FlashCallback(
        uint256 fee0,
        uint256 fee1,
        bytes calldata data
    ) external;
}

// lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol

// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)

// lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol

// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)

// lib/aave-v3-core/contracts/interfaces/IPool.sol

/**
 * @title IPool
 * @author Aave
 * @notice Defines the basic interface for an Aave Pool.
 */
interface IPool {
  /**
   * @dev Emitted on mintUnbacked()
   * @param reserve The address of the underlying asset of the reserve
   * @param user The address initiating the supply
   * @param onBehalfOf The beneficiary of the supplied assets, receiving the aTokens
   * @param amount The amount of supplied assets
   * @param referralCode The referral code used
   */
  event MintUnbacked(
    address indexed reserve,
    address user,
    address indexed onBehalfOf,
    uint256 amount,
    uint16 indexed referralCode
  );

  /**
   * @dev Emitted on backUnbacked()
   * @param reserve The address of the underlying asset of the reserve
   * @param backer The address paying for the backing
   * @param amount The amount added as backing
   * @param fee The amount paid in fees
   */
  event BackUnbacked(address indexed reserve, address indexed backer, uint256 amount, uint256 fee);

  /**
   * @dev Emitted on supply()
   * @param reserve The address of the underlying asset of the reserve
   * @param user The address initiating the supply
   * @param onBehalfOf The beneficiary of the supply, receiving the aTokens
   * @param amount The amount supplied
   * @param referralCode The referral code used
   */
  event Supply(
    address indexed reserve,
    address user,
    address indexed onBehalfOf,
    uint256 amount,
    uint16 indexed referralCode
  );

  /**
   * @dev Emitted on withdraw()
   * @param reserve The address of the underlying asset being withdrawn
   * @param user The address initiating the withdrawal, owner of aTokens
   * @param to The address that will receive the underlying
   * @param amount The amount to be withdrawn
   */
  event Withdraw(address indexed reserve, address indexed user, address indexed to, uint256 amount);

  /**
   * @dev Emitted on borrow() and flashLoan() when debt needs to be opened
   * @param reserve The address of the underlying asset being borrowed
   * @param user The address of the user initiating the borrow(), receiving the funds on borrow() or just
   * initiator of the transaction on flashLoan()
   * @param onBehalfOf The address that will be getting the debt
   * @param amount The amount borrowed out
   * @param interestRateMode The rate mode: 1 for Stable, 2 for Variable
   * @param borrowRate The numeric rate at which the user has borrowed, expressed in ray
   * @param referralCode The referral code used
   */
  event Borrow(
    address indexed reserve,
    address user,
    address indexed onBehalfOf,
    uint256 amount,
    DataTypes.InterestRateMode interestRateMode,
    uint256 borrowRate,
    uint16 indexed referralCode
  );

  /**
   * @dev Emitted on repay()
   * @param reserve The address of the underlying asset of the reserve
   * @param user The beneficiary of the repayment, getting his debt reduced
   * @param repayer The address of the user initiating the repay(), providing the funds
   * @param amount The amount repaid
   * @param useATokens True if the repayment is done using aTokens, `false` if done with underlying asset directly
   */
  event Repay(
    address indexed reserve,
    address indexed user,
    address indexed repayer,
    uint256 amount,
    bool useATokens
  );

  /**
   * @dev Emitted on swapBorrowRateMode()
   * @param reserve The address of the underlying asset of the reserve
   * @param user The address of the user swapping his rate mode
   * @param interestRateMode The current interest rate mode of the position being swapped: 1 for Stable, 2 for Variable
   */
  event SwapBorrowRateMode(
    address indexed reserve,
    address indexed user,
    DataTypes.InterestRateMode interestRateMode
  );

  /**
   * @dev Emitted on borrow(), repay() and liquidationCall() when using isolated assets
   * @param asset The address of the underlying asset of the reserve
   * @param totalDebt The total isolation mode debt for the reserve
   */
  event IsolationModeTotalDebtUpdated(address indexed asset, uint256 totalDebt);

  /**
   * @dev Emitted when the user selects a certain asset category for eMode
   * @param user The address of the user
   * @param categoryId The category id
   */
  event UserEModeSet(address indexed user, uint8 categoryId);

  /**
   * @dev Emitted on setUserUseReserveAsCollateral()
   * @param reserve The address of the underlying asset of the reserve
   * @param user The address of the user enabling the usage as collateral
   */
  event ReserveUsedAsCollateralEnabled(address indexed reserve, address indexed user);

  /**
   * @dev Emitted on setUserUseReserveAsCollateral()
   * @param reserve The address of the underlying asset of the reserve
   * @param user The address of the user enabling the usage as collateral
   */
  event ReserveUsedAsCollateralDisabled(address indexed reserve, address indexed user);

  /**
   * @dev Emitted on rebalanceStableBorrowRate()
   * @param reserve The address of the underlying asset of the reserve
   * @param user The address of the user for which the rebalance has been executed
   */
  event RebalanceStableBorrowRate(address indexed reserve, address indexed user);

  /**
   * @dev Emitted on flashLoan()
   * @param target The address of the flash loan receiver contract
   * @param initiator The address initiating the flash loan
   * @param asset The address of the asset being flash borrowed
   * @param amount The amount flash borrowed
   * @param interestRateMode The flashloan mode: 0 for regular flashloan, 1 for Stable debt, 2 for Variable debt
   * @param premium The fee flash borrowed
   * @param referralCode The referral code used
   */
  event FlashLoan(
    address indexed target,
    address initiator,
    address indexed asset,
    uint256 amount,
    DataTypes.InterestRateMode interestRateMode,
    uint256 premium,
    uint16 indexed referralCode
  );

  /**
   * @dev Emitted when a borrower is liquidated.
   * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
   * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
   * @param user The address of the borrower getting liquidated
   * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
   * @param liquidatedCollateralAmount The amount of collateral received by the liquidator
   * @param liquidator The address of the liquidator
   * @param receiveAToken True if the liquidators wants to receive the collateral aTokens, `false` if he wants
   * to receive the underlying collateral asset directly
   */
  event LiquidationCall(
    address indexed collateralAsset,
    address indexed debtAsset,
    address indexed user,
    uint256 debtToCover,
    uint256 liquidatedCollateralAmount,
    address liquidator,
    bool receiveAToken
  );

  /**
   * @dev Emitted when the state of a reserve is updated.
   * @param reserve The address of the underlying asset of the reserve
   * @param liquidityRate The next liquidity rate
   * @param stableBorrowRate The next stable borrow rate
   * @param variableBorrowRate The next variable borrow rate
   * @param liquidityIndex The next liquidity index
   * @param variableBorrowIndex The next variable borrow index
   */
  event ReserveDataUpdated(
    address indexed reserve,
    uint256 liquidityRate,
    uint256 stableBorrowRate,
    uint256 variableBorrowRate,
    uint256 liquidityIndex,
    uint256 variableBorrowIndex
  );

  /**
   * @dev Emitted when the protocol treasury receives minted aTokens from the accrued interest.
   * @param reserve The address of the reserve
   * @param amountMinted The amount minted to the treasury
   */
  event MintedToTreasury(address indexed reserve, uint256 amountMinted);

  /**
   * @notice Mints an `amount` of aTokens to the `onBehalfOf`
   * @param asset The address of the underlying asset to mint
   * @param amount The amount to mint
   * @param onBehalfOf The address that will receive the aTokens
   * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
   *   0 if the action is executed directly by the user, without any middle-man
   */
  function mintUnbacked(
    address asset,
    uint256 amount,
    address onBehalfOf,
    uint16 referralCode
  ) external;

  /**
   * @notice Back the current unbacked underlying with `amount` and pay `fee`.
   * @param asset The address of the underlying asset to back
   * @param amount The amount to back
   * @param fee The amount paid in fees
   * @return The backed amount
   */
  function backUnbacked(address asset, uint256 amount, uint256 fee) external returns (uint256);

  /**
   * @notice Supplies an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
   * - E.g. User supplies 100 USDC and gets in return 100 aUSDC
   * @param asset The address of the underlying asset to supply
   * @param amount The amount to be supplied
   * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
   *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
   *   is a different wallet
   * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
   *   0 if the action is executed directly by the user, without any middle-man
   */
  function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;

  /**
   * @notice Supply with transfer approval of asset to be supplied done via permit function
   * see: https://eips.ethereum.org/EIPS/eip-2612 and https://eips.ethereum.org/EIPS/eip-713
   * @param asset The address of the underlying asset to supply
   * @param amount The amount to be supplied
   * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
   *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
   *   is a different wallet
   * @param deadline The deadline timestamp that the permit is valid
   * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
   *   0 if the action is executed directly by the user, without any middle-man
   * @param permitV The V parameter of ERC712 permit sig
   * @param permitR The R parameter of ERC712 permit sig
   * @param permitS The S parameter of ERC712 permit sig
   */
  function supplyWithPermit(
    address asset,
    uint256 amount,
    address onBehalfOf,
    uint16 referralCode,
    uint256 deadline,
    uint8 permitV,
    bytes32 permitR,
    bytes32 permitS
  ) external;

  /**
   * @notice Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
   * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
   * @param asset The address of the underlying asset to withdraw
   * @param amount The underlying amount to be withdrawn
   *   - Send the value type(uint256).max in order to withdraw the whole aToken balance
   * @param to The address that will receive the underlying, same as msg.sender if the user
   *   wants to receive it on his own wallet, or a different address if the beneficiary is a
   *   different wallet
   * @return The final amount withdrawn
   */
  function withdraw(address asset, uint256 amount, address to) external returns (uint256);

  /**
   * @notice Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
   * already supplied enough collateral, or he was given enough allowance by a credit delegator on the
   * corresponding debt token (StableDebtToken or VariableDebtToken)
   * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
   *   and 100 stable/variable debt tokens, depending on the `interestRateMode`
   * @param asset The address of the underlying asset to borrow
   * @param amount The amount to be borrowed
   * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
   * @param referralCode The code used to register the integrator originating the operation, for potential rewards.
   *   0 if the action is executed directly by the user, without any middle-man
   * @param onBehalfOf The address of the user who will receive the debt. Should be the address of the borrower itself
   * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
   * if he has been given credit delegation allowance
   */
  function borrow(
    address asset,
    uint256 amount,
    uint256 interestRateMode,
    uint16 referralCode,
    address onBehalfOf
  ) external;

  /**
   * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
   * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
   * @param asset The address of the borrowed underlying asset previously borrowed
   * @param amount The amount to repay
   * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
   * @param interestRateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
   * @param onBehalfOf The address of the user who will get his debt reduced/removed. Should be the address of the
   * user calling the function if he wants to reduce/remove his own debt, or the address of any other
   * other borrower whose debt should be removed
   * @return The final amount repaid
   */
  function repay(
    address asset,
    uint256 amount,
    uint256 interestRateMode,
    address onBehalfOf
  ) external returns (uint256);

  /**
   * @notice Repay with transfer approval of asset to be repaid done via permit function
   * see: https://eips.ethereum.org/EIPS/eip-2612 and https://eips.ethereum.org/EIPS/eip-713
   * @param asset The address of the borrowed underlying asset previously borrowed
   * @param amount The amount to repay
   * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
   * @param interestRateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
   * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
   * user calling the function if he wants to reduce/remove his own debt, or the address of any other
   * other borrower whose debt should be removed
   * @param deadline The deadline timestamp that the permit is valid
   * @param permitV The V parameter of ERC712 permit sig
   * @param permitR The R parameter of ERC712 permit sig
   * @param permitS The S parameter of ERC712 permit sig
   * @return The final amount repaid
   */
  function repayWithPermit(
    address asset,
    uint256 amount,
    uint256 interestRateMode,
    address onBehalfOf,
    uint256 deadline,
    uint8 permitV,
    bytes32 permitR,
    bytes32 permitS
  ) external returns (uint256);

  /**
   * @notice Repays a borrowed `amount` on a specific reserve using the reserve aTokens, burning the
   * equivalent debt tokens
   * - E.g. User repays 100 USDC using 100 aUSDC, burning 100 variable/stable debt tokens
   * @dev  Passing uint256.max as amount will clean up any residual aToken dust balance, if the user aToken
   * balance is not enough to cover the whole debt
   * @param asset The address of the borrowed underlying asset previously borrowed
   * @param amount The amount to repay
   * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
   * @param interestRateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
   * @return The final amount repaid
   */
  function repayWithATokens(
    address asset,
    uint256 amount,
    uint256 interestRateMode
  ) external returns (uint256);

  /**
   * @notice Allows a borrower to swap his debt between stable and variable mode, or vice versa
   * @param asset The address of the underlying asset borrowed
   * @param interestRateMode The current interest rate mode of the position being swapped: 1 for Stable, 2 for Variable
   */
  function swapBorrowRateMode(address asset, uint256 interestRateMode) external;

  /**
   * @notice Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
   * - Users can be rebalanced if the following conditions are satisfied:
   *     1. Usage ratio is above 95%
   *     2. the current supply APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too
   *        much has been borrowed at a stable rate and suppliers are not earning enough
   * @param asset The address of the underlying asset borrowed
   * @param user The address of the user to be rebalanced
   */
  function rebalanceStableBorrowRate(address asset, address user) external;

  /**
   * @notice Allows suppliers to enable/disable a specific supplied asset as collateral
   * @param asset The address of the underlying asset supplied
   * @param useAsCollateral True if the user wants to use the supply as collateral, false otherwise
   */
  function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external;

  /**
   * @notice Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
   * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
   *   a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
   * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
   * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
   * @param user The address of the borrower getting liquidated
   * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
   * @param receiveAToken True if the liquidators wants to receive the collateral aTokens, `false` if he wants
   * to receive the underlying collateral asset directly
   */
  function liquidationCall(
    address collateralAsset,
    address debtAsset,
    address user,
    uint256 debtToCover,
    bool receiveAToken
  ) external;

  /**
   * @notice Allows smartcontracts to access the liquidity of the pool within one transaction,
   * as long as the amount taken plus a fee is returned.
   * @dev IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept
   * into consideration. For further details please visit https://docs.aave.com/developers/
   * @param receiverAddress The address of the contract receiving the funds, implementing IFlashLoanReceiver interface
   * @param assets The addresses of the assets being flash-borrowed
   * @param amounts The amounts of the assets being flash-borrowed
   * @param interestRateModes Types of the debt to open if the flash loan is not returned:
   *   0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
   *   1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
   *   2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
   * @param onBehalfOf The address  that will receive the debt in the case of using on `modes` 1 or 2
   * @param params Variadic packed params to pass to the receiver as extra information
   * @param referralCode The code used to register the integrator originating the operation, for potential rewards.
   *   0 if the action is executed directly by the user, without any middle-man
   */
  function flashLoan(
    address receiverAddress,
    address[] calldata assets,
    uint256[] calldata amounts,
    uint256[] calldata interestRateModes,
    address onBehalfOf,
    bytes calldata params,
    uint16 referralCode
  ) external;

  /**
   * @notice Allows smartcontracts to access the liquidity of the pool within one transaction,
   * as long as the amount taken plus a fee is returned.
   * @dev IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept
   * into consideration. For further details please visit https://docs.aave.com/developers/
   * @param receiverAddress The address of the contract receiving the funds, implementing IFlashLoanSimpleReceiver interface
   * @param asset The address of the asset being flash-borrowed
   * @param amount The amount of the asset being flash-borrowed
   * @param params Variadic packed params to pass to the receiver as extra information
   * @param referralCode The code used to register the integrator originating the operation, for potential rewards.
   *   0 if the action is executed directly by the user, without any middle-man
   */
  function flashLoanSimple(
    address receiverAddress,
    address asset,
    uint256 amount,
    bytes calldata params,
    uint16 referralCode
  ) external;

  /**
   * @notice Returns the user account data across all the reserves
   * @param user The address of the user
   * @return totalCollateralBase The total collateral of the user in the base currency used by the price feed
   * @return totalDebtBase The total debt of the user in the base currency used by the price feed
   * @return availableBorrowsBase The borrowing power left of the user in the base currency used by the price feed
   * @return currentLiquidationThreshold The liquidation threshold of the user
   * @return ltv The loan to value of The user
   * @return healthFactor The current health factor of the user
   */
  function getUserAccountData(
    address user
  )
    external
    view
    returns (
      uint256 totalCollateralBase,
      uint256 totalDebtBase,
      uint256 availableBorrowsBase,
      uint256 currentLiquidationThreshold,
      uint256 ltv,
      uint256 healthFactor
    );

  /**
   * @notice Initializes a reserve, activating it, assigning an aToken and debt tokens and an
   * interest rate strategy
   * @dev Only callable by the PoolConfigurator contract
   * @param asset The address of the underlying asset of the reserve
   * @param aTokenAddress The address of the aToken that will be assigned to the reserve
   * @param stableDebtAddress The address of the StableDebtToken that will be assigned to the reserve
   * @param variableDebtAddress The address of the VariableDebtToken that will be assigned to the reserve
   * @param interestRateStrategyAddress The address of the interest rate strategy contract
   */
  function initReserve(
    address asset,
    address aTokenAddress,
    address stableDebtAddress,
    address variableDebtAddress,
    address interestRateStrategyAddress
  ) external;

  /**
   * @notice Drop a reserve
   * @dev Only callable by the PoolConfigurator contract
   * @param asset The address of the underlying asset of the reserve
   */
  function dropReserve(address asset) external;

  /**
   * @notice Updates the address of the interest rate strategy contract
   * @dev Only callable by the PoolConfigurator contract
   * @param asset The address of the underlying asset of the reserve
   * @param rateStrategyAddress The address of the interest rate strategy contract
   */
  function setReserveInterestRateStrategyAddress(
    address asset,
    address rateStrategyAddress
  ) external;

  /**
   * @notice Sets the configuration bitmap of the reserve as a whole
   * @dev Only callable by the PoolConfigurator contract
   * @param asset The address of the underlying asset of the reserve
   * @param configuration The new configuration bitmap
   */
  function setConfiguration(
    address asset,
    DataTypes.ReserveConfigurationMap calldata configuration
  ) external;

  /**
   * @notice Returns the configuration of the reserve
   * @param asset The address of the underlying asset of the reserve
   * @return The configuration of the reserve
   */
  function getConfiguration(
    address asset
  ) external view returns (DataTypes.ReserveConfigurationMap memory);

  /**
   * @notice Returns the configuration of the user across all the reserves
   * @param user The user address
   * @return The configuration of the user
   */
  function getUserConfiguration(
    address user
  ) external view returns (DataTypes.UserConfigurationMap memory);

  /**
   * @notice Returns the normalized income of the reserve
   * @param asset The address of the underlying asset of the reserve
   * @return The reserve's normalized income
   */
  function getReserveNormalizedIncome(address asset) external view returns (uint256);

  /**
   * @notice Returns the normalized variable debt per unit of asset
   * @dev WARNING: This function is intended to be used primarily by the protocol itself to get a
   * "dynamic" variable index based on time, current stored index and virtual rate at the current
   * moment (approx. a borrower would get if opening a position). This means that is always used in
   * combination with variable debt supply/balances.
   * If using this function externally, consider that is possible to have an increasing normalized
   * variable debt that is not equivalent to how the variable debt index would be updated in storage
   * (e.g. only updates with non-zero variable debt supply)
   * @param asset The address of the underlying asset of the reserve
   * @return The reserve normalized variable debt
   */
  function getReserveNormalizedVariableDebt(address asset) external view returns (uint256);

  /**
   * @notice Returns the state and configuration of the reserve
   * @param asset The address of the underlying asset of the reserve
   * @return The state and configuration data of the reserve
   */
  function getReserveData(address asset) external view returns (DataTypes.ReserveData memory);

  /**
   * @notice Validates and finalizes an aToken transfer
   * @dev Only callable by the overlying aToken of the `asset`
   * @param asset The address of the underlying asset of the aToken
   * @param from The user from which the aTokens are transferred
   * @param to The user receiving the aTokens
   * @param amount The amount being transferred/withdrawn
   * @param balanceFromBefore The aToken balance of the `from` user before the transfer
   * @param balanceToBefore The aToken balance of the `to` user before the transfer
   */
  function finalizeTransfer(
    address asset,
    address from,
    address to,
    uint256 amount,
    uint256 balanceFromBefore,
    uint256 balanceToBefore
  ) external;

  /**
   * @notice Returns the list of the underlying assets of all the initialized reserves
   * @dev It does not include dropped reserves
   * @return The addresses of the underlying assets of the initialized reserves
   */
  function getReservesList() external view returns (address[] memory);

  /**
   * @notice Returns the address of the underlying asset of a reserve by the reserve id as stored in the DataTypes.ReserveData struct
   * @param id The id of the reserve as stored in the DataTypes.ReserveData struct
   * @return The address of the reserve associated with id
   */
  function getReserveAddressById(uint16 id) external view returns (address);

  /**
   * @notice Returns the PoolAddressesProvider connected to this contract
   * @return The address of the PoolAddressesProvider
   */
  function ADDRESSES_PROVIDER() external view returns (IPoolAddressesProvider);

  /**
   * @notice Updates the protocol fee on the bridging
   * @param bridgeProtocolFee The part of the premium sent to the protocol treasury
   */
  function updateBridgeProtocolFee(uint256 bridgeProtocolFee) external;

  /**
   * @notice Updates flash loan premiums. Flash loan premium consists of two parts:
   * - A part is sent to aToken holders as extra, one time accumulated interest
   * - A part is collected by the protocol treasury
   * @dev The total premium is calculated on the total borrowed amount
   * @dev The premium to protocol is calculated on the total premium, being a percentage of `flashLoanPremiumTotal`
   * @dev Only callable by the PoolConfigurator contract
   * @param flashLoanPremiumTotal The total premium, expressed in bps
   * @param flashLoanPremiumToProtocol The part of the premium sent to the protocol treasury, expressed in bps
   */
  function updateFlashloanPremiums(
    uint128 flashLoanPremiumTotal,
    uint128 flashLoanPremiumToProtocol
  ) external;

  /**
   * @notice Configures a new category for the eMode.
   * @dev In eMode, the protocol allows very high borrowing power to borrow assets of the same category.
   * The category 0 is reserved as it's the default for volatile assets
   * @param id The id of the category
   * @param config The configuration of the category
   */
  function configureEModeCategory(uint8 id, DataTypes.EModeCategory memory config) external;

  /**
   * @notice Returns the data of an eMode category
   * @param id The id of the category
   * @return The configuration data of the category
   */
  function getEModeCategoryData(uint8 id) external view returns (DataTypes.EModeCategory memory);

  /**
   * @notice Allows a user to use the protocol in eMode
   * @param categoryId The id of the category
   */
  function setUserEMode(uint8 categoryId) external;

  /**
   * @notice Returns the eMode the user is using
   * @param user The address of the user
   * @return The eMode id
   */
  function getUserEMode(address user) external view returns (uint256);

  /**
   * @notice Resets the isolation mode total debt of the given asset to zero
   * @dev It requires the given asset has zero debt ceiling
   * @param asset The address of the underlying asset to reset the isolationModeTotalDebt
   */
  function resetIsolationModeTotalDebt(address asset) external;

  /**
   * @notice Returns the percentage of available liquidity that can be borrowed at once at stable rate
   * @return The percentage of available liquidity to borrow, expressed in bps
   */
  function MAX_STABLE_RATE_BORROW_SIZE_PERCENT() external view returns (uint256);

  /**
   * @notice Returns the total fee on flash loans
   * @return The total fee on flashloans
   */
  function FLASHLOAN_PREMIUM_TOTAL() external view returns (uint128);

  /**
   * @notice Returns the part of the bridge fees sent to protocol
   * @return The bridge fee sent to the protocol treasury
   */
  function BRIDGE_PROTOCOL_FEE() external view returns (uint256);

  /**
   * @notice Returns the part of the flashloan fees sent to protocol
   * @return The flashloan fee sent to the protocol treasury
   */
  function FLASHLOAN_PREMIUM_TO_PROTOCOL() external view returns (uint128);

  /**
   * @notice Returns the maximum number of reserves supported to be listed in this Pool
   * @return The maximum number of reserves supported
   */
  function MAX_NUMBER_RESERVES() external view returns (uint16);

  /**
   * @notice Mints the assets accrued through the reserve factor to the treasury in the form of aTokens
   * @param assets The list of reserves for which the minting needs to be executed
   */
  function mintToTreasury(address[] calldata assets) external;

  /**
   * @notice Rescue and transfer tokens locked in this contract
   * @param token The address of the token
   * @param to The address of the recipient
   * @param amount The amount of token to transfer
   */
  function rescueTokens(address token, address to, uint256 amount) external;

  /**
   * @notice Supplies an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
   * - E.g. User supplies 100 USDC and gets in return 100 aUSDC
   * @dev Deprecated: Use the `supply` function instead
   * @param asset The address of the underlying asset to supply
   * @param amount The amount to be supplied
   * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
   *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
   *   is a different wallet
   * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
   *   0 if the action is executed directly by the user, without any middle-man
   */
  function deposit(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;
}

// lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol

// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)

/**
 * @title IERC1363
 * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
 *
 * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
 * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
 */
interface IERC1363 is IERC20, IERC165 {
    /*
     * Note: the ERC-165 identifier for this interface is 0xb0202a11.
     * 0xb0202a11 ===
     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
     */

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @param data Additional data with no specified format, sent in call to `spender`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}

// lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol

// OpenZeppelin Contracts (last updated v5.5.0) (token/ERC20/utils/SafeERC20.sol)

/**
 * @title SafeERC20
 * @dev Wrappers around ERC-20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    /**
     * @dev An operation with an ERC-20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        if (!_safeTransfer(token, to, value, true)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        if (!_safeTransferFrom(token, from, to, value, true)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {
        return _safeTransfer(token, to, value, false);
    }

    /**
     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {
        return _safeTransferFrom(token, from, to, value, false);
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     *
     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
     * only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
     * set here.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        if (!_safeApprove(token, spender, value, false)) {
            if (!_safeApprove(token, spender, 0, true)) revert SafeERC20FailedOperation(address(token));
            if (!_safeApprove(token, spender, value, true)) revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            safeTransfer(token, to, value);
        } else if (!token.transferAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
     * has no code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferFromAndCallRelaxed(
        IERC1363 token,
        address from,
        address to,
        uint256 value,
        bytes memory data
    ) internal {
        if (to.code.length == 0) {
            safeTransferFrom(token, from, to, value);
        } else if (!token.transferFromAndCall(from, to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
     * Oppositely, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
     * once without retrying, and relies on the returned value to be true.
     *
     * Reverts if the returned value is other than `true`.
     */
    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            forceApprove(token, to, value);
        } else if (!token.approveAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity `token.transfer(to, value)` call, relaxing the requirement on the return value: the
     * return value is optional (but if data is returned, it must not be false).
     *
     * @param token The token targeted by the call.
     * @param to The recipient of the tokens
     * @param value The amount of token to transfer
     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.
     */
    function _safeTransfer(IERC20 token, address to, uint256 value, bool bubble) private returns (bool success) {
        bytes4 selector = IERC20.transfer.selector;

        assembly ("memory-safe") {
            let fmp := mload(0x40)
            mstore(0x00, selector)
            mstore(0x04, and(to, shr(96, not(0))))
            mstore(0x24, value)
            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)
            // if call success and return is true, all is good.
            // otherwise (not success or return is not true), we need to perform further checks
            if iszero(and(success, eq(mload(0x00), 1))) {
                // if the call was a failure and bubble is enabled, bubble the error
                if and(iszero(success), bubble) {
                    returndatacopy(fmp, 0x00, returndatasize())
                    revert(fmp, returndatasize())
                }
                // if the return value is not true, then the call is only successful if:
                // - the token address has code
                // - the returndata is empty
                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))
            }
            mstore(0x40, fmp)
        }
    }

    /**
     * @dev Imitates a Solidity `token.transferFrom(from, to, value)` call, relaxing the requirement on the return
     * value: the return value is optional (but if data is returned, it must not be false).
     *
     * @param token The token targeted by the call.
     * @param from The sender of the tokens
     * @param to The recipient of the tokens
     * @param value The amount of token to transfer
     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.
     */
    function _safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value,
        bool bubble
    ) private returns (bool success) {
        bytes4 selector = IERC20.transferFrom.selector;

        assembly ("memory-safe") {
            let fmp := mload(0x40)
            mstore(0x00, selector)
            mstore(0x04, and(from, shr(96, not(0))))
            mstore(0x24, and(to, shr(96, not(0))))
            mstore(0x44, value)
            success := call(gas(), token, 0, 0x00, 0x64, 0x00, 0x20)
            // if call success and return is true, all is good.
            // otherwise (not success or return is not true), we need to perform further checks
            if iszero(and(success, eq(mload(0x00), 1))) {
                // if the call was a failure and bubble is enabled, bubble the error
                if and(iszero(success), bubble) {
                    returndatacopy(fmp, 0x00, returndatasize())
                    revert(fmp, returndatasize())
                }
                // if the return value is not true, then the call is only successful if:
                // - the token address has code
                // - the returndata is empty
                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))
            }
            mstore(0x40, fmp)
            mstore(0x60, 0)
        }
    }

    /**
     * @dev Imitates a Solidity `token.approve(spender, value)` call, relaxing the requirement on the return value:
     * the return value is optional (but if data is returned, it must not be false).
     *
     * @param token The token targeted by the call.
     * @param spender The spender of the tokens
     * @param value The amount of token to transfer
     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.
     */
    function _safeApprove(IERC20 token, address spender, uint256 value, bool bubble) private returns (bool success) {
        bytes4 selector = IERC20.approve.selector;

        assembly ("memory-safe") {
            let fmp := mload(0x40)
            mstore(0x00, selector)
            mstore(0x04, and(spender, shr(96, not(0))))
            mstore(0x24, value)
            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)
            // if call success and return is true, all is good.
            // otherwise (not success or return is not true), we need to perform further checks
            if iszero(and(success, eq(mload(0x00), 1))) {
                // if the call was a failure and bubble is enabled, bubble the error
                if and(iszero(success), bubble) {
                    returndatacopy(fmp, 0x00, returndatasize())
                    revert(fmp, returndatasize())
                }
                // if the return value is not true, then the call is only successful if:
                // - the token address has code
                // - the returndata is empty
                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))
            }
            mstore(0x40, fmp)
        }
    }
}

// src/FlashPro_V2_Hybrid.sol

interface IUniswapRouter {
    struct ExactInputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
    }
    function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);
}

error Unauthorized();
error InsufficientProfit(uint256 available, uint256 required);
error DeadlineExpired();
error TradeFailed();

contract FlashPro_V2_Hybrid is IUniswapV3FlashCallback {
    using SafeERC20 for IERC20;

    address public constant OWNER = 0x2705F2Ce76345FD5Dbf3149898Fb772195e5F9C5;
    IPoolAddressesProvider public constant ADDRESS_PROVIDER = IPoolAddressesProvider(0xa97684ead0E402dc232D5A977953DF7ecBab3CD2);
    IUniswapRouter public swapRouter = IUniswapRouter(0xE592427A0AEce92De3Edee1F18E0157C05861564);

    struct TradeParams {
        address asset;
        uint256 amount;
        uint256 minProfit;
        uint256 minAmountOut;
        uint256 deadline;
        bytes path; 
    }

    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    function _checkOwner() internal view {
        if (msg.sender != OWNER) revert Unauthorized();
    }

    function executeAaveFlash(
        address asset, 
        uint256 amount, 
        uint256 minProfit, 
        uint256 minAmountOut,
        uint256 deadline, 
        bytes calldata path
    ) external onlyOwner {
        if (block.timestamp > deadline) revert DeadlineExpired();
        
        TradeParams memory params = TradeParams({
            asset: asset,
            amount: amount,
            minProfit: minProfit,
            minAmountOut: minAmountOut,
            deadline: deadline,
            path: path
        });

        IPool pool = IPool(ADDRESS_PROVIDER.getPool());
        pool.flashLoanSimple(address(this), asset, amount, abi.encode(params), 0);
    }

    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,
        address, 
        bytes calldata params
    ) external returns (bool) {
        TradeParams memory tParams = abi.decode(params, (TradeParams));
        
        if (tParams.path.length > 0) {
            IERC20(asset).forceApprove(address(swapRouter), amount);
            
            IUniswapRouter.ExactInputParams memory swapParams = IUniswapRouter.ExactInputParams({
                path: tParams.path,
                recipient: address(this),
                deadline: tParams.deadline,
                amountIn: amount,
                amountOutMinimum: tParams.minAmountOut
            });
            
            try swapRouter.exactInput(swapParams) returns (uint256) {
            } catch {
                revert TradeFailed();
            }
        }
        
        uint256 totalRepayment = amount + premium;
        IERC20(asset).forceApprove(msg.sender, totalRepayment);
        
        _finalizeProfit(asset, tParams.minProfit);
        return true;
    }

    function uniswapV3FlashCallback(uint256 fee0, uint256 fee1, bytes calldata data) external override {
        TradeParams memory params = abi.decode(data, (TradeParams));
        uint256 amountToRepay = params.amount + (fee0 > 0 ? fee0 : fee1);
        IERC20(params.asset).safeTransfer(msg.sender, amountToRepay);
        _finalizeProfit(params.asset, params.minProfit);
    }

    function _finalizeProfit(address asset, uint256 minProfit) internal {
        uint256 balance = IERC20(asset).balanceOf(address(this));
        if (balance < minProfit) revert InsufficientProfit(balance, minProfit);
        if (balance > 0) {
            IERC20(asset).safeTransfer(OWNER, balance);
        }
    }

    function updateRouter(address _newRouter) external onlyOwner {
        swapRouter = IUniswapRouter(_newRouter);
    }

    function withdrawToken(address token) external onlyOwner {
        IERC20(token).safeTransfer(OWNER, IERC20(token).balanceOf(address(this)));
    }

    receive() external payable {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"DeadlineExpired","type":"error"},{"inputs":[{"internalType":"uint256","name":"available","type":"uint256"},{"internalType":"uint256","name":"required","type":"uint256"}],"name":"InsufficientProfit","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"TradeFailed","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"ADDRESS_PROVIDER","outputs":[{"internalType":"contract IPoolAddressesProvider","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OWNER","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"minProfit","type":"uint256"},{"internalType":"uint256","name":"minAmountOut","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"path","type":"bytes"}],"name":"executeAaveFlash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"premium","type":"uint256"},{"internalType":"address","name":"","type":"address"},{"internalType":"bytes","name":"params","type":"bytes"}],"name":"executeOperation","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapRouter","outputs":[{"internalType":"contract IUniswapRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"fee0","type":"uint256"},{"internalType":"uint256","name":"fee1","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"uniswapV3FlashCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newRouter","type":"address"}],"name":"updateRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"withdrawToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

72989:3651:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73086:74;;;;;;;;;;;;73118:42;73086:74;;;;;-1:-1:-1;;;;;178:32:1;;;160:51;;148:2;133:18;73086:74:0;;;;;;;;73167:124;;;;;;;;;;;;73248:42;73167:124;;74485:1114;;;;;;;;;;-1:-1:-1;74485:1114:0;;;;;:::i;:::-;;:::i;:::-;;;1941:14:1;;1934:22;1916:41;;1904:2;1889:18;74485:1114:0;1776:187:1;73775:702:0;;;;;;;;;;-1:-1:-1;73775:702:0;;;;;:::i;:::-;;:::i;:::-;;76451:149;;;;;;;;;;-1:-1:-1;76451:149:0;;;;;:::i;:::-;;:::i;73298:93::-;;;;;;;;;;-1:-1:-1;73298:93:0;;;;-1:-1:-1;;;;;73298:93:0;;;76324:119;;;;;;;;;;-1:-1:-1;76324:119:0;;;;;:::i;:::-;;:::i;75607:381::-;;;;;;;;;;-1:-1:-1;75607:381:0;;;;;:::i;:::-;;:::i;74485:1114::-;74662:4;;74708:33;;;;74719:6;74708:33;:::i;:::-;74766:12;;;;:19;74679:62;;-1:-1:-1;74766:23:0;74762:619;;74841:10;;74806:55;;-1:-1:-1;;;;;74806:26:0;;;;74841:10;74854:6;74806:26;:55::i;:::-;74942:265;;;;;;;;;74999:12;;;74942:265;;75049:4;74942:265;;;;75083:16;;;;;74942:265;;;;;;;;;;;75171:20;;;74942:265;;;;74890:49;75240:10;:33;;-1:-1:-1;;;75240:33:0;;74942:265;;-1:-1:-1;;;;;75240:10:0;;:21;;:33;;74942:265;;75240:33;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75240:33:0;;;;;;;;-1:-1:-1;;75240:33:0;;;;;;;;;;;;:::i;:::-;;;75236:134;;75341:13;;-1:-1:-1;;;75341:13:0;;;;;;;;;;;75236:134;75274:34;74791:590;74762:619;75401:22;75426:16;75435:7;75426:6;:16;:::i;:::-;75401:41;-1:-1:-1;75453:54:0;-1:-1:-1;;;;;75453:26:0;;75480:10;75401:41;75453:26;:54::i;:::-;75528:41;75544:5;75551:7;:17;;;75528:15;:41::i;:::-;-1:-1:-1;75587:4:0;;74485:1114;-1:-1:-1;;;;;;;;74485:1114:0:o;73775:702::-;73624:13;:11;:13::i;:::-;74029:8:::1;74011:15;:26;74007:56;;;74046:17;;-1:-1:-1::0;;;74046:17:0::1;;;;;;;;;;;74007:56;74084:25;74112:214;;;;;;;;74146:5;-1:-1:-1::0;;;;;74112:214:0::1;;;;;74174:6;74112:214;;;;74206:9;74112:214;;;;74244:12;74112:214;;;;74281:8;74112:214;;;;74310:4;;74112:214;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;-1:-1:-1;74112:214:0;;;;-1:-1:-1;;74358:26:0::1;::::0;;-1:-1:-1;;;74358:26:0;;;;74084:242;;-1:-1:-1;74112:214:0;;73248:42:::1;::::0;-1:-1:-1;74358:24:0::1;::::0;:26:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;73248:42;74358:26:::1;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;74339:46;;74396:4;-1:-1:-1::0;;;;;74396:20:0::1;;74425:4;74432:5;74439:6;74458;74447:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;74467:1;74396:73;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;73996:481;;73775:702:::0;;;;;;;:::o;76451:149::-;73624:13;:11;:13::i;:::-;76553:38:::1;::::0;-1:-1:-1;;;76553:38:0;;76585:4:::1;76553:38;::::0;::::1;160:51:1::0;76519:73:0::1;::::0;73118:42:::1;::::0;-1:-1:-1;;;;;76553:23:0;::::1;::::0;::::1;::::0;133:18:1;;76553:38:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;76519:26:0;::::1;::::0;:73;:26:::1;:73::i;:::-;76451:149:::0;:::o;76324:119::-;73624:13;:11;:13::i;:::-;76396:10:::1;:39:::0;;-1:-1:-1;;;;;;76396:39:0::1;-1:-1:-1::0;;;;;76396:39:0;;;::::1;::::0;;;::::1;::::0;;76324:119::o;75607:381::-;75717:25;75745:31;;;;75756:4;75745:31;:::i;:::-;75717:59;;75787:21;75835:1;75828:4;:8;:22;;75846:4;75828:22;;;75839:4;75828:22;75811:6;:13;;;:40;;;;:::i;:::-;75869:12;;75787:64;;-1:-1:-1;75862:60:0;;-1:-1:-1;;;;;75862:33:0;75896:10;75787:64;75862:33;:60::i;:::-;75933:47;75949:6;:12;;;75963:6;:16;;;75933:15;:47::i;:::-;75706:282;;75607:381;;;;:::o;64111:372::-;64204:42;64217:5;64224:7;64233:5;64240;64204:12;:42::i;:::-;64199:277;;64268:37;64281:5;64288:7;64297:1;64300:4;64268:12;:37::i;:::-;64263:91;;64314:40;;-1:-1:-1;;;64314:40:0;;-1:-1:-1;;;;;178:32:1;;64314:40:0;;;160:51:1;133:18;;64314:40:0;;;;;;;;64263:91;64374:41;64387:5;64394:7;64403:5;64410:4;64374:12;:41::i;:::-;64369:95;;64424:40;;-1:-1:-1;;;64424:40:0;;-1:-1:-1;;;;;178:32:1;;64424:40:0;;;160:51:1;133:18;;64424:40:0;14:203:1;64369:95:0;64111:372;;;:::o;75996:320::-;76093:38;;-1:-1:-1;;;76093:38:0;;76125:4;76093:38;;;160:51:1;76075:15:0;;-1:-1:-1;;;;;76093:23:0;;;;;133:18:1;;76093:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;76075:56;;76156:9;76146:7;:19;76142:70;;;76174:38;;-1:-1:-1;;;76174:38:0;;;;;9095:25:1;;;9136:18;;;9129:34;;;9068:18;;76174:38:0;8921:248:1;76142:70:0;76227:11;;76223:86;;76255:42;-1:-1:-1;;;;;76255:26:0;;73118:42;76289:7;76255:26;:42::i;73665:102::-;73717:10;73118:42;73717:19;73713:46;;73745:14;;-1:-1:-1;;;73745:14:0;;;;;;;;;;;73713:46;73665:102::o;60160:208::-;60248:37;60262:5;60269:2;60273:5;60280:4;60248:13;:37::i;71222:1276::-;71456:4;71450:11;-1:-1:-1;;;71320:12:0;71475:22;;;-1:-1:-1;;;;;71524:29:0;;71518:4;71511:43;71575:4;71568:19;;;71320:12;71652:4;71320:12;71640:4;71320:12;;71624:5;71617;71612:45;71601:56;;71872:1;71865:4;71859:11;71856:18;71847:7;71843:32;71833:616;;72006:6;71996:7;71989:15;71985:28;71982:168;;;72063:16;72057:4;72052:3;72037:43;72114:16;72109:3;72102:29;71982:168;72430:1;72422:5;72410:18;72407:25;72388:16;72381:24;72377:56;72368:7;72364:70;72353:81;;71833:616;72470:4;72463:17;-1:-1:-1;71222:1276:0;;-1:-1:-1;;;;71222:1276:0:o;67457:1268::-;67688:4;67682:11;-1:-1:-1;;;67551:12:0;67707:22;;;-1:-1:-1;;;;;67756:24:0;;67750:4;67743:38;67802:4;67795:19;;;67551:12;67879:4;67551:12;67867:4;67551:12;;67851:5;67844;67839:45;67828:56;;68099:1;68092:4;68086:11;68083:18;68074:7;68070:32;68060:616;;68233:6;68223:7;68216:15;68212:28;68209:168;;;68290:16;68284:4;68279:3;68264:43;68341:16;68336:3;68329:29;460:131:1;-1:-1:-1;;;;;535:31:1;;525:42;;515:70;;581:1;578;571:12;596:347;647:8;657:6;711:3;704:4;696:6;692:17;688:27;678:55;;729:1;726;719:12;678:55;-1:-1:-1;752:20:1;;795:18;784:30;;781:50;;;827:1;824;817:12;781:50;864:4;856:6;852:17;840:29;;916:3;909:4;900:6;892;888:19;884:30;881:39;878:59;;;933:1;930;923:12;878:59;596:347;;;;;:::o;948:823::-;1054:6;1062;1070;1078;1086;1094;1147:3;1135:9;1126:7;1122:23;1118:33;1115:53;;;1164:1;1161;1154:12;1115:53;1203:9;1190:23;1222:31;1247:5;1222:31;:::i;:::-;1272:5;-1:-1:-1;1324:2:1;1309:18;;1296:32;;-1:-1:-1;1375:2:1;1360:18;;1347:32;;-1:-1:-1;1431:2:1;1416:18;;1403:32;1444:33;1403:32;1444:33;:::i;:::-;1496:7;-1:-1:-1;1554:3:1;1539:19;;1526:33;1582:18;1571:30;;1568:50;;;1614:1;1611;1604:12;1568:50;1653:58;1703:7;1694:6;1683:9;1679:22;1653:58;:::i;:::-;948:823;;;;-1:-1:-1;948:823:1;;-1:-1:-1;948:823:1;;1730:8;;948:823;-1:-1:-1;;;948:823:1:o;1968:819::-;2083:6;2091;2099;2107;2115;2123;2131;2184:3;2172:9;2163:7;2159:23;2155:33;2152:53;;;2201:1;2198;2191:12;2152:53;2240:9;2227:23;2259:31;2284:5;2259:31;:::i;:::-;2309:5;-1:-1:-1;2361:2:1;2346:18;;2333:32;;-1:-1:-1;2412:2:1;2397:18;;2384:32;;-1:-1:-1;2463:2:1;2448:18;;2435:32;;-1:-1:-1;2514:3:1;2499:19;;2486:33;;-1:-1:-1;2570:3:1;2555:19;;2542:33;2598:18;2587:30;;2584:50;;;2630:1;2627;2620:12;2584:50;2669:58;2719:7;2710:6;2699:9;2695:22;2669:58;:::i;:::-;1968:819;;;;-1:-1:-1;1968:819:1;;-1:-1:-1;1968:819:1;;;;2643:84;;-1:-1:-1;;;1968:819:1:o;2792:247::-;2851:6;2904:2;2892:9;2883:7;2879:23;2875:32;2872:52;;;2920:1;2917;2910:12;2872:52;2959:9;2946:23;2978:31;3003:5;2978:31;:::i;:::-;3028:5;2792:247;-1:-1:-1;;;2792:247:1:o;3275:545::-;3363:6;3371;3379;3387;3440:2;3428:9;3419:7;3415:23;3411:32;3408:52;;;3456:1;3453;3446:12;3408:52;3492:9;3479:23;3469:33;;3549:2;3538:9;3534:18;3521:32;3511:42;;3604:2;3593:9;3589:18;3576:32;3631:18;3623:6;3620:30;3617:50;;;3663:1;3660;3653:12;3617:50;3702:58;3752:7;3743:6;3732:9;3728:22;3702:58;:::i;:::-;3275:545;;;;-1:-1:-1;3779:8:1;-1:-1:-1;;;;3275:545:1:o;3825:127::-;3886:10;3881:3;3877:20;3874:1;3867:31;3917:4;3914:1;3907:15;3941:4;3938:1;3931:15;3957:253;4029:2;4023:9;4071:4;4059:17;;4106:18;4091:34;;4127:22;;;4088:62;4085:88;;;4153:18;;:::i;:::-;4189:2;4182:22;3957:253;:::o;4215:275::-;4286:2;4280:9;4351:2;4332:13;;-1:-1:-1;;4328:27:1;4316:40;;4386:18;4371:34;;4407:22;;;4368:62;4365:88;;;4433:18;;:::i;:::-;4469:2;4462:22;4215:275;;-1:-1:-1;4215:275:1:o;4495:1401::-;4583:6;4614:2;4657;4645:9;4636:7;4632:23;4628:32;4625:52;;;4673:1;4670;4663:12;4625:52;4713:9;4700:23;4742:18;4783:2;4775:6;4772:14;4769:34;;;4799:1;4796;4789:12;4769:34;4822:22;;;;4878:4;4860:16;;;4856:27;4853:47;;;4896:1;4893;4886:12;4853:47;4922:22;;:::i;:::-;4981:2;4968:16;4993:33;5018:7;4993:33;:::i;:::-;5049:7;5042:5;5035:22;;5110:2;5106;5102:11;5089:25;5084:2;5077:5;5073:14;5066:49;5168:2;5164;5160:11;5147:25;5142:2;5135:5;5131:14;5124:49;5226:2;5222;5218:11;5205:25;5200:2;5193:5;5189:14;5182:49;5285:3;5281:2;5277:12;5264:26;5258:3;5251:5;5247:15;5240:51;5337:3;5333:2;5329:12;5316:26;5367:2;5357:8;5354:16;5351:36;;;5383:1;5380;5373:12;5351:36;5414:8;5410:2;5406:17;5396:27;;;5461:7;5454:4;5450:2;5446:13;5442:27;5432:55;;5483:1;5480;5473:12;5432:55;5519:2;5506:16;5541:2;5537;5534:10;5531:36;;;5547:18;;:::i;:::-;5589:53;5632:2;5613:13;;-1:-1:-1;;5609:27:1;5605:36;;5589:53;:::i;:::-;5576:66;;5665:2;5658:5;5651:17;5705:7;5700:2;5695;5691;5687:11;5683:20;5680:33;5677:53;;;5726:1;5723;5716:12;5677:53;5781:2;5776;5772;5768:11;5763:2;5756:5;5752:14;5739:45;5825:1;5804:14;;;5800:23;;;5793:34;;;;5854:3;5843:15;;5836:30;-1:-1:-1;5847:5:1;4495:1401;-1:-1:-1;;;4495:1401:1:o;5901:422::-;5942:3;5980:5;5974:12;6007:6;6002:3;5995:19;6032:1;6042:162;6056:6;6053:1;6050:13;6042:162;;;6118:4;6174:13;;;6170:22;;6164:29;6146:11;;;6142:20;;6135:59;6071:12;6042:162;;;6046:3;6249:1;6242:4;6233:6;6228:3;6224:16;6220:27;6213:38;6312:4;6305:2;6301:7;6296:2;6288:6;6284:15;6280:29;6275:3;6271:39;6267:50;6260:57;;;5901:422;;;;:::o;6328:652::-;6525:2;6514:9;6507:21;6488:4;6563:6;6557:13;6606:4;6601:2;6590:9;6586:18;6579:32;6634:51;6680:3;6669:9;6665:19;6651:12;6634:51;:::i;:::-;6620:65;;6766:1;6762;6757:3;6753:11;6749:19;6743:2;6735:6;6731:15;6725:22;6721:48;6716:2;6705:9;6701:18;6694:76;6824:2;6816:6;6812:15;6806:22;6801:2;6790:9;6786:18;6779:50;6884:2;6876:6;6872:15;6866:22;6860:3;6849:9;6845:19;6838:51;6945:3;6937:6;6933:16;6927:23;6920:4;6909:9;6905:20;6898:53;6968:6;6960:14;;;6328:652;;;;:::o;6985:184::-;7055:6;7108:2;7096:9;7087:7;7083:23;7079:32;7076:52;;;7124:1;7121;7114:12;7076:52;-1:-1:-1;7147:16:1;;6985:184;-1:-1:-1;6985:184:1:o;7174:222::-;7239:9;;;7260:10;;;7257:133;;;7312:10;7307:3;7303:20;7300:1;7293:31;7347:4;7344:1;7337:15;7375:4;7372:1;7365:15;7257:133;7174:222;;;;:::o;7401:251::-;7471:6;7524:2;7512:9;7503:7;7499:23;7495:32;7492:52;;;7540:1;7537;7530:12;7492:52;7572:9;7566:16;7591:31;7616:5;7591:31;:::i;7657:674::-;7844:2;7833:9;7826:21;7919:1;7915;7910:3;7906:11;7902:19;7893:6;7887:13;7883:39;7878:2;7867:9;7863:18;7856:67;7977:2;7969:6;7965:15;7959:22;7954:2;7943:9;7939:18;7932:50;8036:2;8028:6;8024:15;8018:22;8013:2;8002:9;7998:18;7991:50;8096:2;8088:6;8084:15;8078:22;8072:3;8061:9;8057:19;8050:51;8156:3;8148:6;8144:16;8138:23;8132:3;8121:9;8117:19;8110:52;7807:4;8209:3;8201:6;8197:16;8191:23;8252:4;8245;8234:9;8230:20;8223:34;8274:51;8320:3;8309:9;8305:19;8291:12;8274:51;:::i;:::-;8266:59;7657:674;-1:-1:-1;;;;7657:674:1:o;8336:580::-;-1:-1:-1;;;;;8640:15:1;;;8622:34;;8692:15;;8687:2;8672:18;;8665:43;8739:2;8724:18;;8717:34;;;8602:3;8782:2;8767:18;;8760:31;;;8565:4;;8808:45;;8833:19;;8825:6;8808:45;:::i;:::-;8800:53;;8902:6;8894;8890:19;8884:3;8873:9;8869:19;8862:48;8336:580;;;;;;;;:::o

ipfs://7ff13685152f87e4d772d1373cdee8ec9093cc13035f4c3309c0020625746db8