A tricky ternary operator

We all know how to use ternary operators. Some of them can be really creative, like the one below:

uint a = 100;
uint b = 10;

bool aIsSmallerOrMultiple = a < b ? true : a % b == 0 ? true : false;

But even if you're good at it, there are still logical situations where you can use it wrongly. Let's take a look on the Beanstalk contest.

The `LibChainlinkOracle::getTokenPrice` function has a parameter of `lookback` in order to determine how many seconds ago do we want to obtain the twap of a chainlink price feed. However, this is implemented in a wrong way.

When the function is called, it returns a different price calculation depending on the `lookback` parameter passed to the function:

    function getTokenPrice(
        address priceAggregatorAddress,
        uint256 maxTimeout,
        uint256 lookback
    ) internal view returns (uint256 price) {
        return
            lookback > 0
                ? getPrice(priceAggregatorAddress, maxTimeout)
                : getTwap(priceAggregatorAddress, maxTimeout, lookback);
    }

In this case the ternary operator returns the function `getPrice` (instantaneous price) when lookback > 0 and `getTwap` when lookback == 0. As we can see, the conditional for returning the different price computation is wrong because it returns the twap price when lookback = 0, which is basically the instantaneous price and it returns the current price when the lookback parameter is greater than 0, when it should return the twap according to the amount of lookback passed.

The correct behaviour should be that when `lookback` is set to 0, it should return the instantaneous price "`getPrice`" and when it is greater than 0 it should return the "`getTwap`" function passing it the lookback parameter.

Anyway, even if you know how to write ternary operators, you should still be aware of the logic flaws in them.

Read the full report here (H-01):

Link: https://codehawks.cyfrin.io/c/2024-05-beanstalk-the-finale/results/?lt=contest&page=1&sc=reward&sj=reward&t=report