Contract Address Details

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";

/** @notice Pension contract Interface */
interface PensionContractInterface {
    /**
     * @notice Create CDP tokens
     * @param _amount Amount to create
     * @param _day The day for which the tokens are minted
     * @dev The Pension contracts mints the tokens from the CDPToken contract
     */
    function mintCDP(
        uint256 _amount,
        uint256 _day
    ) external;

    /**
     * @notice Create shares
     * @param _recipient Address of the recipient
     * @param _amount Amount to create
     */
    function mintShares(
        address _recipient,
        uint256 _amount
    ) external;

    /**
     * @notice View function to get the total amount of shares in the system
     * @return totalShares Total amount of shares in the system
     */
    function gettotalShares() external view returns (uint256);

    /**
     * @notice Calculate the amount of shares to be auctioned
     * @return sharesDistributedinAuction Shares to be auctioned today
     */
    function BurnSharesfromAuction() external returns (uint256);
}

/**
 * @title Auction and daily updater for the Carpe Diem Pension system
 * @author Carpe Diem
 * @notice Updates the entire system and auctions shares for PLS each 20 hours
 * @dev Part of a system of three contracts. The other two are called Pension and CDPToken
 */
contract Auction is Ownable, Initializable {
    /**
     * @notice Auction entry of the user
     * @param addr Address of the user
     * @param timestamp Time of the event
     * @param entryAmountPLS Amount of PLS deposited
     * @param day Day of the system
     */
    event UserEnterAuction(
        address indexed addr,
        uint256 timestamp,
        uint256 entryAmountPLS,
        uint256 day
    );

    /**
     * @notice Collected shares from the auction by the user
     * @param addr Address of the user
     * @param timestamp Time of the event
     * @param day Day of the system
     * @param tokenAmount Amount of shares collected
     */
    event UsercollectAuctionShares(
        address indexed addr,
        uint256 timestamp,
        uint256 day,
        uint256 tokenAmount
    );

    /**
     * @notice End mark of the auction for a certain day
     * @param timestamp Time of the event
     * @param day Day of the system
     * @param PLSTotal Amount of PLS deposited for the day
     * @param tokenTotal Amount of shares auctioned for the day
     */
    event DailyAuctionEnd(
        uint256 timestamp,
        uint256 day,      
        uint256 PLSTotal,
        uint256 tokenTotal
    );

    /** 
     * @notice Start of the system 
     * @param timestamp Time of the event
     */
    event AuctionStarted(
        uint256 timestamp
    );

    /** @notice Address that receives PLS */
    address public immutable swiss_addr;

    /** @notice Record the current day of the system */
    uint256 public currentDay;

    struct userAuctionEntry {
        uint256 totalDepositsPLS; // Total PLS deposited by the user for the day
        uint256 day; // Day of the system
        bool hasCollected; // Whether the user has collected its shares
    }
    /** 
     * @notice Information about the auction participant
     * @dev Users are allowed to enter multiple times a day
     */
    mapping(address => mapping(uint256 => userAuctionEntry))
        public mapUserAuctionEntry;

    /** @notice Total PLS deposited for the day */
    mapping(uint256 => uint256) public PLSauctionDeposits;

    /** @notice Total shares distributed for the day */
    mapping(uint256 => uint256) public shares;

    /** @notice Total CDP minted for the day */
    mapping(uint256 => uint256) public CDPMinted;

    /** @notice Start time of the system used to calculate the days */
    uint256 public launchTime;

    /** @notice CDPToken address */
    address public immutable CDP;

    /** @notice Total amount of PLS deposited */
    uint256 public totalPLSdeposited;

    /** @notice Address of the Pension contract */
    address public immutable PensionContractAddress;

    /** 
     * @notice Construct the contract
     * @param _CDP Address of the CDPToken contract
     * @param _pensionaddress Address of the pension contract
     */
    constructor(
        address _CDP,
        address _pensionaddress
    ) Ownable(msg.sender) {
        swiss_addr = msg.sender;
        CDP = _CDP;
        PensionContractAddress = _pensionaddress;
    }

    receive() external payable {}

    /** 
     * @notice Start the system
     * @dev Called when we're ready to start the auction
     */
    function startAuction() external onlyOwner initializer {
        launchTime = block.timestamp;
        currentDay = 1;

        renounceOwnership();

        emit AuctionStarted(block.timestamp);
    }

    /**
     * @notice Calculate the current day based off the start time
     */
    function calcDay() public view returns (uint256) {
        if (launchTime == 0) return 0;
        return ((block.timestamp - launchTime) / 20 hours) + 1;
    }

    /**
     * @notice Update the system for the day
     * @notice Mints daily inflation
     * @dev Called daily, can be done manually in explorer. For security, all tokens are kept inside the contract.
     */
    function doDailyUpdate() public {
        uint256 _nextDay = calcDay();
        uint256 _currentDay = currentDay;
 
        // This is true once a day
        if (_currentDay != _nextDay) {
            // Mints the CDP for the current day
            _mintDailyCDPandShares(_currentDay);

            // Mints CDP for days that were skipped
            for(uint256 i = _currentDay + 1; i < _nextDay; i++) {
                _mintPastDailyCDP(i);
            }

            emit DailyAuctionEnd(
                block.timestamp,
                currentDay,
                PLSauctionDeposits[currentDay],
                shares[currentDay]
            );

            currentDay = _nextDay;
        }
    }

    /**
     * @notice Enter the auction by depositing PLS
     * @dev Enter the Auction for the current day
     */
    function enterAuction() external payable {
        require(
            (launchTime > 0),
            "Project not launched"
        );
        require(
            msg.value > 0, 
            "Value is 0"
        );
        doDailyUpdate();

        uint256 _currentDay = currentDay;
        PLSauctionDeposits[_currentDay] += msg.value;

        mapUserAuctionEntry[msg.sender][_currentDay] = userAuctionEntry({
            totalDepositsPLS: mapUserAuctionEntry[msg.sender][_currentDay]
                .totalDepositsPLS + msg.value,
            day: _currentDay,
            hasCollected: false
        });
        totalPLSdeposited += msg.value;

        emit UserEnterAuction(
            msg.sender,
            block.timestamp,
            msg.value,
            _currentDay
        );
    }

    /**
     * @notice Collect shares for day `targetDay`
     * @dev External function for collecting shares from auction
     * @param targetDay Target day of Auction to collect
     */
    function collectAuctionShares(
        uint256 targetDay
    ) external {
        require(
            mapUserAuctionEntry[msg.sender][targetDay].hasCollected == false,
            "Tokens already collected for day"
        );
        require(
            targetDay < currentDay,
            "Cannot collect tokens for current active day"
        );

        uint256 _sharesToPay = calcTokenValue(msg.sender, targetDay);
        mapUserAuctionEntry[msg.sender][targetDay].hasCollected = true;

        PensionContractInterface(PensionContractAddress).mintShares(
            msg.sender,
            _sharesToPay
        );

        emit UsercollectAuctionShares(
            msg.sender,
            block.timestamp,
            targetDay,
            _sharesToPay
        );
    }

    /**
     * @notice Calculate the amount of shares for user `_address` for day `_Day`
     * @dev Calculating user's share from Auction based on their deposits for the day
     * @param _Day The Auction day
     * @return _tokenValue Amount of shares
     */
    function calcTokenValue(
        address _address,
        uint256 _Day
    ) public view returns (uint256 _tokenValue) {
        uint256 _entryDay = mapUserAuctionEntry[_address][_Day].day;

        if (shares[_entryDay] == 0) {
            return 0;
        }
        if (_entryDay < currentDay) {
            _tokenValue =
                (shares[_entryDay] *
                    mapUserAuctionEntry[_address][_Day].totalDepositsPLS) /
                PLSauctionDeposits[_entryDay];
        }

        return _tokenValue;
    }

    /**
     * @notice Send PLS to `swiss_addr`
     * @notice Caller pays network fees, but cannot expect to receive anything in return
     */
    function withdrawPLS() external {
        uint256 _bal = address(this).balance;
        (bool sent, ) = payable(swiss_addr).call{value: _bal}("");
        require(sent, "Failed to withdraw PLS");
    }

    /**
     * @dev Mints CDP in Pension contract and shares for the day 
     * @param _day Day to mint the CDP + shares for
     */
    function _mintDailyCDPandShares(
        uint256 _day
    ) internal {
        // CDP is minted from Pension contract every day
        uint256 MintedCDP = todayMintedCDP();
        CDPMinted[_day] = MintedCDP;
        PensionContractInterface(PensionContractAddress).mintCDP(
            MintedCDP,
            _day
        );

        if (PLSauctionDeposits[_day] != 0) {
            uint256 nextDayShares = PensionContractInterface(PensionContractAddress)
                .BurnSharesfromAuction();
            shares[_day] = nextDayShares; // Amount of shares that are for sale on _day
        }
    }

    /**
     * @dev Only mints CDP in Pension contract for days that weren't updated
     * @param _day Skipped day to mint the CDP
     */
    function _mintPastDailyCDP(
        uint256 _day
    ) internal {
        // CDP is minted from Pension from previous days
        uint256 MintedCDP = todayMintedCDP();
        CDPMinted[_day] = MintedCDP;
        PensionContractInterface(PensionContractAddress).mintCDP(
            MintedCDP,
            _day
        );
    }

    /**
     * @notice Calculate the amount of CDP Tokens to create
     * @dev Converts inflation of 4.32% a year (including compounding) to 20 hour days
     * @dev Applies inflation to the totalSupply + historicSupply
     * @dev historicSupply = totalShares / 1.3, as every CDP deposited creates a total of 1.3 shares
     */
    function todayMintedCDP() public view returns (uint256) {
        uint256 totalSupply = IERC20(CDP).totalSupply();
        uint256 totalShares = PensionContractInterface(PensionContractAddress)
            .gettotalShares();
        uint256 historicSupply = (totalShares * 10) / 13;
        return (((totalSupply + historicSupply) * 10000) / 103563452);
    }

    /**
     * @notice Get your statistics for day `_day`
     * @return yourDeposit Your total deposits of PLS for day `_day`
     * @return totalDeposits Total deposits of PLS for day `_day`
     * @return youReceive Calculate the amount of shares to receive
     * @return claimedis Boolean to know whether you have claimed your shares
     * @return sharesis Total shares auctioned for day `_day`
     */
    function getStatsLoop(
        uint256 _day
    )
        external
        view
        returns (
            uint256 yourDeposit,
            uint256 totalDeposits,
            uint256 youReceive,
            bool claimedis,
            uint256 sharesis
        )
    {
        yourDeposit = mapUserAuctionEntry[msg.sender][_day].totalDepositsPLS;
        totalDeposits = PLSauctionDeposits[_day];
        youReceive = calcTokenValue(msg.sender, _day);
        claimedis = mapUserAuctionEntry[msg.sender][_day].hasCollected;
        sharesis = shares[_day];
    }

    /**
     * @notice Get someone's statistics for multiple days
     * @param _day First day to get statistics from
     * @param numb Number of days to get statistics from
     * @param account Address to get statistics from
     */
    function getStatsLoops(
        uint256 _day,
        uint256 numb,
        address account
    )
        external
        view
        returns (
            uint256[] memory yourDeposits,
            uint256[] memory totalDeposits,
            uint256[] memory youReceives,
            bool[] memory claimedis,
            uint256[] memory sharesDay
        )
    {
        yourDeposits = new uint256[](numb);
        totalDeposits = new uint256[](numb);
        youReceives = new uint256[](numb);
        claimedis = new bool[](numb);
        sharesDay = new uint256[](numb);

        for (uint256 i = 0; i < numb; ) {
            yourDeposits[i] = mapUserAuctionEntry[account][_day + i]
                .totalDepositsPLS;
            totalDeposits[i] = PLSauctionDeposits[_day + i];
            youReceives[i] = calcTokenValue(account, _day + i);
            claimedis[i] = mapUserAuctionEntry[account][_day + i].hasCollected;
            sharesDay[i] = shares[_day + i];
            unchecked {
                ++i;
            }
        }
        
        return (yourDeposits, totalDeposits, youReceives, claimedis, sharesDay);
    }
}
        

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.20;

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Storage of the initializable contract.
     *
     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
     * when using with upgradeable contracts.
     *
     * @custom:storage-location erc7201:openzeppelin.storage.Initializable
     */
    struct InitializableStorage {
        /**
         * @dev Indicates that the contract has been initialized.
         */
        uint64 _initialized;
        /**
         * @dev Indicates that the contract is in the process of being initialized.
         */
        bool _initializing;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;

    /**
     * @dev The contract is already initialized.
     */
    error InvalidInitialization();

    /**
     * @dev The contract is not initializing.
     */
    error NotInitializing();

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint64 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
     * production.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        // Cache values to avoid duplicated sloads
        bool isTopLevelCall = !$._initializing;
        uint64 initialized = $._initialized;

        // Allowed calls:
        // - initialSetup: the contract is not in the initializing state and no previous version was
        //                 initialized
        // - construction: the contract is initialized at version 1 (no reininitialization) and the
        //                 current contract is just being deployed
        bool initialSetup = initialized == 0 && isTopLevelCall;
        bool construction = initialized == 1 && address(this).code.length == 0;

        if (!initialSetup && !construction) {
            revert InvalidInitialization();
        }
        $._initialized = 1;
        if (isTopLevelCall) {
            $._initializing = true;
        }
        _;
        if (isTopLevelCall) {
            $._initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint64 version) {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing || $._initialized >= version) {
            revert InvalidInitialization();
        }
        $._initialized = version;
        $._initializing = true;
        _;
        $._initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        _checkInitializing();
        _;
    }

    /**
     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
     */
    function _checkInitializing() internal view virtual {
        if (!_isInitializing()) {
            revert NotInitializing();
        }
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing) {
            revert InvalidInitialization();
        }
        if ($._initialized != type(uint64).max) {
            $._initialized = type(uint64).max;
            emit Initialized(type(uint64).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint64) {
        return _getInitializableStorage()._initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _getInitializableStorage()._initializing;
    }

    /**
     * @dev Returns a pointer to the storage namespace.
     */
    // solhint-disable-next-line var-name-mixedcase
    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
        assembly {
            $.slot := INITIALIZABLE_STORAGE
        }
    }
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}