@pendle/core-v2 5.2.2 → 5.2.3-beta

package/contracts/core/StandardizedYield/implementations/EtherFi/PendleWEEthSY.sol

@@ -1,100 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.23;
-
-import "../../SYBase.sol";
-import "../../../../interfaces/EtherFi/IEtherFiLiquidityPool.sol";
-import "../../../../interfaces/EtherFi/IEtherFiWEEth.sol";
-
-contract PendleWEEthSY is SYBase {
-    using PMath for int256;
-
-    address public immutable weETH;
-    address public immutable liquidityPool;
-    address public immutable eETH;
-    address public immutable referee;
-
-    constructor(address _weETH, address _referee) SYBase("SY ether.fi weETH", "SY-weETH", _weETH) {
-        weETH = _weETH;
-        liquidityPool = IEtherFiWEEth(_weETH).liquidityPool();
-        eETH = IEtherFiWEEth(_weETH).eETH();
-        referee = _referee;
-
-        _safeApproveInf(eETH, weETH);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-
-    function _deposit(address tokenIn, uint256 amountDeposited) internal override returns (uint256 amountSharesOut) {
-        if (tokenIn == NATIVE) {
-            IEtherFiLiquidityPool(liquidityPool).deposit{value: amountDeposited}(referee);
-        }
-        if (tokenIn != weETH) {
-            amountSharesOut = IEtherFiWEEth(weETH).wrap(_selfBalance(eETH));
-        } else {
-            amountSharesOut = amountDeposited;
-        }
-    }
-
-    function _redeem(
-        address receiver,
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal override returns (uint256 amountTokenOut) {
-        if (tokenOut == weETH) {
-            amountTokenOut = amountSharesToRedeem;
-        } else {
-            amountTokenOut = IEtherFiWEEth(weETH).unwrap(amountSharesToRedeem);
-        }
-        _transferOut(tokenOut, receiver, amountTokenOut);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               EXCHANGE-RATE
-    //////////////////////////////////////////////////////////////*/
-
-    function exchangeRate() public view override returns (uint256) {
-        return IEtherFiLiquidityPool(liquidityPool).amountForShare(1 ether);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                MISC FUNCTIONS FOR METADATA
-    //////////////////////////////////////////////////////////////*/
-
-    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
-        if (tokenIn == weETH) {
-            return amountTokenToDeposit;
-        } else {
-            return IEtherFiLiquidityPool(liquidityPool).sharesForAmount(amountTokenToDeposit);
-        }
-    }
-
-    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem) internal view override returns (uint256) {
-        if (tokenOut == weETH) {
-            return amountSharesToRedeem;
-        } else {
-            return IEtherFiLiquidityPool(liquidityPool).amountForShare(amountSharesToRedeem);
-        }
-    }
-
-    function getTokensIn() public view override returns (address[] memory res) {
-        return ArrayLib.create(weETH, eETH, NATIVE);
-    }
-
-    function getTokensOut() public view override returns (address[] memory res) {
-        return ArrayLib.create(weETH, eETH);
-    }
-
-    function isValidTokenIn(address token) public view override returns (bool) {
-        return token == NATIVE || token == eETH || token == weETH;
-    }
-
-    function isValidTokenOut(address token) public view override returns (bool) {
-        return token == eETH || token == weETH;
-    }
-
-    function assetInfo() external view override returns (AssetType, address, uint8) {
-        return (AssetType.TOKEN, eETH, 18);
-    }
-}

package/contracts/core/StandardizedYield/implementations/EtherFi/PendleWEEthkSY.sol

@@ -1,63 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.23;
-
-import "../PendleERC20SYUpg.sol";
-import "../../../../interfaces/EtherFi/IVedaTeller.sol";
-import "../../../../interfaces/EtherFi/IVedaAccountant.sol";
-
-contract PendleWEEthkSY is PendleERC20SYUpg {
-    using PMath for uint256;
-
-    // solhint-disable immutable-vars-naming
-    // solhint-disable const-name-snakecase
-    // solhint-disable ordering
-
-    address public constant weETHk = 0x7223442cad8e9cA474fC40109ab981608F8c4273;
-    address public constant vedaTeller = 0x929B44db23740E65dF3A81eA4aAB716af1b88474;
-    address public constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
-    address public constant WEETH = 0xCd5fE23C85820F7B72D0926FC9b05b43E359b7ee;
-    address public constant EETH = 0x35fA164735182de50811E8e2E824cFb9B6118ac2;
-    address public constant WSTETH = 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0;
-
-    address public immutable vedaAccountant;
-
-    constructor() PendleERC20SYUpg(weETHk) {
-        vedaAccountant = IVedaTeller(vedaTeller).accountant();
-    }
-
-    function approveAllForTeller() external {
-        _safeApproveInf(WETH, weETHk);
-        _safeApproveInf(WEETH, weETHk);
-        _safeApproveInf(EETH, weETHk);
-        _safeApproveInf(WSTETH, weETHk);
-    }
-
-    function _deposit(
-        address tokenIn,
-        uint256 amountDeposited
-    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
-        if (tokenIn == weETHk) {
-            return amountDeposited;
-        }
-        return IVedaTeller(vedaTeller).bulkDeposit(tokenIn, amountDeposited, 0, address(this));
-    }
-
-    function _previewDeposit(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal view virtual override returns (uint256 amountSharesOut) {
-        if (tokenIn == weETHk) {
-            return amountTokenToDeposit;
-        }
-        uint256 rate = IVedaAccountant(vedaAccountant).getRateInQuoteSafe(tokenIn);
-        amountSharesOut = amountTokenToDeposit.divDown(rate);
-    }
-
-    function isValidTokenIn(address token) public pure override returns (bool) {
-        return token == weETHk || token == WETH || token == WEETH || token == EETH || token == WSTETH;
-    }
-
-    function getTokensIn() public pure override returns (address[] memory res) {
-        return ArrayLib.create(weETHk, WETH, WEETH, EETH, WSTETH);
-    }
-}

package/contracts/core/StandardizedYield/implementations/EtherFi/PendleWEEthsSY.sol

@@ -1,63 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.23;
-
-import "../PendleERC20SYUpg.sol";
-import "../../../../interfaces/EtherFi/IVedaTeller.sol";
-import "../../../../interfaces/EtherFi/IVedaAccountant.sol";
-
-contract PendleWEEthsSY is PendleERC20SYUpg {
-    using PMath for uint256;
-
-    // solhint-disable immutable-vars-naming
-    // solhint-disable const-name-snakecase
-    // solhint-disable ordering
-
-    address public constant weETHs = 0x917ceE801a67f933F2e6b33fC0cD1ED2d5909D88;
-    address public constant vedaTeller = 0x99dE9e5a3eC2750a6983C8732E6e795A35e7B861;
-    address public constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
-    address public constant WEETH = 0xCd5fE23C85820F7B72D0926FC9b05b43E359b7ee;
-    address public constant EETH = 0x35fA164735182de50811E8e2E824cFb9B6118ac2;
-    address public constant WSTETH = 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0;
-
-    address public immutable vedaAccountant;
-
-    constructor() PendleERC20SYUpg(weETHs) {
-        vedaAccountant = IVedaTeller(vedaTeller).accountant();
-    }
-
-    function approveAllForTeller() external {
-        _safeApproveInf(WETH, weETHs);
-        _safeApproveInf(WEETH, weETHs);
-        _safeApproveInf(EETH, weETHs);
-        _safeApproveInf(WSTETH, weETHs);
-    }
-
-    function _deposit(
-        address tokenIn,
-        uint256 amountDeposited
-    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
-        if (tokenIn == weETHs) {
-            return amountDeposited;
-        }
-        return IVedaTeller(vedaTeller).bulkDeposit(tokenIn, amountDeposited, 0, address(this));
-    }
-
-    function _previewDeposit(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal view virtual override returns (uint256 amountSharesOut) {
-        if (tokenIn == weETHs) {
-            return amountTokenToDeposit;
-        }
-        uint256 rate = IVedaAccountant(vedaAccountant).getRateInQuoteSafe(tokenIn);
-        amountSharesOut = amountTokenToDeposit.divDown(rate);
-    }
-
-    function isValidTokenIn(address token) public pure override returns (bool) {
-        return token == weETHs || token == WETH || token == WEETH || token == EETH || token == WSTETH;
-    }
-
-    function getTokensIn() public pure override returns (address[] memory res) {
-        return ArrayLib.create(weETHs, WETH, WEETH, EETH, WSTETH);
-    }
-}

package/contracts/core/StandardizedYield/implementations/Flux/FluxTokenLib.sol

@@ -1,80 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "../../../../interfaces/Flux/IFluxErc20.sol";
-import "../../../../interfaces/Flux/IFluxInterestRateModel.sol";
-import "../../../libraries/Errors.sol";
-
-library FluxTokenLib {
-    uint256 private constant borrowRateMaxMantissa = 0.0005e16;
-
-    struct ExchangeRateComputationParams {
-        uint256 currentBlockNumber;
-        uint256 accrualBlockNumberPrior;
-        uint256 cashPrior;
-        uint256 borrowsPrior;
-        uint256 reservesPrior;
-        uint256 borrowRateMantissa;
-        uint256 timestampDelta;
-        uint256 simpleInterestFactor;
-        uint256 interestAccumulated;
-        uint256 totalBorrowsNew;
-        uint256 totalReservesNew;
-    }
-
-    function exchangeRateCurrentView(address fToken) internal view returns (uint256) {
-        ExchangeRateComputationParams memory params;
-
-        params.currentBlockNumber = block.number;
-        params.accrualBlockNumberPrior = IFluxErc20(fToken).accrualBlockNumber();
-
-        if (params.accrualBlockNumberPrior == params.currentBlockNumber) return IFluxErc20(fToken).exchangeRateStored();
-
-        /* Read the previous values out of storage */
-        params.cashPrior = IFluxErc20(fToken).getCash();
-        params.borrowsPrior = IFluxErc20(fToken).totalBorrows();
-        params.reservesPrior = IFluxErc20(fToken).totalReserves();
-
-        /* Calculate the current borrow interest rate */
-        params.borrowRateMantissa = IFluxInterestRateModel(IFluxErc20(fToken).interestRateModel()).getBorrowRate(
-            params.cashPrior,
-            params.borrowsPrior,
-            params.reservesPrior
-        );
-
-        assert(params.borrowRateMantissa <= borrowRateMaxMantissa);
-
-        params.timestampDelta = params.currentBlockNumber - params.accrualBlockNumberPrior;
-        params.simpleInterestFactor = params.borrowRateMantissa * params.timestampDelta;
-        params.interestAccumulated = (params.simpleInterestFactor * params.borrowsPrior) / 1e18;
-        params.totalBorrowsNew = params.interestAccumulated + params.borrowsPrior;
-
-        params.totalReservesNew =
-            (IFluxErc20(fToken).reserveFactorMantissa() * params.interestAccumulated) /
-            1e18 +
-            params.reservesPrior;
-
-        return
-            _calcExchangeRate(
-                IFluxErc20(fToken).totalSupply(),
-                params.cashPrior,
-                params.totalBorrowsNew,
-                params.totalReservesNew
-            );
-    }
-
-    function _calcExchangeRate(
-        uint256 totalSupply,
-        uint256 totalCash,
-        uint256 totalBorrows,
-        uint256 totalReserves
-    ) private pure returns (uint256) {
-        uint256 cashPlusBorrowsMinusReserves;
-        uint256 exchangeRate;
-
-        cashPlusBorrowsMinusReserves = totalCash + totalBorrows - totalReserves;
-        exchangeRate = (cashPlusBorrowsMinusReserves * 1e18) / totalSupply;
-
-        return exchangeRate;
-    }
-}

package/contracts/core/StandardizedYield/implementations/Flux/PendleFluxLendingSY.sol

@@ -1,103 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "./FluxTokenLib.sol";
-import "../../SYBase.sol";
-import "../../../../interfaces/Flux/IFluxErc20.sol";
-
-contract PendleFluxLendingSY is SYBase {
-    using PMath for uint256;
-
-    error FluxLendingError(uint256 errCode);
-
-    address public immutable fToken;
-    address public immutable underlying;
-
-    constructor(string memory _name, string memory _symbol, address _fToken) SYBase(_name, _symbol, _fToken) {
-        // underlying
-        fToken = _fToken;
-        underlying = IFluxErc20(_fToken).underlying();
-
-        _safeApproveInf(underlying, fToken);
-    }
-
-    function _deposit(
-        address tokenIn,
-        uint256 amountDeposited
-    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
-        if (tokenIn == fToken) {
-            return amountDeposited;
-        } else {
-            uint256 preBalance = _selfBalance(fToken);
-            uint256 errCode = IFluxErc20(fToken).mint(amountDeposited);
-            if (errCode != 0) revert FluxLendingError(errCode);
-            return _selfBalance(fToken) - preBalance;
-        }
-    }
-
-    function _redeem(
-        address receiver,
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal virtual override returns (uint256 amountTokenOut) {
-        if (tokenOut == fToken) {
-            amountTokenOut = amountSharesToRedeem;
-        } else {
-            uint256 preBalance = _selfBalance(tokenOut);
-            uint256 errCode = IFluxErc20(fToken).redeem(amountSharesToRedeem);
-            if (errCode != 0) revert FluxLendingError(errCode);
-            amountTokenOut = _selfBalance(tokenOut) - preBalance;
-        }
-        _transferOut(tokenOut, receiver, amountTokenOut);
-    }
-
-    function exchangeRate() public view virtual override returns (uint256) {
-        return FluxTokenLib.exchangeRateCurrentView(fToken);
-    }
-
-    function _previewDeposit(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal view override returns (uint256 /*amountSharesOut*/) {
-        if (tokenIn == fToken) {
-            return amountTokenToDeposit;
-        } else {
-            return amountTokenToDeposit.divDown(exchangeRate());
-        }
-    }
-
-    function _previewRedeem(
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal view override returns (uint256 /*amountTokenOut*/) {
-        if (tokenOut == fToken) {
-            return amountSharesToRedeem;
-        } else {
-            return amountSharesToRedeem.mulDown(exchangeRate());
-        }
-    }
-
-    function getTokensIn() public view virtual override returns (address[] memory res) {
-        res = new address[](2);
-        res[0] = fToken;
-        res[1] = underlying;
-    }
-
-    function getTokensOut() public view virtual override returns (address[] memory res) {
-        res = new address[](2);
-        res[0] = fToken;
-        res[1] = underlying;
-    }
-
-    function isValidTokenIn(address token) public view virtual override returns (bool) {
-        return token == fToken || token == underlying;
-    }
-
-    function isValidTokenOut(address token) public view virtual override returns (bool) {
-        return token == fToken || token == underlying;
-    }
-
-    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
-        return (AssetType.TOKEN, underlying, IERC20Metadata(underlying).decimals());
-    }
-}

package/contracts/core/StandardizedYield/implementations/GLP/GLPPreviewHelper.sol

@@ -1,135 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "../../../../interfaces/GMX/IGMXVault.sol";
-import "../../../../interfaces/GMX/IVaultPriceFeed.sol";
-
-abstract contract GLPPreviewHelper {
-    // Based on Vault functions
-
-    IGMXVault public immutable vault;
-    address internal immutable usdg;
-    uint256 public constant PRICE_PRECISION = 10 ** 30;
-    uint256 public constant BASIS_POINTS_DIVISOR = 10000;
-
-    constructor(address _vaultAddress) {
-        vault = IGMXVault(_vaultAddress);
-        usdg = vault.usdg();
-    }
-
-    function _buyUSDG(address _token, uint256 tokenAmount) internal view returns (uint256) {
-        tokenAmount = __transferIn(_token, tokenAmount);
-        assert(tokenAmount > 0);
-
-        uint256 price = vault.getMinPrice(_token);
-
-        uint256 usdgAmount = (tokenAmount * price) / PRICE_PRECISION;
-        usdgAmount = vault.adjustForDecimals(usdgAmount, _token, usdg);
-        require(usdgAmount > 0, "preview buyUSDG: usdgAmount must be > 0");
-
-        uint256 feeBasisPoints = __getFeeBasisPoints(
-            _token,
-            usdgAmount,
-            0,
-            vault.mintBurnFeeBasisPoints(),
-            vault.taxBasisPoints(),
-            true
-        );
-        uint256 amountAfterFees = __collectSwapFees(_token, tokenAmount, feeBasisPoints);
-        uint256 mintAmount = (amountAfterFees * price) / PRICE_PRECISION;
-        mintAmount = vault.adjustForDecimals(mintAmount, _token, usdg);
-
-        return mintAmount;
-    }
-
-    function _sellUSDG(address _token, uint256 usdgAmount) internal view returns (uint256) {
-        usdgAmount = __transferIn(usdg, usdgAmount);
-        assert(usdgAmount > 0);
-
-        uint256 redemptionAmount = vault.getRedemptionAmount(_token, usdgAmount);
-        require(redemptionAmount > 0, "preview sellUSDG: redemptionAmount must be > 0");
-
-        uint256 feeBasisPoints = __getFeeBasisPoints(
-            _token,
-            usdgAmount,
-            usdgAmount,
-            vault.mintBurnFeeBasisPoints(),
-            vault.taxBasisPoints(),
-            false
-        );
-        uint256 amountOut = __collectSwapFees(_token, redemptionAmount, feeBasisPoints);
-        require(amountOut > 0, "preview sellUSDG: amountOut must be > 0");
-
-        return amountOut;
-    }
-
-    function __transferIn(address _token, uint256 _amount) private view returns (uint256) {
-        uint256 prevBalance = vault.tokenBalances(_token);
-        uint256 nextBalance = IERC20(_token).balanceOf(address(vault)) + _amount;
-
-        return nextBalance - prevBalance;
-    }
-
-    function __collectSwapFees(
-        address /*_token*/,
-        uint256 _amount,
-        uint256 _feeBasisPoints
-    ) private pure returns (uint256) {
-        uint256 afterFeeAmount = (_amount * (BASIS_POINTS_DIVISOR - _feeBasisPoints)) / (BASIS_POINTS_DIVISOR);
-        return afterFeeAmount;
-    }
-
-    function __getFeeBasisPoints(
-        address _token,
-        uint256 _usdgDelta,
-        uint256 _burnedUsdg,
-        uint256 _feeBasisPoints,
-        uint256 _taxBasisPoints,
-        bool _increment
-    ) private view returns (uint256) {
-        if (!vault.hasDynamicFees()) {
-            return _feeBasisPoints;
-        }
-
-        uint256 initialAmount = vault.usdgAmounts(_token);
-        initialAmount = (initialAmount >= _burnedUsdg) ? initialAmount - _burnedUsdg : 0;
-
-        uint256 nextAmount = initialAmount + _usdgDelta;
-        if (!_increment) {
-            nextAmount = _usdgDelta > initialAmount ? 0 : initialAmount - _usdgDelta;
-        }
-
-        uint256 targetAmount = __getTargetUsdgAmount(_token, _burnedUsdg);
-        if (targetAmount == 0) {
-            return _feeBasisPoints;
-        }
-
-        uint256 initialDiff = initialAmount > targetAmount
-            ? initialAmount - targetAmount
-            : targetAmount - initialAmount;
-        uint256 nextDiff = nextAmount > targetAmount ? nextAmount - targetAmount : targetAmount - nextAmount;
-
-        // action improves relative asset balance
-        if (nextDiff < initialDiff) {
-            uint256 rebateBps = (_taxBasisPoints * initialDiff) / targetAmount;
-            return rebateBps > _feeBasisPoints ? 0 : _feeBasisPoints - rebateBps;
-        }
-
-        uint256 averageDiff = (initialDiff + nextDiff) / 2;
-        if (averageDiff > targetAmount) {
-            averageDiff = targetAmount;
-        }
-        uint256 taxBps = (_taxBasisPoints * averageDiff) / targetAmount;
-        return _feeBasisPoints + taxBps;
-    }
-
-    function __getTargetUsdgAmount(address _token, uint256 _burnedUsdg) private view returns (uint256) {
-        uint256 supply = IERC20(usdg).totalSupply() - _burnedUsdg;
-        if (supply == 0) {
-            return 0;
-        }
-        uint256 weight = vault.tokenWeights(_token);
-        return (weight * supply) / vault.totalTokenWeights();
-    }
-}

package/contracts/core/StandardizedYield/implementations/GLP/GMTokenPricingHelper.sol

@@ -1,115 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "../../../libraries/BoringOwnableUpgradeable.sol";
-import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
-
-interface IGMXV2Oracle {
-    function getPriceFeedMultiplier(address dataStore, address token) external view returns (uint256);
-}
-
-interface IGMXV2DataStore {
-    function getAddress(bytes32 key) external view returns (address);
-}
-
-interface IGMXV2Reader {
-    struct PriceProps {
-        uint256 min;
-        uint256 max;
-    }
-    struct MarketProps {
-        address marketToken;
-        address indexToken;
-        address longToken;
-        address shortToken;
-    }
-    struct MarketPoolValueInfoProps {
-        int256 poolValue;
-        int256 longPnl;
-        int256 shortPnl;
-        int256 netPnl;
-        uint256 longTokenAmount;
-        uint256 shortTokenAmount;
-        uint256 longTokenUsd;
-        uint256 shortTokenUsd;
-        uint256 totalBorrowingFees;
-        uint256 borrowingFeePoolFactor;
-        uint256 impactPoolAmount;
-    }
-
-    function getMarketTokenPrice(
-        address dataStore,
-        MarketProps memory market,
-        PriceProps memory indexTokenPrice,
-        PriceProps memory longTokenPrice,
-        PriceProps memory shortTokenPrice,
-        bytes32 pnlFactorType,
-        bool maximize
-    ) external view returns (int256, MarketPoolValueInfoProps memory);
-}
-
-contract GMTokenPricingHelper is BoringOwnableUpgradeable, UUPSUpgradeable {
-    uint256 constant FLOAT_PRECISION = 10 ** 30;
-    bytes32 public constant MARKET_TOKEN = keccak256(abi.encode("MARKET_TOKEN"));
-    bytes32 public constant INDEX_TOKEN = keccak256(abi.encode("INDEX_TOKEN"));
-    bytes32 public constant LONG_TOKEN = keccak256(abi.encode("LONG_TOKEN"));
-    bytes32 public constant SHORT_TOKEN = keccak256(abi.encode("SHORT_TOKEN"));
-    bytes32 public constant PRICE_FEED = keccak256(abi.encode("PRICE_FEED"));
-    bytes32 public constant MAX_PNL_FACTOR_FOR_DEPOSITS = keccak256(abi.encode("MAX_PNL_FACTOR_FOR_DEPOSITS"));
-
-    IGMXV2Oracle constant oracle = IGMXV2Oracle(0xa11B501c2dd83Acd29F6727570f2502FAaa617F2);
-    IGMXV2DataStore constant datastore = IGMXV2DataStore(0xFD70de6b91282D8017aA4E741e9Ae325CAb992d8);
-    IGMXV2Reader constant reader = IGMXV2Reader(0xf60becbba223EEA9495Da3f606753867eC10d139);
-
-    constructor() initializer {}
-
-    function getPrice(address gm) external view returns (uint256) {
-        IGMXV2Reader.MarketProps memory prop = _getMarketProps(datastore, gm);
-        (int256 marketPrice, ) = reader.getMarketTokenPrice(
-            address(datastore),
-            prop,
-            _getTokenPrice(prop.indexToken),
-            _getTokenPrice(prop.longToken),
-            _getTokenPrice(prop.shortToken),
-            MAX_PNL_FACTOR_FOR_DEPOSITS,
-            true
-        );
-
-        // price from gmx is in based 30 when token decimals is 18
-        // while GM token should always be 18 decimals
-        return uint256(marketPrice) / 10 ** 12;
-    }
-
-    function _getTokenPrice(address token) internal view returns (IGMXV2Reader.PriceProps memory price) {
-        (, int256 latestAnswer, , , ) = IChainlinkAggregator(datastore.getAddress(_priceFeedKey(token)))
-            .latestRoundData();
-
-        uint256 multipler = oracle.getPriceFeedMultiplier(address(datastore), token);
-        uint256 adjustedPrice = (uint256(latestAnswer) * multipler) / FLOAT_PRECISION;
-        return IGMXV2Reader.PriceProps({min: adjustedPrice, max: adjustedPrice});
-    }
-
-    function _getMarketProps(
-        IGMXV2DataStore dataStore,
-        address key
-    ) internal view returns (IGMXV2Reader.MarketProps memory) {
-        IGMXV2Reader.MarketProps memory prop;
-        prop.marketToken = dataStore.getAddress(keccak256(abi.encode(key, MARKET_TOKEN)));
-        prop.indexToken = dataStore.getAddress(keccak256(abi.encode(key, INDEX_TOKEN)));
-        prop.longToken = dataStore.getAddress(keccak256(abi.encode(key, LONG_TOKEN)));
-        prop.shortToken = dataStore.getAddress(keccak256(abi.encode(key, SHORT_TOKEN)));
-        return prop;
-    }
-
-    function _priceFeedKey(address token) internal pure returns (bytes32) {
-        return keccak256(abi.encode(PRICE_FEED, token));
-    }
-
-    /////////////////// UPGRADABLE LOGIC ///////////////////////////
-    function initialize() external initializer {
-        __BoringOwnable_init();
-    }
-
-    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
-}