Merge pull request #271 from VenusProtocol/develop

New release

Author: kkirka

CHANGELOG.md

@@ -1,3 +1,28 @@
+## [2.12.0-dev.2](https://github.com/VenusProtocol/oracle/compare/v2.12.0-dev.1...v2.12.0-dev.2) (2025-02-21)
+
+
+### Features
+
+* add deployments for Pendle oracles used as a reference ([39e82df](https://github.com/VenusProtocol/oracle/commit/39e82df3b40de2031e73176289abd9b4d396a701))
+* updating deployment files ([eb9cee1](https://github.com/VenusProtocol/oracle/commit/eb9cee1879960e95b7bfc6c93c7c6092a6f7e3f9))
+
+## [2.12.0-dev.1](https://github.com/VenusProtocol/oracle/compare/v2.11.0...v2.12.0-dev.1) (2025-02-21)
+
+
+### Features
+
+* add reference oracle conract ([cfa31eb](https://github.com/VenusProtocol/oracle/commit/cfa31eb97a956fc914daa6fd3ff0dd7b31aadd3c))
+* add reference oracle deployment for bsc and eth ([0f0cc33](https://github.com/VenusProtocol/oracle/commit/0f0cc33fa90ff85fb475dd046fa6f4ef8f7fcd4a))
+* add testnet tags and helpers to dispatch testnets ([8576fe9](https://github.com/VenusProtocol/oracle/commit/8576fe961dc65805ad50617d705748cdca03945d))
+* replace multisig with timelock on Ethereum ([6bbff81](https://github.com/VenusProtocol/oracle/commit/6bbff818a8db2869ea630dd0fee34b82b4f1b2f5))
+* support compiling for cancun ([5a22e67](https://github.com/VenusProtocol/oracle/commit/5a22e6754daeea2a9c759bec02dfb62457384b02))
+* updating deployment files ([9f378c5](https://github.com/VenusProtocol/oracle/commit/9f378c53caf231cc6120c6c671a3c1ad886a19e3))
+
+
+### Bug Fixes
+
+* patch smock package to check if provider has init ([2f86269](https://github.com/VenusProtocol/oracle/commit/2f86269c94f370f3841d851a7f6f965584b9f66b))
+
 ## [2.11.0](https://github.com/VenusProtocol/oracle/compare/v2.10.0...v2.11.0) (2025-02-14)
 
 

contracts/ReferenceOracle.sol

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: BSD-3-Clause
+// SPDX-FileCopyrightText: 2025 Venus
+pragma solidity 0.8.25;
+
+import { Ownable2StepUpgradeable } from "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
+import { ensureNonzeroAddress } from "@venusprotocol/solidity-utilities/contracts/validators.sol";
+import { ResilientOracleInterface, OracleInterface } from "./interfaces/OracleInterface.sol";
+
+/**
+ * @title ReferenceOracle
+ * @author Venus
+ * @notice Reference oracle is the oracle that is not used for production but required for
+ * price monitoring. This oracle contains some extra configurations for assets required to
+ * compute reference prices of their derivative assets (OneJump, ERC4626, Pendle, etc.)
+ */
+contract ReferenceOracle is Ownable2StepUpgradeable, OracleInterface {
+    struct ExternalPrice {
+        /// @notice asset address
+        address asset;
+        /// @notice price of the asset from an external source
+        uint256 price;
+    }
+
+    /// @notice Slot to temporarily store price information from external sources
+    /// like CMC/Coingecko, useful to compute prices of derivative assets based on
+    /// prices of the base assets with no on chain price information
+    bytes32 public constant PRICES_SLOT = keccak256(abi.encode("venus-protocol/oracle/ReferenceOracle/prices"));
+
+    /// @notice Resilient oracle address
+    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+    ResilientOracleInterface public immutable RESILIENT_ORACLE;
+
+    /// @notice Oracle configuration for assets
+    mapping(address => OracleInterface) public oracles;
+
+    /// @notice Event emitted when an oracle is set
+    event OracleConfigured(address indexed asset, address indexed oracle);
+
+    /**
+     * @notice Constructor for the implementation contract. Sets immutable variables.
+     * @param resilientOracle Resilient oracle address
+     * @custom:error ZeroAddressNotAllowed is thrown if resilient oracle address is null
+     * @custom:oz-upgrades-unsafe-allow constructor
+     */
+    constructor(ResilientOracleInterface resilientOracle) {
+        ensureNonzeroAddress(address(resilientOracle));
+        RESILIENT_ORACLE = resilientOracle;
+        _disableInitializers();
+    }
+
+    /**
+     * @notice Initializes the contract admin
+     */
+    function initialize() external initializer {
+        __Ownable2Step_init();
+    }
+
+    /**
+     * @notice Sets an oracle to use for a specific asset
+     * @dev The production resilientOracle will be used if zero address is passed
+     * @param asset Asset address
+     * @param oracle Oracle address
+     * @custom:access Only owner
+     * @custom:error ZeroAddressNotAllowed is thrown if asset address is null
+     * @custom:event Emits OracleConfigured event
+     */
+    function setOracle(address asset, OracleInterface oracle) external onlyOwner {
+        ensureNonzeroAddress(asset);
+        oracles[asset] = OracleInterface(oracle);
+        emit OracleConfigured(asset, address(oracle));
+    }
+
+    /**
+     * @notice Gets price of the asset assuming other assets have the defined price
+     * @param asset asset address
+     * @param externalPrices an array of prices for other assets
+     * @return USD price in scaled decimal places
+     */
+    function getPriceAssuming(address asset, ExternalPrice[] memory externalPrices) external returns (uint256) {
+        uint256 externalPricesCount = externalPrices.length;
+        for (uint256 i = 0; i < externalPricesCount; ++i) {
+            _storeExternalPrice(externalPrices[i].asset, externalPrices[i].price);
+        }
+        return _getPrice(asset);
+    }
+
+    /**
+     * @notice Gets price of the asset
+     * @param asset asset address
+     * @return USD price in scaled decimal places
+     */
+    function getPrice(address asset) external view override returns (uint256) {
+        return _getPrice(asset);
+    }
+
+    function _storeExternalPrice(address asset, uint256 price) internal {
+        bytes32 slot = keccak256(abi.encode(PRICES_SLOT, asset));
+        // solhint-disable-next-line no-inline-assembly
+        assembly ("memory-safe") {
+            tstore(slot, price)
+        }
+    }
+
+    function _getPrice(address asset) internal view returns (uint256) {
+        uint256 externalPrice = _loadExternalPrice(asset);
+        if (externalPrice != 0) {
+            return externalPrice;
+        }
+        OracleInterface oracle = oracles[asset];
+        if (oracle != OracleInterface(address(0))) {
+            return oracle.getPrice(asset);
+        }
+        return RESILIENT_ORACLE.getPrice(asset);
+    }
+
+    function _loadExternalPrice(address asset) internal view returns (uint256 value) {
+        bytes32 slot = keccak256(abi.encode(PRICES_SLOT, asset));
+        // solhint-disable-next-line no-inline-assembly
+        assembly ("memory-safe") {
+            value := tload(slot)
+        }
+    }
+}

deploy/16-deploy-SolvBTC.BBN-pendle-oracles.ts

@@ -3,6 +3,7 @@ import { DeployFunction } from "hardhat-deploy/dist/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 
 import { ADDRESSES } from "../helpers/deploymentConfig";
+import { isMainnet } from "../helpers/deploymentUtils";
 
 enum PendleRateKind {
   PT_TO_ASSET = 0,
@@ -53,6 +54,34 @@ const func: DeployFunction = async ({ getNamedAccounts, deployments, network }:
     },
     skipIfAlreadyDeployed: true,
   });
+
+  if (isMainnet(network)) {
+    const referenceOracle = await ethers.getContract("ReferenceOracle");
+    const { devMultisig } = addresses;
+    await deploy("PendleOracle-PT-SolvBTC.BBN-27MAR2025_Reference_PtToAsset", {
+      contract: "PendleOracle",
+      from: deployer,
+      log: true,
+      deterministicDeployment: false,
+      args: [
+        addresses["PT-SolvBTC.BBN-27MAR2025_Market"] || "0x0000000000000000000000000000000000000001",
+        ptOracleAddress,
+        PendleRateKind.PT_TO_ASSET,
+        addresses["PT-SolvBTC.BBN-27MAR2025"],
+        addresses.BTCB,
+        referenceOracle.address,
+        900,
+      ],
+      proxy: {
+        owner: devMultisig,
+        proxyContract: "OptimizedTransparentUpgradeableProxy",
+        viaAdminContract: {
+          name: "DevProxyAdmin",
+        },
+      },
+      skipIfAlreadyDeployed: true,
+    });
+  }
 };
 
 export default func;

deploy/2-deploy-reference-oracle.ts

@@ -0,0 +1,59 @@
+import hre from "hardhat";
+import { DeployFunction } from "hardhat-deploy/dist/types";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+import { ADDRESSES } from "../helpers/deploymentConfig";
+import { skipAllExcept } from "../helpers/deploymentUtils";
+
+const func: DeployFunction = async function ({ getNamedAccounts, deployments, network }: HardhatRuntimeEnvironment) {
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  const devMultisig = network.live ? ADDRESSES[network.name].devMultisig : deployer;
+  const proxyAdminArtifact = await hre.artifacts.readArtifact(
+    "hardhat-deploy/solc_0.8/openzeppelin/proxy/transparent/ProxyAdmin.sol:ProxyAdmin",
+  );
+
+  const resilientOracle = await hre.ethers.getContract("ResilientOracle");
+
+  await deploy("ReferenceOracle", {
+    contract: "ReferenceOracle",
+    from: deployer,
+    log: true,
+    deterministicDeployment: false,
+    skipIfAlreadyDeployed: true,
+    args: [resilientOracle.address],
+    proxy: {
+      owner: devMultisig,
+      proxyContract: "OptimizedTransparentUpgradeableProxy",
+      execute: {
+        methodName: "initialize",
+        args: [],
+      },
+      viaAdminContract: {
+        name: "DevProxyAdmin",
+        artifact: proxyAdminArtifact,
+      },
+    },
+  });
+
+  const devProxyAdmin = await hre.ethers.getContract("DevProxyAdmin");
+  const devProxyAdminOwner = await devProxyAdmin.owner();
+
+  if (devProxyAdminOwner === deployer) {
+    await devProxyAdmin.transferOwnership(devMultisig);
+    console.log(`Ownership of DevProxyAdmin transfered from deployer to dev multisig (${devMultisig})`);
+  }
+
+  const referenceOracle = await hre.ethers.getContract("ReferenceOracle");
+  const referenceOracleOwner = await referenceOracle.owner();
+
+  if (referenceOracleOwner === deployer) {
+    await referenceOracle.transferOwnership(devMultisig);
+    console.log(`Ownership of ReferenceOracle transfered from deployer to dev multisig (${devMultisig})`);
+  }
+};
+
+export default func;
+func.skip = skipAllExcept(["bscmainnet", "ethereum"]);
+func.tags = ["reference"];