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 CDP Token contract interface */
interface ICDPToken is IERC20 {
    /**
     * @notice Create new CDP tokens
     * @param to Address of the recipient
     * @param amount Amount of CDP tokens to create
     */
    function mint(
        address to,
        uint256 amount
    ) external;

    /**
     * @notice Destroy CDP tokens from existence
     * @param amount Amount to destroy
     * @dev Keeps track of destroyed CDP tokens 
     */    
    function burn(
        uint256 amount
    ) external;

    /**
     * @notice Destroy CDP tokens from existence from `account`
     * @param account Address to destroy CDP tokens from
     * @param amount Amount of CDP tokens to destroy
     * @dev Requirement: The caller must have a sufficient allowance
     */    
    function burnFrom(
        address account,
        uint256 amount
    ) external;
}


/**
 * @title Carpe Diem Pension
 * @author Carpe Diem
 * @notice Deposit and destroy CDP Tokens to get a share of the daily minted inflation
 * @dev Part of a system of three contracts. The other two are called Auction and CDPToken
 */
contract Pension is Ownable, Initializable {
    /** 
     * @notice Amount of shares in the system
     */
    uint256 public totalShares;

    /** 
     * @notice Pool of shares for the auction
     * @dev These shares cannot claim rewards
     */
    uint256 public auctionShares;

    /**
     * @notice Shares that are pending in the auction
     * @dev These shares cannot claim rewards
     */
    uint256 public activeAuctionShares;

    /** @notice Total amount of CDP rewards claimed */
    uint256 public totalCDPClaimed;

    /** @notice Total amount of shares distributed to referrers */
    uint256 public totalRefShares;

    /** 
     * @notice Number of unique addresses that have deposited
     * @dev Also includes users with destroyed shares 
     */
    uint256 public NoUsers;

    /** @notice Total amount of CDP deposited */
    uint256 public totalDeposited;

    /** 
     * @notice Value that only increases used to calculate users rewards 
     * @dev Increases every time CDP is minted
     */
    uint256 public rewardPerShare;

    /** @notice CDP Token */
    ICDPToken public CDP;
   
    struct UserInfo {
        address referral; // The referrer of the user
        uint256 shares; // How many tokens the user has provided
        uint256 lastInteraction; // last time user interacted
        uint256 CDPCollected; // Rewards collected by the user
        uint256 snapshot; // Saved snapshot of rewardPerShare
        uint256 storedReward; // Stored reward from before the snapshot that the user hasn't claimed yet
    }
    /** @notice Information about the user */
    mapping(address => UserInfo) public userInfo;

    /** @notice Total number of users mapped per day */
    mapping(uint256 => uint256) public NoUsersPerDay;

    struct dayInfo {
        uint256 CDPRewards; // CDP Minted on the day
        uint256 totalShares; // Total amount of shares on the day
    }
    /** @notice Total Rewards per day */
    mapping(uint256 => dayInfo) public dayInfoMap; // Info updated from Auction contract

    /** @notice Address of the Auction contract */
    address public AuctionContractAddress;

    address[] public UsersInfo;

    /** 
     * @notice Deposit by the user 
     * @param user Address of the user
     * @param timestamp Time of the event
     * @param amount Amount deposited
     */
    event DepositCDP(
        address indexed user,
        uint256 timestamp,
        uint256 amount
    );

    /**
     * @notice Shares given to the user
     * @param user Recipient of the shares
     * @param amount Amount of shares given
     */
    event MintShares(
        address indexed user,
        uint256 amount
    );

    /**
     * @notice Claimed rewards by the user
     * @param user Address of the user
     * @param timestamp Time of the event
     * @param amount Amount claimed
     */
    event ClaimCDP(
        address indexed user,
        uint256 timestamp,
        uint256 amount
    );

    /**
     * @notice Compounded rewards by the user
     * @param user Address of the user
     * @param timestamp Time of the event
     * @param amount Amount compounded
     */
    event CompoundCDP(
        address indexed user,
        uint256 timestamp,
        uint256 amount
    );

    /**
     * @notice Constuct the contract
     * @dev Needs to appoint the owner
     */
    constructor() Ownable(msg.sender) {}

    /**
     * @notice Connect to the other contracts
     * @dev Renounce ownership after configuration
     * @param _CDP Address of the CDPToken contract
     * @param _auctionAddress Address of the Auction contract
     */
    function initialize(
        address _CDP,
        address _auctionAddress
    ) public onlyOwner initializer {
        CDP = ICDPToken(_CDP);
        AuctionContractAddress = _auctionAddress;
        renounceOwnership();
    }

    /**
     * @notice Deposit CDP
     * @param _amount Amount of CDP to deposit
     * @param _referral Address of the (new) referrer, not necessary
     * @dev If no referral address is stored nor inserted, the shares go to the Auction pool
     */
    function depositCDP(
        uint256 _amount,
        address _referral
    ) external {
        require(msg.sender != _referral, "No self-referring");
        require(_amount >= 1e15, "Minimum deposit is 0.001 CDP");

        UserInfo storage user = userInfo[msg.sender];

        // Registers the user if the user interacts for the first time
        if (user.lastInteraction == 0) {
            UsersInfo.push(msg.sender);
            NoUsers += 1;
        }

        address ref;

        if (
            // Case 1: No referral is entered (_referral == address(0)) nor is stored for the user (user.referral == address(0))
            _referral == address(0) && user.referral == address(0)
        ) {
            // Set the ref to the auction address
            ref = AuctionContractAddress;
        } else if (
            // Case 2: No referral is entered (_referral == address(0)) but a referral is stored for the user (user.referral != address(0))
            _referral == address(0) && user.referral != address(0)
        ) {
            // Set the ref to the stored referral
            ref = user.referral;
        } else {
            // Case 3: A referral is entered
            // Update the user's referral to the provided referral
            user.referral = _referral;
            // Set the ref to the provided referral
            ref = _referral;
        }

        UserInfo storage userRef = userInfo[ref];
        uint256 snapshot = user.snapshot;
        uint256 userShares = user.shares;
        uint256 refSnapshot = userRef.snapshot;
        uint256 refShares = userRef.shares;
            
        user.storedReward += ((rewardPerShare - snapshot) * userShares) / 1e18; // Stores rewards before taking a new snapshot
        user.snapshot = rewardPerShare; // Takes a new snapshot for the user
        user.shares += _amount;

        if (ref == AuctionContractAddress) {
            auctionShares += (_amount) / 10;
        } else {
            // Registers the referral if the referral has no interactions
            if (userRef.lastInteraction == 0) {
                UsersInfo.push(ref);
                NoUsers += 1;
                userRef.lastInteraction = block.timestamp;
            }            
            // Stores rewards, takes a new snapshot, and adds shares for referral
            userRef.storedReward += ((rewardPerShare - refSnapshot) * refShares) / 1e18; 
            userRef.snapshot = rewardPerShare;
            userRef.shares += _amount / 10;
            totalRefShares += _amount / 10;
        }

        totalDeposited += _amount;
        auctionShares += (_amount * 2) / 10;
        totalShares += (_amount * 13) / 10;
        user.lastInteraction = block.timestamp;
        
        CDP.burnFrom(msg.sender, _amount);

        emit DepositCDP(msg.sender, block.timestamp, _amount);
    }

    /**
     * @notice Claim CDP rewards
     * @dev Compares the current rewardPerShare value with the user's snapshot to calculate the rewards
     */
    function claimCDP() external {
        UserInfo storage user = userInfo[msg.sender];

        uint256 pending;
        uint256 snapshot = user.snapshot;
        uint256 storedReward = user.storedReward;
        uint256 userShares = user.shares;

        pending += (((rewardPerShare - snapshot) * userShares) / 1e18) + storedReward;
        user.snapshot = rewardPerShare; // Takes a new snapshot for the user
        user.storedReward = 0; // Delete stored reward
        totalCDPClaimed += pending;
        user.CDPCollected += pending;
        user.lastInteraction = block.timestamp;

        CDP.transfer(msg.sender, pending);

        emit ClaimCDP(msg.sender, block.timestamp, pending);
    }

    /**
     * @notice Compound CDP rewards and get 15% more shares
     * @dev Referral and Auction shares are cut in half, so the total amount of shares created per CDP deposited remains at 1.3
     */
    function compoundCDP() external {
        UserInfo storage user = userInfo[msg.sender];
        UserInfo storage userRef = userInfo[user.referral];
        uint256 pending;
        uint256 snapshot = user.snapshot;
        uint256 storedReward = user.storedReward;
        uint256 userShares = user.shares;
        uint256 refSnapshot = userRef.snapshot;
        uint256 refShares = userRef.shares;

        pending += (((rewardPerShare - snapshot) * userShares) / 1e18) + storedReward;
        user.storedReward = 0; // Delete stored reward
        user.snapshot = rewardPerShare; // Takes a new snapshot for the user
        user.shares += (pending * 115) / 100;

        if (user.referral == address(0)) {
            // Add referral shares to auctionShares when no referral is stored
            auctionShares += (pending * 5) / 100;
        } else {
            // Stores rewards, takes a new snapshot, and adds shares for referral
            userRef.storedReward += ((rewardPerShare - refSnapshot) * refShares) / 1e18;
            userRef.snapshot = rewardPerShare;
            userRef.shares += (pending * 5) / 100;
            totalRefShares += (pending * 5) / 100;
        }

        totalDeposited += pending;
        auctionShares += (pending * 10) / 100;
        totalShares += (pending * 130) / 100;
        totalCDPClaimed += pending;
        user.CDPCollected += pending;
        user.lastInteraction = block.timestamp;

        CDP.burn(pending);

        emit CompoundCDP(msg.sender, block.timestamp, pending);
    }

    /**
     * @notice Transfer shares from auction to user
     * @dev Called by auction contract to collect shares for the user/day
     * @param _recipient Address to transfer the shares to
     * @param _amount Amount of shares to transfer
     */
    function mintShares(
        address _recipient,
        uint256 _amount
    ) external {
        require(msg.sender == AuctionContractAddress, "No permission");
        UserInfo storage user = userInfo[_recipient];

        uint256 snapshot = user.snapshot;
        uint256 userShares = user.shares;

        user.storedReward += ((rewardPerShare - snapshot) * userShares) / 1e18; // Stores rewards before taking a new snapshot
        user.snapshot = rewardPerShare; // Takes a new snapshot for the user
        user.shares += (_amount);
        user.lastInteraction = block.timestamp;
        activeAuctionShares -= (_amount);
        emit MintShares(_recipient, _amount);
    }

    /**
     * @notice Create daily inflation and add it to the rewards pool
     * @dev Called by auction contract to mint daily distribution and update daily rewards
     * @param _amount Amount of CDP to create
     * @param _day The day for which the inflation is created
     */
    function mintCDP(
        uint256 _amount,
        uint256 _day
    ) external {
        require(msg.sender == AuctionContractAddress, "No permission");
        uint256 denom = totalShares - auctionShares - activeAuctionShares;

        NoUsersPerDay[_day] = NoUsers;
        dayInfoMap[_day].totalShares = totalShares;

        // Only mint and distribute when there are active user shares
        if (denom != 0) {
            rewardPerShare += (_amount * 1e18) / denom;
            dayInfoMap[_day].CDPRewards = _amount;
            CDP.mint(address(this), _amount);
        }
    }

    /**
     * @notice 5% of the shares in the auction pool are transferred to the auction daily
     * @dev Called by auction contract to update Auction shares balance
     */
    function BurnSharesfromAuction() external returns (uint256) {
        require(msg.sender == AuctionContractAddress, "No permission");
        uint256 sharesDistributedinAuction = (5 * auctionShares) / 100;
        activeAuctionShares += sharesDistributedinAuction;
        auctionShares -= sharesDistributedinAuction;

        return sharesDistributedinAuction;
    }

    /**
     * @notice View function to see the pending reward for a user
     * @param _user: Address of the user
     * @return totalPending Pending reward for a given user
     */
    function pendingRewardCDP(
        address _user
    ) public view returns (uint256 totalPending) {
        UserInfo storage user = userInfo[_user];
        uint256 snapshot = user.snapshot;
        uint256 storedReward = user.storedReward;
        uint256 userShares = user.shares;

        totalPending += (((rewardPerShare - snapshot) * userShares) / 1e18) + storedReward; // Could be 0
    }

    /**
     * @notice Delete a user's shares if he hasn't interacted for 1111 days
     * @notice Claims and sends pending rewards to the targetted user
     * @param _target: Address of whom its shares are being destroyed
     */
    function Destroyshares(
        address _target
    ) external {
        UserInfo storage user = userInfo[_target];

        // Require that the current timestamp is greater than the user's last interaction plus 1111 days
        require(
            block.timestamp > user.lastInteraction + 1111 days,
            "Time requirement not met"
        );
        uint256 pending;
        uint256 snapshot = user.snapshot;
        uint256 storedReward = user.storedReward;
        uint256 userShares = user.shares;

        pending += (((rewardPerShare - snapshot) * userShares) / 1e18) + storedReward;
        user.storedReward = 0; // Delete stored reward
        totalCDPClaimed += pending;
        user.CDPCollected += pending;
        totalShares -= user.shares; // Reduce the total shares
        user.shares = 0; // Set the user's shares to 0

        CDP.transfer(_target, pending);

        emit ClaimCDP(_target, block.timestamp, pending);
    }

    /**
     * @notice Prove your presence
     */
    function Iamhere() external {
        UserInfo storage user = userInfo[msg.sender];
        require(
            user.lastInteraction != 0, 
            "Activate your account with depositCDP()"
        );
        user.lastInteraction = block.timestamp;
    }

    /**
     * @notice Get the total number of shares in the system
     * @return totalShares Total amount of shares
     */
    function gettotalShares() external view returns (uint256) {
        return totalShares;
    }
}
        

// 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);
    }
}