clone QuantAMM contracts

Author: elshan-eth

contracts/ChainlinkOracle.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.20;
+
+import "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
+import "./OracleWrapper.sol";
+
+/// @title ChainlinkOracle contract based on the underlying QuantAMM oracle wrapper
+/// @notice Contains the logic for retrieving data from a Chainlink oracle and converting it to the QuantAMM format using the oracle wrapper contract
+contract ChainlinkOracle is OracleWrapper {
+    AggregatorV3Interface internal immutable priceFeed;
+
+    ///@notice Difference of feed result to 18 decimals. We store the difference instead of the oracle decimals for optimization reasons (saves a subtraction in _getData)
+    uint internal immutable normalizationFactor;
+
+    /// @param _chainlinkFeed the address of the Chainlink oracle to wrap
+    constructor(address _chainlinkFeed) {
+        require(_chainlinkFeed != address(0), "INVADDR"); //Invalid address provided
+        priceFeed = AggregatorV3Interface(_chainlinkFeed);
+        // Chainlink oracles have <= 18 decimals, cannot underflow
+        normalizationFactor = 18 - priceFeed.decimals();
+    }
+
+    /// @notice Returns the latest data from the oracle in the QuantAMM format
+    /// @return data the latest data from the oracle in the QuantAMM format
+    /// @return timestamp the timestamp of the data retrieval
+    function _getData() internal view override returns (int216, uint40) {
+        (, /*uint80 roundID*/ int data, , /*uint startedAt*/ uint timestamp /*uint80 answeredInRound*/, ) = priceFeed
+            .latestRoundData();
+        require(data > 0, "INVLDDATA");
+        data = data * int(10 ** normalizationFactor);
+        return (int216(data), uint40(timestamp)); // Overflow of data is extremely improbable and uint40 is large enough for timestamps for a very long time
+    }
+}

contracts/CustomPool.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import "./OracleWrapper.sol";
+
+/// @notice For tokens where no direct oracle / price feeds exists, multiple oracle wrappers can be combined to one.
+contract MultiHopOracle is OracleWrapper {
+    /// @notice Configuration for one hop
+    /// @dev Fits in one storage slot
+    struct HopConfig {
+        OracleWrapper oracle;
+        /// @notice Set to true if the result should be inverted, e.g. if we have TOK1/TOK2 but want to multiply by TOK2/TOK1 (i.e., divide by TOK1/TOK2)
+        bool invert;
+    }
+
+    /// @notice configuration for the oracles
+    HopConfig[] public oracles;
+
+    constructor(HopConfig[] memory _oracles) {
+        //CODEHAWKS INFO /s/716
+        require(_oracles.length > 0, "NOORACLES");
+        for (uint i = 0; i < _oracles.length; i++) {
+            //CODEHAWKS INFO /s/716
+            require(address(_oracles[i].oracle) != address(0), "INVORACLE");
+            oracles.push(_oracles[i]);
+        }
+    }
+
+    /// @notice Returns the latest data from one oracle hopping across n oracles
+    /// @return data the latest data from the oracle in the QuantAMM format
+    /// @return timestamp the timestamp of the data retrieval
+    function _getData() internal view override returns (int216 data, uint40 timestamp) {
+        HopConfig memory firstOracle = oracles[0];
+        (data, timestamp) = firstOracle.oracle.getData();
+        if (firstOracle.invert) {
+            data = 10 ** 36 / data; // 10^36 (i.e., 1 with 18 decimals * 10^18) to get the inverse with 18 decimals.
+            // 10**36 is automatically precomputed by the compiler, no explicit caching needed
+        }
+        uint256 oracleLength = oracles.length;
+
+        for (uint i = 1; i < oracleLength; ) {
+            HopConfig memory oracleConfig = oracles[i];
+            (int216 oracleRes, uint40 oracleTimestamp) = oracleConfig.oracle.getData();
+            if (oracleTimestamp < timestamp) {
+                timestamp = oracleTimestamp; // Return minimum timestamp
+            }
+
+            // depends which way the oracle conversion is happening
+            if (oracleConfig.invert) {
+                data = (data * 10 ** 18) / oracleRes;
+            } else {
+                data = (data * oracleRes) / 10 ** 18;
+            }
+            unchecked {
+                ++i;
+            }
+        }
+    }
+}

contracts/CustomPoolFactory.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+/// @notice Generic wrapper around an arbitrary oracle that returns normalized values.
+abstract contract OracleWrapper {
+    //CODEHAWKS INFO /s/294 remove unused enum
+
+    /// @notice Get the data of the underlying oracle, interpretation of data depends on oracle type
+    /// @param data The underlying data (can be negative), normalized to 18 decimals
+    /// @return data Retrieved oracle data
+    /// @return timestamp Last update timestamp
+    function getData() public view returns (int216 data, uint40 timestamp) {
+        (data, timestamp) = _getData();
+        require(timestamp > 0, "INVORCLVAL"); // Sanity check in case oracle returns invalid values
+    }
+
+    /// @notice Get data from oracle, to be implemented by child contracts. Needs to return data with 18 decimals
+    function _getData() internal view virtual returns (int216 data, uint40 timestamp) {}
+}