@shift-defi/strategies 0.1.0

package/README.md

@@ -0,0 +1,55 @@
+# ShiftDeFi Onchain Template
+
+This repository contains basic setup for ShiftDeFi onhcain projects.
+
+## Usage
+
+### Build
+
+```shell
+$ forge build
+```
+
+### Test
+
+```shell
+$ forge test
+```
+
+### Format
+
+```shell
+$ forge fmt
+```
+
+### Gas Snapshots
+
+```shell
+$ forge snapshot
+```
+
+### Anvil
+
+```shell
+$ anvil
+```
+
+### Deploy
+
+```shell
+$ forge script script/Counter.s.sol:CounterScript --rpc-url <your_rpc_url> --private-key <your_private_key>
+```
+
+### Cast
+
+```shell
+$ cast <subcommand>
+```
+
+### Help
+
+```shell
+$ forge --help
+$ anvil --help
+$ cast --help
+```

package/contracts/curve-gauge/CurveGauge.sol

@@ -0,0 +1,296 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import {StrategyTemplate} from "@shift-defi/core/StrategyTemplate.sol";
+import {IStrategyTemplate} from "@shift-defi/core/interfaces/IStrategyTemplate.sol";
+import {Errors} from "@shift-defi/core/libraries/Errors.sol";
+
+import {ICurveStableSwapNG} from "contracts/dependencies/curve/ICurveStableSwapNG.sol";
+import {ILiquidityGaugeV6} from "contracts/dependencies/curve/ILiquidityGaugeV6.sol";
+
+import {ICurveGauge} from "contracts/interfaces/ICurveGauge.sol";
+
+contract CurveGauge is StrategyTemplate, ICurveGauge {
+    using SafeERC20 for IERC20;
+    using Math for uint256;
+
+    address public gauge;
+    address public lpToken;
+    address public underlyingAsset0;
+    address public underlyingAsset1;
+
+    uint256 public lastStoredVirtualPrice;
+    uint256 public lastStoredGaugeBalance;
+
+    bytes32 internal constant UNDERLYING_ASSETS_STATE_ID = keccak256("UNDERLYING_ASSETS_STATE_ID");
+    bytes32 internal constant CURVE_LP_STATE_ID = keccak256("CURVE_LP_STATE_ID");
+    bytes32 internal constant CURVE_GAUGE_STATE_ID = keccak256("CURVE_GAUGE_STATE_ID");
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(
+        address strategyContainer,
+        address _gauge,
+        uint256 _enterMaxSlippage,
+        uint256 _exitMaxSlippage,
+        uint256 _emergencyExitMaxSlippage
+    ) external initializer {
+        __StrategyTemplate_init(strategyContainer, _enterMaxSlippage, _exitMaxSlippage, _emergencyExitMaxSlippage);
+
+        require(_gauge != address(0), Errors.ZeroAddress());
+        gauge = _gauge;
+        lpToken = ILiquidityGaugeV6(_gauge).lp_token();
+        underlyingAsset0 = ICurveStableSwapNG(lpToken).coins(0);
+        underlyingAsset1 = ICurveStableSwapNG(lpToken).coins(1);
+
+        _setState(UNDERLYING_ASSETS_STATE_ID, false, false, true, 1);
+        _setState(CURVE_LP_STATE_ID, false, true, false, 2);
+        _setState(CURVE_GAUGE_STATE_ID, true, true, false, 3);
+
+        lastStoredVirtualPrice = ICurveStableSwapNG(lpToken).get_virtual_price();
+    }
+
+    /// @inheritdoc IStrategyTemplate
+    function stateNav(bytes32 stateId) public view override returns (uint256) {
+        if (stateId == CURVE_GAUGE_STATE_ID) {
+            return _curveGaugeNav();
+        } else if (stateId == CURVE_LP_STATE_ID) {
+            return _curveLpNav();
+        } else if (stateId == UNDERLYING_ASSETS_STATE_ID) {
+            return _underlyingAssetsNav();
+        } else if (stateId == NO_ALLOCATION_STATE_ID) {
+            return 0;
+        } else {
+            revert StateNotFound(stateId);
+        }
+    }
+
+    function _underlyingAssetsNav() internal view returns (uint256) {
+        address asset0 = underlyingAsset0;
+        address asset1 = underlyingAsset1;
+        uint256 balance0 = IERC20(asset0).balanceOf(address(this));
+        uint256 balance1 = IERC20(asset1).balanceOf(address(this));
+        return getTokenAmountInNotion(asset0, balance0) + getTokenAmountInNotion(asset1, balance1);
+    }
+
+    function _curveLpNav() internal view returns (uint256) {
+        address lpTokenCached = lpToken;
+        uint256 lpBalance = IERC20(lpTokenCached).balanceOf(address(this));
+        uint256 totalSupply = IERC20(lpTokenCached).totalSupply();
+
+        if (totalSupply == 0) {
+            return 0;
+        }
+
+        uint256[] memory poolReserves = ICurveStableSwapNG(lpTokenCached).get_balances();
+        uint256 totalPoolNav = getTokenAmountInNotion(underlyingAsset0, poolReserves[0]) +
+            getTokenAmountInNotion(underlyingAsset1, poolReserves[1]);
+
+        return totalPoolNav.mulDiv(lpBalance, totalSupply);
+    }
+
+    function _curveGaugeNav() internal view returns (uint256) {
+        address gaugeCached = gauge;
+        uint256 stakedLp = ILiquidityGaugeV6(gaugeCached).balanceOf(address(this));
+
+        address lpTokenCached = lpToken;
+        uint256 totalSupply = IERC20(lpTokenCached).totalSupply();
+
+        if (stakedLp == 0 || totalSupply == 0) {
+            return 0;
+        }
+
+        uint256[] memory poolReserves = ICurveStableSwapNG(lpTokenCached).get_balances();
+        uint256 totalPoolNav = getTokenAmountInNotion(underlyingAsset0, poolReserves[0]) +
+            getTokenAmountInNotion(underlyingAsset1, poolReserves[1]);
+
+        return totalPoolNav.mulDiv(stakedLp, totalSupply);
+    }
+
+    function _enterCurveLp() internal {
+        uint256[] memory amounts = new uint256[](2);
+        amounts[0] = IERC20(underlyingAsset0).balanceOf(address(this));
+        amounts[1] = IERC20(underlyingAsset1).balanceOf(address(this));
+
+        if (amounts[0] == 0 && amounts[1] == 0) {
+            return;
+        }
+
+        if (amounts[0] > 0) {
+            IERC20(underlyingAsset0).safeIncreaseAllowance(lpToken, amounts[0]);
+        }
+        if (amounts[1] > 0) {
+            IERC20(underlyingAsset1).safeIncreaseAllowance(lpToken, amounts[1]);
+        }
+
+        ICurveStableSwapNG(lpToken).add_liquidity(amounts, 0);
+    }
+
+    function _enterCurveGauge() internal {
+        address lpTokenCached = lpToken;
+        address gaugeCached = gauge;
+
+        uint256 lpBalance = IERC20(lpTokenCached).balanceOf(address(this));
+
+        if (lpBalance == 0) {
+            return;
+        }
+
+        IERC20(lpTokenCached).safeIncreaseAllowance(gaugeCached, lpBalance);
+        ILiquidityGaugeV6(gaugeCached).deposit(lpBalance);
+
+        lastStoredGaugeBalance = ILiquidityGaugeV6(gaugeCached).balanceOf(address(this));
+        lastStoredVirtualPrice = ICurveStableSwapNG(lpTokenCached).get_virtual_price();
+    }
+
+    function _enterTarget() internal override {
+        _enterCurveLp();
+        _enterCurveGauge();
+    }
+
+    function _enterState(bytes32 stateId) internal override {
+        if (stateId == CURVE_GAUGE_STATE_ID) {
+            _enterCurveLp();
+            _enterCurveGauge();
+        } else if (stateId == CURVE_LP_STATE_ID) {
+            _enterCurveLp();
+        } else {
+            revert StateNotFound(stateId);
+        }
+    }
+
+    function _exitCurveLp(uint256 share) internal {
+        address lpTokenCached = lpToken;
+        uint256 lpBalance = IERC20(lpTokenCached).balanceOf(address(this));
+        uint256 lpToWithdraw = lpBalance.mulDiv(share, MAX_BPS);
+
+        if (lpToWithdraw == 0) {
+            return;
+        }
+
+        uint256[] memory minAmountsOut = new uint256[](2);
+
+        ICurveStableSwapNG(lpTokenCached).remove_liquidity(lpToWithdraw, minAmountsOut);
+    }
+
+    function _exitCurveGauge(uint256 share) internal {
+        address gaugeCached = gauge;
+        uint256 gaugeBalance = ILiquidityGaugeV6(gaugeCached).balanceOf(address(this));
+        uint256 gaugeLpToWithdraw = gaugeBalance.mulDiv(share, MAX_BPS);
+
+        if (gaugeLpToWithdraw == 0) {
+            return;
+        }
+
+        ILiquidityGaugeV6(gaugeCached).withdraw(gaugeLpToWithdraw);
+
+        lastStoredGaugeBalance = ILiquidityGaugeV6(gaugeCached).balanceOf(address(this));
+        lastStoredVirtualPrice = ICurveStableSwapNG(lpToken).get_virtual_price();
+    }
+
+    function _exitTarget(uint256 share) internal override {
+        _exitCurveGauge(share);
+        _exitCurveLp(MAX_BPS);
+    }
+
+    function _exitFromState(bytes32 stateId, uint256 share) internal override {
+        if (stateId == CURVE_GAUGE_STATE_ID) {
+            _exitCurveGauge(share);
+        } else if (stateId == CURVE_LP_STATE_ID) {
+            _exitCurveLp(share);
+        } else {
+            revert StateNotFound(stateId);
+        }
+    }
+
+    function _emergencyExit(bytes32 toStateId, uint256 share) internal override {
+        bytes32 currentStateId = currentStateId();
+        if (toStateId == CURVE_LP_STATE_ID) {
+            _exitCurveGauge(share);
+        } else if (toStateId == UNDERLYING_ASSETS_STATE_ID) {
+            if (currentStateId == CURVE_GAUGE_STATE_ID) {
+                _exitCurveGauge(share);
+                _exitCurveLp(MAX_BPS);
+            } else {
+                _exitCurveLp(share);
+            }
+        } else {
+            revert StateNotFound(toStateId);
+        }
+    }
+
+    function _harvest(bytes32 _stateId, address _treasury, uint256 _feePct) internal override {
+        AutomaticHarvestLocalVars memory vars;
+        vars.gaugeCached = gauge;
+        vars.lpTokenCached = lpToken;
+        vars.asset0Cached = underlyingAsset0;
+        vars.asset1Cached = underlyingAsset1;
+
+        vars.lastStoredGaugeBalance = lastStoredGaugeBalance;
+        vars.lastStoredVirtualPrice = lastStoredVirtualPrice;
+
+        vars.currentGaugeBalance = ILiquidityGaugeV6(vars.gaugeCached).balanceOf(address(this));
+        vars.currentVirtualPrice = ICurveStableSwapNG(vars.lpTokenCached).get_virtual_price();
+
+        if (vars.lastStoredGaugeBalance == 0) {
+            lastStoredGaugeBalance = vars.currentGaugeBalance;
+            lastStoredVirtualPrice = vars.currentVirtualPrice;
+            return;
+        }
+
+        if (_feePct > 0 && vars.currentVirtualPrice > vars.lastStoredVirtualPrice) {
+            vars.accruedLpValue =
+                (vars.currentGaugeBalance * vars.currentVirtualPrice -
+                    vars.lastStoredGaugeBalance * vars.lastStoredVirtualPrice) / vars.currentVirtualPrice;
+
+            vars.gaugeTokensToTreasury = vars.accruedLpValue.mulDiv(_feePct, MAX_BPS);
+        }
+
+        vars.asset0BalanceBefore = IERC20(vars.asset0Cached).balanceOf(address(this));
+        vars.asset1BalanceBefore = IERC20(vars.asset1Cached).balanceOf(address(this));
+
+        ILiquidityGaugeV6(vars.gaugeCached).claim_rewards();
+
+        vars.asset0Rewards = IERC20(vars.asset0Cached).balanceOf(address(this)) - vars.asset0BalanceBefore;
+        vars.asset1Rewards = IERC20(vars.asset1Cached).balanceOf(address(this)) - vars.asset1BalanceBefore;
+
+        if ((vars.asset0Rewards != 0 || vars.asset1Rewards != 0) && _stateId == CURVE_GAUGE_STATE_ID) {
+            uint256[] memory amounts = new uint256[](2);
+            amounts[0] = vars.asset0Rewards;
+            amounts[1] = vars.asset1Rewards;
+
+            IERC20(vars.asset0Cached).safeIncreaseAllowance(vars.lpTokenCached, amounts[0]);
+            IERC20(vars.asset1Cached).safeIncreaseAllowance(vars.lpTokenCached, amounts[1]);
+
+            ICurveStableSwapNG(vars.lpTokenCached).add_liquidity(amounts, 0);
+
+            _enterCurveGauge();
+
+            vars.reinvestGaugeDelta =
+                ILiquidityGaugeV6(vars.gaugeCached).balanceOf(address(this)) - vars.currentGaugeBalance;
+
+            if (vars.reinvestGaugeDelta > 0) {
+                vars.feeFromReinvest = vars.reinvestGaugeDelta.mulDiv(_feePct, MAX_BPS);
+                if (vars.feeFromReinvest > 0) {
+                    vars.gaugeTokensToTreasury += vars.feeFromReinvest;
+                }
+            }
+        }
+
+        if (vars.gaugeTokensToTreasury > 0) {
+            IERC20(vars.gaugeCached).safeTransfer(_treasury, vars.gaugeTokensToTreasury);
+        }
+
+        lastStoredGaugeBalance = ILiquidityGaugeV6(vars.gaugeCached).balanceOf(address(this));
+        lastStoredVirtualPrice = Math.max(
+            ICurveStableSwapNG(vars.lpTokenCached).get_virtual_price(),
+            vars.lastStoredVirtualPrice
+        );
+    }
+}

package/contracts/dependencies/aave-v3/DataTypes.sol

@@ -0,0 +1,333 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+library DataTypes {
+    /**
+     * This exists specifically to maintain the `getReserveData()` interface, since the new, internal
+     * `ReserveData` struct includes the reserve's `virtualUnderlyingBalance`.
+     */
+    struct ReserveDataLegacy {
+        //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;
+        // DEPRECATED on v3.2.0
+        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;
+        // DEPRECATED on v3.2.0
+        address stableDebtTokenAddress;
+        //variableDebtToken address
+        address variableDebtTokenAddress;
+        // DEPRECATED on v3.4.0, should use the `RESERVE_INTEREST_RATE_STRATEGY` variable from the Pool contract
+        address interestRateStrategyAddress;
+        //the current treasury balance, scaled
+        uint128 accruedToTreasury;
+        // DEPRECATED on v3.4.0
+        uint128 unbacked;
+        //the outstanding debt borrowed against this asset in isolation mode
+        uint128 isolationModeTotalDebt;
+    }
+
+    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;
+        /// @notice reused `__deprecatedStableBorrowRate` storage from pre 3.2
+        // the current accumulate deficit in underlying tokens
+        uint128 deficit;
+        //timestamp of last update
+        uint40 lastUpdateTimestamp;
+        //the id of the reserve. Represents the position in the list of the active reserves
+        uint16 id;
+        //timestamp until when liquidations are not allowed on the reserve, if set to past liquidations will be allowed
+        uint40 liquidationGracePeriodUntil;
+        //aToken address
+        address aTokenAddress;
+        // DEPRECATED on v3.2.0
+        address __deprecatedStableDebtTokenAddress;
+        //variableDebtToken address
+        address variableDebtTokenAddress;
+        // DEPRECATED on v3.4.0, should use the `RESERVE_INTEREST_RATE_STRATEGY` variable from the Pool contract
+        address __deprecatedInterestRateStrategyAddress;
+        //the current treasury balance, scaled
+        uint128 accruedToTreasury;
+        // In aave 3.3.0 this storage slot contained the `unbacked`
+        uint128 virtualUnderlyingBalance;
+        //the outstanding debt borrowed against this asset in isolation mode
+        uint128 isolationModeTotalDebt;
+        //the amount of underlying accounted for by the protocol
+        // DEPRECATED on v3.4.0. Moved into the same slot as accruedToTreasury for optimized storage access.
+        uint128 __deprecatedVirtualUnderlyingBalance;
+    }
+
+    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: DEPRECATED: 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: DEPRECATED: eMode category
+        //bit 176-211: DEPRECATED: unbacked mint cap
+        //bit 212-251: debt ceiling for isolation mode with (ReserveConfiguration::DEBT_CEILING_DECIMALS) decimals
+        //bit 252: DEPRECATED: virtual accounting is enabled for the reserve
+        //bit 253-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;
+    }
+
+    // DEPRECATED: kept for backwards compatibility, might be removed in a future version
+    struct EModeCategoryLegacy {
+        // each eMode category has a custom ltv and liquidation threshold
+        uint16 ltv;
+        uint16 liquidationThreshold;
+        uint16 liquidationBonus;
+        // DEPRECATED
+        address priceSource;
+        string label;
+    }
+
+    struct CollateralConfig {
+        uint16 ltv;
+        uint16 liquidationThreshold;
+        uint16 liquidationBonus;
+    }
+
+    struct EModeCategoryBaseConfiguration {
+        uint16 ltv;
+        uint16 liquidationThreshold;
+        uint16 liquidationBonus;
+        string label;
+    }
+
+    struct EModeCategory {
+        // each eMode category has a custom ltv and liquidation threshold
+        uint16 ltv;
+        uint16 liquidationThreshold;
+        uint16 liquidationBonus;
+        uint128 collateralBitmap;
+        string label;
+        uint128 borrowableBitmap;
+    }
+
+    enum InterestRateMode {
+        NONE,
+        __DEPRECATED,
+        VARIABLE
+    }
+
+    struct ReserveCache {
+        uint256 currScaledVariableDebt;
+        uint256 nextScaledVariableDebt;
+        uint256 currLiquidityIndex;
+        uint256 nextLiquidityIndex;
+        uint256 currVariableBorrowIndex;
+        uint256 nextVariableBorrowIndex;
+        uint256 currLiquidityRate;
+        uint256 currVariableBorrowRate;
+        uint256 reserveFactor;
+        ReserveConfigurationMap reserveConfiguration;
+        address aTokenAddress;
+        address variableDebtTokenAddress;
+        uint40 reserveLastUpdateTimestamp;
+    }
+
+    struct ExecuteLiquidationCallParams {
+        address liquidator;
+        uint256 debtToCover;
+        address collateralAsset;
+        address debtAsset;
+        address borrower;
+        bool receiveAToken;
+        address priceOracle;
+        uint8 borrowerEModeCategory;
+        address priceOracleSentinel;
+        address interestRateStrategyAddress;
+    }
+
+    struct ExecuteSupplyParams {
+        address user;
+        address asset;
+        address interestRateStrategyAddress;
+        uint256 amount;
+        address onBehalfOf;
+        uint16 referralCode;
+    }
+
+    struct ExecuteBorrowParams {
+        address asset;
+        address user;
+        address onBehalfOf;
+        address interestRateStrategyAddress;
+        uint256 amount;
+        InterestRateMode interestRateMode;
+        uint16 referralCode;
+        bool releaseUnderlying;
+        address oracle;
+        uint8 userEModeCategory;
+        address priceOracleSentinel;
+    }
+
+    struct ExecuteRepayParams {
+        address asset;
+        address user;
+        address interestRateStrategyAddress;
+        uint256 amount;
+        InterestRateMode interestRateMode;
+        address onBehalfOf;
+        bool useATokens;
+        address oracle;
+        uint8 userEModeCategory;
+    }
+
+    struct ExecuteWithdrawParams {
+        address user;
+        address asset;
+        address interestRateStrategyAddress;
+        uint256 amount;
+        address to;
+        address oracle;
+        uint8 userEModeCategory;
+    }
+
+    struct ExecuteEliminateDeficitParams {
+        address user;
+        address asset;
+        address interestRateStrategyAddress;
+        uint256 amount;
+    }
+
+    struct FinalizeTransferParams {
+        address asset;
+        address from;
+        address to;
+        uint256 scaledAmount;
+        uint256 scaledBalanceFromBefore;
+        uint256 scaledBalanceToBefore;
+        address oracle;
+        uint8 fromEModeCategory;
+    }
+
+    struct FlashloanParams {
+        address user;
+        address receiverAddress;
+        address[] assets;
+        uint256[] amounts;
+        uint256[] interestRateModes;
+        address interestRateStrategyAddress;
+        address onBehalfOf;
+        bytes params;
+        uint16 referralCode;
+        uint256 flashLoanPremium;
+        address addressesProvider;
+        address pool;
+        uint8 userEModeCategory;
+        bool isAuthorizedFlashBorrower;
+    }
+
+    struct FlashloanSimpleParams {
+        address user;
+        address receiverAddress;
+        address asset;
+        address interestRateStrategyAddress;
+        uint256 amount;
+        bytes params;
+        uint16 referralCode;
+        uint256 flashLoanPremium;
+    }
+
+    struct FlashLoanRepaymentParams {
+        address user;
+        uint256 amount;
+        uint256 totalPremium;
+        address asset;
+        address interestRateStrategyAddress;
+        address receiverAddress;
+        uint16 referralCode;
+    }
+
+    struct CalculateUserAccountDataParams {
+        UserConfigurationMap userConfig;
+        address user;
+        address oracle;
+        uint8 userEModeCategory;
+    }
+
+    struct ValidateBorrowParams {
+        ReserveCache reserveCache;
+        UserConfigurationMap userConfig;
+        address asset;
+        address userAddress;
+        uint256 amountScaled;
+        InterestRateMode interestRateMode;
+        address oracle;
+        uint8 userEModeCategory;
+        address priceOracleSentinel;
+    }
+
+    struct ValidateLiquidationCallParams {
+        ReserveCache debtReserveCache;
+        uint256 totalDebt;
+        uint256 healthFactor;
+        address priceOracleSentinel;
+        address borrower;
+        address liquidator;
+    }
+
+    struct CalculateInterestRatesParams {
+        uint256 unbacked;
+        uint256 liquidityAdded;
+        uint256 liquidityTaken;
+        uint256 totalDebt;
+        uint256 reserveFactor;
+        address reserve;
+        // @notice DEPRECATED in 3.4, but kept for backwards compatibility
+        bool usingVirtualBalance;
+        uint256 virtualUnderlyingBalance;
+    }
+
+    struct InitReserveParams {
+        address asset;
+        address aTokenAddress;
+        address variableDebtAddress;
+        uint16 reservesCount;
+        uint16 maxNumberReserves;
+    }
+}