Alto Money v1

function readChainlinkFeed(uint256 quoteAmount, ChainlinkNode memory config) public view returns (uint256) {    // ... validation ...        uint256 price = uint256(ratio);    uint256 powFeed = 10 ** config.feed.decimals();    uint256 powIn = 10 ** config.inDecimals;    uint256 powOut = 10 ** config.outDecimals;        if (config.direction == ConversionDirection.IN_TO_OUT) {        // quoteAmount = quoteAmount * ratio / 10^feedDecimals * 10^outDecimals / 10^inDecimals        quoteAmount = FixedPointMath.divideWithRounding(quoteAmount, price * powOut, powFeed * powIn, false);    } else {        // quoteAmount = quoteAmount * 10^feedDecimals / ratio * 10^outDecimals / 10^inDecimals        quoteAmount = FixedPointMath.divideWithRounding(quoteAmount, powFeed * powOut, price * powIn, false);    }        return quoteAmount;}

function readChainlinkFeed(uint256 quoteAmount, ChainlinkNode memory config) public view returns (uint256) {    // ... validation ...        uint256 price = uint256(ratio);    uint256 powFeed = 10 ** config.feed.decimals();    uint256 powIn = 10 ** config.inDecimals;    uint256 powOut = 10 ** config.outDecimals;        if (config.direction == ConversionDirection.IN_TO_OUT) {-       quoteAmount = FixedPointMath.divideWithRounding(quoteAmount, price * powOut, powFeed * powIn, false);+       quoteAmount = _mulDiv(quoteAmount * price, powOut, powFeed * powIn);    } else {-       quoteAmount = FixedPointMath.divideWithRounding(quoteAmount, powFeed * powOut, price * powIn, false);+       quoteAmount = _mulDiv(quoteAmount * powFeed, powOut, price * powIn);    }        return quoteAmount;}

function readChainlinkFeed(uint256 baseAmount, ChainlinkNode memory config) public view returns (uint256) {    // ... validation ...        uint256 price = uint256(ratio);    uint256 feedDecimals = config.feed.decimals();        // Calculate net decimal adjustment    (uint256 numeratorPow, uint256 denominatorPow) =         _calculateDecimalAdjustment(config.outDecimals, config.inDecimals, feedDecimals);        if (config.direction == ConversionDirection.IN_TO_OUT) {        baseAmount = baseAmount * price * numeratorPow / denominatorPow;    } else {        baseAmount = baseAmount * numeratorPow / (price * denominatorPow);    }        return baseAmount;}
function _calculateDecimalAdjustment(    uint256 outDecimals,    uint256 inDecimals,    uint256 feedDecimals) internal pure returns (uint256 numeratorPow, uint256 denominatorPow) {    int256 exponentDiff;        if (direction == ConversionDirection.IN_TO_OUT) {        // For IN_TO_OUT: outDecimals / (feedDecimals + inDecimals)        // Net exponent: outDecimals - feedDecimals - inDecimals        exponentDiff = int256(outDecimals) - int256(feedDecimals) - int256(inDecimals);    } else {        // For OUT_TO_IN: (feedDecimals + outDecimals) / inDecimals        // Net exponent: feedDecimals + outDecimals - inDecimals        exponentDiff = int256(feedDecimals) + int256(outDecimals) - int256(inDecimals);    }        numeratorPow = 1;    denominatorPow = 1;        if (exponentDiff > 0) {        numeratorPow = 10 ** uint256(exponentDiff);    } else if (exponentDiff < 0) {        denominatorPow = 10 ** uint256(-exponentDiff);    }}

function deployWbtcOracle(address owner) public returns (address) {    ChainlinkNode[] memory chainlinkNodes = new ChainlinkNode[](2);        // First feed: WBTC/BTC ratio    chainlinkNodes[0] = ChainlinkNode({        feed: AggregatorV3Interface(CHAINLINK_WBTC_BTC_RATIO_FEED),        direction: ConversionDirection.IN_TO_OUT,        stalePeriod: 26 hours,        inDecimals: 8,        outDecimals: 8    });        // Second feed: BTC/USD price    chainlinkNodes[1] = ChainlinkNode({        feed: AggregatorV3Interface(CHAINLINK_BTC_USD_PRICE_FEED),        direction: ConversionDirection.IN_TO_OUT,        stalePeriod: 2 hours,        inDecimals: 8,        outDecimals: 46    });        return address(new AltoMultiChainlinkLendingOracle(owner, chainlinkNodes));}

function deployCbbtcOracle(address owner) public returns (address) {    ChainlinkNode[] memory chainlinkNodes = new ChainlinkNode[](1);        chainlinkNodes[0] = ChainlinkNode({        feed: AggregatorV3Interface(CHAINLINK_BTC_USD_PRICE_FEED),        direction: ConversionDirection.IN_TO_OUT,        stalePeriod: 2 hours,        inDecimals: 8,        outDecimals: 46    });        return address(new AltoMultiChainlinkLendingOracle(owner, chainlinkNodes));}
function deployTbtcOracle(address owner) public returns (address) {    ChainlinkNode[] memory chainlinkNodes = new ChainlinkNode[](1);        chainlinkNodes[0] = ChainlinkNode({        feed: AggregatorV3Interface(CHAINLINK_BTC_USD_PRICE_FEED),        direction: ConversionDirection.IN_TO_OUT,        stalePeriod: 2 hours,        inDecimals: 18,        outDecimals: 36    });        return address(new AltoMultiChainlinkLendingOracle(owner, chainlinkNodes));}

function deployCbbtcOracle(address owner) public returns (address) {    ChainlinkNode[] memory chainlinkNodes = new ChainlinkNode[](1);        chainlinkNodes[0] = ChainlinkNode({        feed: AggregatorV3Interface(CHAINLINK_CBBTC_USD_PRICE_FEED), // cbBTC/USD feed        direction: ConversionDirection.IN_TO_OUT,        stalePeriod: 2 hours,        inDecimals: 8,        outDecimals: 46    });        return address(new AltoMultiChainlinkLendingOracle(owner, chainlinkNodes));}

function deployTbtcOracle(address owner) public returns (address) {    ChainlinkNode[] memory chainlinkNodes = new ChainlinkNode[](1);        chainlinkNodes[0] = ChainlinkNode({        feed: AggregatorV3Interface(CHAINLINK_TBTC_USD_PRICE_FEED), // tBTC/USD feed        direction: ConversionDirection.IN_TO_OUT,        stalePeriod: 2 hours,        inDecimals: 18,        outDecimals: 36    });        return address(new AltoMultiChainlinkLendingOracle(owner, chainlinkNodes));}

function _computeMaxRatio(ERC4626RatioNode memory _erc4626RatioNode) internal view returns (uint256) {    uint256 timePassed = block.timestamp - _erc4626RatioNode.initialTimestamp;    uint256 maxGrowthPerYear = _erc4626RatioNode.initialRatio * _erc4626RatioNode.maxYearlyGrowthRatioWad;    uint256 maxAllowedGrowthRatio = maxGrowthPerYear * timePassed / MATH_PRECISION / SECONDS_PER_YEAR;    return _erc4626RatioNode.initialRatio + maxAllowedGrowthRatio;}

function _validateERC4626RatioParams(ERC4626RatioNode memory _erc4626RatioNode) internal view {-   if (_erc4626RatioNode.initialRatio == 0) {-       revert ModuleERC4626RatioInvalidInput();-   }-   if (_erc4626RatioNode.initialTimestamp > block.timestamp) {-       revert ModuleERC4626RatioInvalidInput();-   }    if (_erc4626RatioNode.maxYearlyGrowthRatioWad == 0) {        revert ModuleERC4626RatioInvalidInput();    }}
+function _initializeERC4626RatioParams(+    uint256 maxYearlyGrowthRatioWad+) internal {+    erc4626RatioNode = ERC4626RatioNode({+        initialRatio: _getRatioOfWrappedAssetToUnderlyingAsset(),+        initialTimestamp: block.timestamp,+        maxYearlyGrowthRatioWad: maxYearlyGrowthRatioWad+    });+}

function startTwapPeriod(uint256 _initialPrice) external onlyOwner {    if (lastPriceUpdateTimestamp != 0) {        revert AltoRewardsOracleAlreadyStartedTwapPeriod();    }        lastPriceUpdateTimestamp = block.timestamp;    cachedPrice = _initialPrice;        emit PriceUpdated(block.timestamp, cachedPrice, 0);}

function updatePrice() external {    // ... validation checks ...        // reads the amount of out currency for 1 full unit of in-currency    uint256 newPrice = readUniswapPool(inTokenOneUnit, uniswapNode);        // converts the price from the out-currency to chainlinkNode.outDecimals decimals    cachedPrice = readChainlinkFeed(newPrice, chainlinkNode);        lastPriceUpdateTimestamp = block.timestamp;        emit PriceUpdated(block.timestamp, newPrice, oldPrice);}

function startTwapPeriod() external onlyOwner {    if (lastPriceUpdateTimestamp != 0) {        revert AltoRewardsOracleAlreadyStartedTwapPeriod();    }        _updatePrice();}
function updatePrice() external {    if (lastPriceUpdateTimestamp == 0) {        revert AltoRewardsOracleNotInitiated();    }        if (block.timestamp - lastPriceUpdateTimestamp <= priceUpdateCooldownPeriod) {        revert AltoRewardsOracleTooEarlyToUpdatePrice();    }        _updatePrice();}
function _updatePrice() internal {    uint256 oldPrice = cachedPrice;        // reads the amount of out currency for 1 full unit of in-currency    uint256 newPrice = readUniswapPool(inTokenOneUnit, uniswapNode);        // converts the price from the out-currency to chainlinkNode.outDecimals decimals    cachedPrice = readChainlinkFeed(newPrice, chainlinkNode);        lastPriceUpdateTimestamp = block.timestamp;        emit PriceUpdated(block.timestamp, newPrice, oldPrice);}

function _updateInTokenOneUnitFromUniswapNode() internal {    address inToken = uniswapNode.direction == ConversionDirection.IN_TO_OUT        ? IUniswapV3Pool(uniswapNode.pool).token0()        : IUniswapV3Pool(uniswapNode.pool).token1();    inTokenOneUnit = 10 ** IERC20Metadata(inToken).decimals();}

// In AltoRewardsDistributor._calculatePaymentAmount()uint256 rewardPriceValue = IUsdOracle(rewardTokenUsdOracle).getPrice();// ... price calculation logic ...

function _updateInTokenOneUnitFromUniswapNode() internal {    address token0 = IUniswapV3Pool(uniswapNode.pool).token0();    address token1 = IUniswapV3Pool(uniswapNode.pool).token1();        address inToken = uniswapNode.direction == ConversionDirection.IN_TO_OUT ? token0 : token1;    address outToken = uniswapNode.direction == ConversionDirection.IN_TO_OUT ? token1 : token0;        // Validate that inToken appears to be ALTO and outToken appears to be a stablecoin    // This could check token symbols, known addresses, or other heuristics    if (!_isAltoToken(inToken) || !_isEther(outToken)) {        revert AltoRewardsOracleInvalidDirection();    }        inTokenOneUnit = 10 ** IERC20Metadata(inToken).decimals();}

function updateChainlinkNodes(ChainlinkNode[] memory _chainlinkNodes) external onlyOwner {    if (_chainlinkNodes.length == 0) {        revert AltoMultiChainlinkLendingOracleInvalidInput();    }    emit SetChainlinkNodes(chainlinkNodes, _chainlinkNodes);    delete chainlinkNodes;    for (uint256 i = 0; i < _chainlinkNodes.length; i++) {        _validateChainlinkParams(_chainlinkNodes[i]);        chainlinkNodes.push(_chainlinkNodes[i]);    }}

function updateChainlinkNode(ChainlinkNode memory _chainlinkNode) external onlyOwner {    _validateChainlinkParams(_chainlinkNode);    emit SetChainlinkNode(chainlinkNode, _chainlinkNode);    chainlinkNode = _chainlinkNode;}
function updateUniswapNode(UniswapNode memory _uniswapNode) external onlyOwner {    _validateUniswapParams(_uniswapNode);    emit SetUniswapNode(uniswapNode, _uniswapNode);    uniswapNode = _uniswapNode;    _updateInTokenOneUnitFromUniswapNode();}

function _getQuoteAtTick(int24 tick, uint256 baseAmount, ConversionDirection direction)    internal    pure    returns (uint256 quoteAmount){    uint256 ratio = _getRatioAtTick(tick);        quoteAmount = (direction == ConversionDirection.IN_TO_OUT)        ? _mulDiv(ratio, baseAmount, 1e18)        : _mulDiv(1e18, baseAmount, ratio);}

// In _calculatePaymentAmount()uint256 rewardPriceValue = IUsdOracle(rewardTokenUsdOracle).getPrice(); // Already rounded downuint256 tokenPrice = IUsdOracle(paymentTokenConfig.oracle).getPrice();
uint256 rewardToPurchaseCostUsd = rewardsPurchaseAmount.divideWithRounding(    rewardPriceValue,  // Uses the already-rounded-down price    10 ** REWARD_TOKEN.decimals,    true // round up to avoid zero payment);

function _getQuoteAtTick(    int24 tick,     uint256 baseAmount,     ConversionDirection direction,    bool roundUp)    internal    pure    returns (uint256 quoteAmount){    uint256 ratio = _getRatioAtTick(tick);        if (direction == ConversionDirection.IN_TO_OUT) {        quoteAmount = roundUp             ? _mulDivRoundingUp(ratio, baseAmount, 1e18)            : _mulDiv(ratio, baseAmount, 1e18);    } else {        quoteAmount = roundUp            ? _mulDivRoundingUp(1e18, baseAmount, ratio)            : _mulDiv(1e18, baseAmount, ratio);    }}
function _mulDivRoundingUp(uint256 a, uint256 b, uint256 denominator)     internal     pure     returns (uint256 result) {    result = _mulDiv(a, b, denominator);    if (mulmod(a, b, denominator) > 0) {        result++;    }}

function _getQuoteAtTick(int24 tick, uint256 baseAmount, ConversionDirection direction)    internal    pure    returns (uint256 quoteAmount){    uint256 ratio = _getRatioAtTick(tick);        if (direction == ConversionDirection.IN_TO_OUT) {        quoteAmount = _mulDiv(ratio, baseAmount, 1e18);        if (mulmod(ratio, baseAmount, 1e18) > 0) {            quoteAmount++;        }    } else {        quoteAmount = _mulDiv(1e18, baseAmount, ratio);        if (mulmod(1e18, baseAmount, ratio) > 0) {            quoteAmount++;        }    }}

function readLatestRatio(uint256 latestRatio, ERC4626RatioNode memory _erc4626RatioNode)    public    view    returns (uint256){    uint256 currentRatio = latestRatio;    if (currentRatio == 0) return 0;
    uint256 maxRatio = _computeMaxRatio(_erc4626RatioNode);
    if (currentRatio > maxRatio) {        return maxRatio;  // Caps growth but doesn't enforce a minimum    } else {        return currentRatio;    }}

/// @title Module ERC4626 Ratio/// @notice Utility contract used to read the ratio of ERC4626 vaults and LSTs with growth caps/// @dev IMPORTANT ASSUMPTION: This module assumes that all underlying asset ratios are /// monotonically increasing (never decrease). This holds true for:/// - Liquid staking tokens (wstETH, rETH, mETH) where ratios represent accumulated rewards/// - Yield-bearing tokens (sUSDe) where ratios represent accrued interest/// @dev If an asset experiences slashing or losses causing the ratio to decrease, this /// module will report the decreased value without safeguards. Such assets should either:/// 1. Not be integrated into the protocol, or/// 2. Use a different oracle mechanism that includes minimum ratio enforcementcontract ModuleERC4626Ratio {    // ...        /// @notice Returns the current capped ratio    /// @dev ROUNDING: Always returns floor value (rounds down) to avoid overvaluing collateral    /// @dev This is appropriate for lending scenarios where users borrow against this collateral    function readLatestRatio(uint256 latestRatio, ERC4626RatioNode memory _erc4626RatioNode)        public        view        returns (uint256)    {        // ...    }}

/// @notice Gets a quote for an amount of input currency and returns the output currency/// @param quoteAmount The input currency amount to get the price of in output currency/// @param config Uniswap configuration/// @return The value of the `quoteAmount` in output currency/// @dev ROUNDING: This function uses floor division (rounds down)/// @dev APPROPRIATE USES:///      - Pricing collateral in lending protocols (conservative valuation)///      - Calculating amounts when USERS RECEIVE tokens/// @dev INAPPROPRIATE USES:///      - Pricing assets when users make payments (use ceiling division instead)///      - Any scenario where protocol should receive more rather than lessfunction readUniswapPool(uint256 quoteAmount, UniswapNode memory config)     public     view     returns (uint256){    // ...}

/// @title Alto Protocol Oracle Usage Guidelines/// @notice This document describes the correct usage of oracle functions based on rounding requirements////// LENDING/COLLATERAL SCENARIOS (round DOWN):/// - When valuing user collateral deposits/// - When calculating maximum borrowing capacity/// - Goal: Be conservative to keep protocol solvent/// - Use: AltoMultiChainlinkLendingOracle, ModuleERC4626Ratio (as-is)////// PAYMENT SCENARIOS (round UP):/// - When calculating payment amounts users must transfer/// - When pricing tokens users are purchasing/// - Goal: Prevent value leakage from accumulated rounding/// - Use: Modify oracle to support ceiling division, or round up at consumer level////// REVERSE FLOWS (not currently supported):/// - If protocol adds: deposit DUSD → borrow collateral///   Then: Oracle must round UP collateral value/// - If protocol adds: sell ALTO → receive stablecoins  ///   Then: Oracle must round DOWN ALTO price

/// @notice Validates and stores the ERC4626 ratio configuration/// @dev INVARIANT: initialRatio must be ≤ current on-chain ratio/// @dev INVARIANT: Over time, ratio should only increase (monotonicity assumption)/// @dev SECURITY: If ratio decreases, it indicates asset losses/slashing - should trigger alertsfunction _validateERC4626RatioParams(ERC4626RatioNode memory _erc4626RatioNode) internal view {    // ...}

function readChainlinkFeed(uint256 quoteAmount, ChainlinkNode memory config) public view returns (uint256) {    (uint80 roundId, int256 ratio,, uint256 updatedAt, uint80 answeredInRound) = config.feed.latestRoundData();    if (ratio <= 0 || roundId > answeredInRound || block.timestamp - updatedAt > config.stalePeriod) {        revert ModuleChainlinkInvalidRate();    }        // External call to get decimals    uint256 price = uint256(ratio);    uint256 powFeed = 10 ** config.feed.decimals();  // <-- External call on every read    uint256 powIn = 10 ** config.inDecimals;    uint256 powOut = 10 ** config.outDecimals;        // ... price calculation ...}

struct ChainlinkNode {    AggregatorV3Interface feed;    ConversionDirection direction;    uint32 stalePeriod;    uint8 inDecimals;    uint8 outDecimals;    uint8 feedDecimals;  // Add cached feed decimals}

function _validateChainlinkParams(ChainlinkNode memory config) internal view {    if (address(config.feed) == address(0) || config.stalePeriod == 0) {        revert ModuleChainlinkInvalidInput();    }        // Validate that cached feedDecimals matches actual feed decimals    if (config.feedDecimals != config.feed.decimals()) {        revert ModuleChainlinkInvalidInput();    }        // Bound decimals to prevent overflow and DoS via extreme values    if (config.inDecimals + config.outDecimals > 54) {        revert ModuleChainlinkInvalidInput();    }}

function readChainlinkFeed(uint256 quoteAmount, ChainlinkNode memory config) public view returns (uint256) {    (uint80 roundId, int256 ratio,, uint256 updatedAt, uint80 answeredInRound) = config.feed.latestRoundData();    if (ratio <= 0 || roundId > answeredInRound || block.timestamp - updatedAt > config.stalePeriod) {        revert ModuleChainlinkInvalidRate();    }        uint256 price = uint256(ratio);    uint256 powFeed = 10 ** config.feedDecimals;  // Use cached value instead of external call    uint256 powIn = 10 ** config.inDecimals;    uint256 powOut = 10 ** config.outDecimals;        // ... rest of function ...}