Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.8.0;

interface IPot {
    function dsr() external view returns (uint256);
    function chi() external view returns (uint256);
    function rho() external view returns (uint256);
}

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.8.0;

/**
 * @title  IDSROracle
 * @notice Consolidated DSR reporting along with some convenience functions.
 */
interface IDSROracle {

    struct PotData {
        uint96  dsr;  // Dai Savings Rate in per-second value [ray]
        uint120 chi;  // Last computed conversion rate [ray]
        uint40  rho;  // Last computed timestamp [seconds]
    }

    /**
     * @notice Emitted when the PotData is updated.
     * @param  nextData The new PotData struct.
     */
    event SetPotData(PotData nextData);

    /**
     * @notice Retrieve the current PotData: dsr, chi, and rho.
     * @return The current PotData struct.
     */
    function getPotData() external view returns (PotData memory);

    /**
     * @notice Get the current Dai Savings Rate.
     * @return The Dai Savings Rate in per-second value [ray].
     */
    function getDSR() external view returns (uint256);

    /**
     * @notice Get the last computed conversion rate.
     * @return The last computed conversion rate [ray].
     */
    function getChi() external view returns (uint256);

    /**
     * @notice Get the last computed timestamp.
     * @return The last computed timestamp [seconds].
     */
    function getRho() external view returns (uint256);

    /**
     * @notice Get the Annual Percentage Rate.
     * @return The APR.
     */
    function getAPR() external view returns (uint256);

    /**
     * @notice Get the conversion rate at the current timestamp.
     * @return The conversion rate.
     */
    function getConversionRate() external view returns (uint256);

    /**
     * @notice Get the conversion rate at a specified timestamp.
     * @dev    Timestamp must be greater than or equal to the current timestamp.
     * @param  timestamp The timestamp at which to retrieve the conversion rate.
     * @return The conversion rate.
     */
    function getConversionRate(uint256 timestamp) external view returns (uint256);

    /**
     * @notice Get the binomial approximated conversion rate at the current timestamp.
     * @return The binomial approximated conversion rate.
     */
    function getConversionRateBinomialApprox() external view returns (uint256);

    /**
     * @notice Get the binomial approximated conversion rate at a specified timestamp.
     * @dev    Timestamp must be greater than or equal to the current timestamp.
     * @param  timestamp The timestamp at which to retrieve the binomial approximated conversion rate.
     * @return The binomial approximated conversion rate.
     */
    function getConversionRateBinomialApprox(uint256 timestamp) external view returns (uint256);

    /**
     * @notice Get the linear approximated conversion rate at the current timestamp.
     * @return The linear approximated conversion rate.
     */
    function getConversionRateLinearApprox() external view returns (uint256);

    /**
     * @notice Get the linear approximated conversion rate at a specified timestamp.
     * @dev    Timestamp must be greater than or equal to the current timestamp.
     * @param  timestamp The timestamp at which to retrieve the linear approximated conversion rate.
     * @return The linear approximated conversion rate.
     */
    function getConversionRateLinearApprox(uint256 timestamp) external view returns (uint256);

}

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.8.0;

import { IDSROracle } from './IDSROracle.sol';

/**
 * @title  IDSRAuthOracle
 * @notice Consolidated DSR reporting along with some convenience functions.
 */
interface IDSRAuthOracle is IDSROracle {

    /** 
     * @notice Emitted when the maxDSR is updated.
     */
    event SetMaxDSR(uint256 maxDSR);

    /**
     * @notice The data provider role.
     */
    function DATA_PROVIDER_ROLE() external view returns (bytes32);

    /**
     * @notice Get the max dsr.
     */
    function maxDSR() external view returns (uint256);

    /**
     * @notice Set the max dsr.
     * @param  maxDSR The max dsr.
     * @dev    Only callable by the admin role.
     */
    function setMaxDSR(uint256 maxDSR) external;

    /**
     * @notice Update the pot data.
     * @param  data The max dsr.
     * @dev    Only callable by the data provider role.
     */
    function setPotData(IDSROracle.PotData calldata data) external;

}

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.0;

import { IDSRAuthOracle, IDSROracle } from '../interfaces/IDSRAuthOracle.sol';
import { IPot }                       from '../interfaces/IPot.sol';

/**
 * @title  DSROracleForwarderBase
 * @notice Base contract for relaying pot data messages cross-chain.
 */
abstract contract DSROracleForwarderBase {

    IPot               public immutable pot;
    address            public immutable l2Oracle;
    
    IDSROracle.PotData public _lastSeenPotData;

    constructor(address _pot, address _l2Oracle) {
        pot      = IPot(_pot);
        l2Oracle = _l2Oracle;
    }

    function _packMessage() internal returns (bytes memory) {
        IDSROracle.PotData memory potData = IDSROracle.PotData({
            dsr: uint96(pot.dsr()),
            chi: uint120(pot.chi()),
            rho: uint40(pot.rho())
        });
        _lastSeenPotData = potData;
        return abi.encodeCall(
            IDSRAuthOracle.setPotData,
            (potData)
        );
    }

    function getLastSeenPotData() external view returns (IDSROracle.PotData memory) {
        return _lastSeenPotData;
    }

    function getLastSeenDSR() external view returns (uint256) {
        return _lastSeenPotData.dsr;
    }

    function getLastSeenChi() external view returns (uint256) {
        return _lastSeenPotData.chi;
    }

    function getLastSeenRho() external view returns (uint256) {
        return _lastSeenPotData.rho;
    }

}

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.0;

interface ICrossDomainOptimism {
    function sendMessage(address _target, bytes calldata _message, uint32 _gasLimit) external;
}

interface ICrossDomainArbitrum {
    function createRetryableTicket(
        address to,
        uint256 l2CallValue,
        uint256 maxSubmissionCost,
        address excessFeeRefundAddress,
        address callValueRefundAddress,
        uint256 gasLimit,
        uint256 maxFeePerGas,
        bytes calldata data
    ) external payable returns (uint256);
    function calculateRetryableSubmissionFee(uint256 dataLength, uint256 baseFee) external view returns (uint256);
}

interface ICrossDomainGnosis {
    function requireToPassMessage(address _contract, bytes memory _data, uint256 _gas) external returns (bytes32);
}

interface ICrossDomainZkEVM {
    function bridgeMessage(
        uint32 destinationNetwork,
        address destinationAddress,
        bool forceUpdateGlobalExitRoot,
        bytes calldata metadata
    ) external payable;
}

/**
 * @title XChainForwarders
 * @notice Helper functions to abstract over L1 -> L2 message passing.
 * @dev General structure is sendMessageXXX(target, message, gasLimit) where XXX is the remote domain name (IE OptimismMainnet, ArbitrumOne, Base, etc).
 */
library XChainForwarders {

    /// ================================ Optimism Style ================================

    function sendMessageOptimism(
        address l1CrossDomain,
        address target,
        bytes memory message,
        uint256 gasLimit
    ) internal {
        ICrossDomainOptimism(l1CrossDomain).sendMessage(
            target,
            message,
            uint32(gasLimit)
        );
    }

    function sendMessageOptimismMainnet(
        address target,
        bytes memory message,
        uint256 gasLimit
    ) internal {
        sendMessageOptimism(
            0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1,
            target,
            message,
            uint32(gasLimit)
        );
    }

    function sendMessageBase(
        address target,
        bytes memory message,
        uint256 gasLimit
    ) internal {
        sendMessageOptimism(
            0x866E82a600A1414e583f7F13623F1aC5d58b0Afa,
            target,
            message,
            uint32(gasLimit)
        );
    }

    /// ================================ Arbitrum Style ================================

    function sendMessageArbitrum(
        address l1CrossDomain,
        address target,
        bytes memory message,
        uint256 gasLimit,
        uint256 maxFeePerGas,
        uint256 baseFee
    ) internal {
        uint256 maxSubmission = ICrossDomainArbitrum(l1CrossDomain).calculateRetryableSubmissionFee(message.length, baseFee);
        uint256 maxRedemption = gasLimit * maxFeePerGas;
        ICrossDomainArbitrum(l1CrossDomain).createRetryableTicket{value: maxSubmission + maxRedemption}(
            target,
            0, // we always assume that l2CallValue = 0
            maxSubmission,
            address(0), // burn the excess gas
            address(0), // burn the excess gas
            gasLimit,
            maxFeePerGas,
            message
        );
    }

    function sendMessageArbitrumOne(
        address target,
        bytes memory message,
        uint256 gasLimit,
        uint256 maxFeePerGas,
        uint256 baseFee
    ) internal {
        sendMessageArbitrum(
            0x4Dbd4fc535Ac27206064B68FfCf827b0A60BAB3f,
            target,
            message,
            gasLimit,
            maxFeePerGas,
            baseFee
        );
    }

    function sendMessageArbitrumNova(
        address target,
        bytes memory message,
        uint256 gasLimit,
        uint256 maxFeePerGas,
        uint256 baseFee
    ) internal {
        sendMessageArbitrum(
            0xc4448b71118c9071Bcb9734A0EAc55D18A153949,
            target,
            message,
            gasLimit,
            maxFeePerGas,
            baseFee
        );
    }

    /// ================================ Gnosis ================================

    function sendMessageGnosis(
        address l1CrossDomain,
        address target,
        bytes memory message,
        uint256 gasLimit
    ) internal {
        ICrossDomainGnosis(l1CrossDomain).requireToPassMessage(
            target,
            message,
            gasLimit
        );
    }

    function sendMessageGnosis(
        address target,
        bytes memory message,
        uint256 gasLimit
    ) internal {
        sendMessageGnosis(
            0x4C36d2919e407f0Cc2Ee3c993ccF8ac26d9CE64e,
            target,
            message,
            gasLimit
        );
    }

    /// ================================ zkEVM ================================

    function sendMessageZkEVM(
        address l1CrossDomain,
        uint32 destinationNetworkId,
        address destinationAddress,
        bool forceUpdateGlobalExitRoot,
        bytes memory metadata
    ) internal {
        ICrossDomainZkEVM(l1CrossDomain).bridgeMessage(
            destinationNetworkId,
            destinationAddress,
            forceUpdateGlobalExitRoot,
            metadata
        );
    }

    function sendMessageZkEVM(
        address destinationAddress,
        bytes memory metadata
    ) internal {
        sendMessageZkEVM(
            0x2a3DD3EB832aF982ec71669E178424b10Dca2EDe,
            1,
            destinationAddress,
            true,
            metadata
        );
    }

}

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.0;

import { XChainForwarders } from 'xchain-helpers/XChainForwarders.sol';

import { DSROracleForwarderBase } from './DSROracleForwarderBase.sol';

contract DSROracleForwarderArbitrumOne is DSROracleForwarderBase {

    constructor(address _pot, address _l2Oracle) DSROracleForwarderBase(_pot, _l2Oracle) {
        // Intentionally left blank
    }

    function refresh(
        uint256 gasLimit,
        uint256 maxFeePerGas,
        uint256 baseFee
    ) public payable {
        XChainForwarders.sendMessageArbitrumOne(
            address(l2Oracle),
            _packMessage(),
            gasLimit,
            maxFeePerGas,
            baseFee
        );
    }

}