Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: agpl-3.0
// Copyright (c) 2024, Alt Research Ltd.
pragma solidity =0.8.23;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {StakedMultiToken} from "./StakedMultiToken.sol";

contract StakedALTXterioVault is StakedMultiToken {
    constructor(IERC20 altToken_, uint40 stakingStartTimestamp_) StakedMultiToken(altToken_, stakingStartTimestamp_) {}

    event URIUpdated(string);

    function setURI(string memory newuri) external onlyOwner {
        _setURI(newuri);
        emit URIUpdated(newuri);
    }

    function name() external pure returns (string memory) {
        return "Staked ALT (XTER Vault)";
    }

    function symbol() external pure returns (string memory) {
        return "STALTXTER";
    }

    function decimals() external pure returns (uint256) {
        return 18;
    }
}

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

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity =0.8.23;

import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {
    ERC1155SupplyUpgradeable,
    ERC1155Upgradeable
} from "@openzeppelin/contracts-upgradeable/token/ERC1155/extensions/ERC1155SupplyUpgradeable.sol";

import {IStakedMultiToken} from "./interfaces/IStakedMultiToken.sol";
import {DistributionData, RewardDistribution} from "./RewardDistribution.sol";
import {AlertSystem} from "./AlertSystem.sol";
import {OperatorRegistry} from "./OperatorRegistry.sol";
import {
    ArrayLengthMismatch,
    ZeroVotingStake,
    FrozenOperator,
    InsufficientAmount,
    LessThanMinStakeToVote,
    ZeroAddress,
    NotOperator,
    AlreadyRegistered,
    InvalidBPS,
    ZeroExchangeRate,
    ZeroAmount,
    InvalidCooldownAmount,
    InsufficientCooldown,
    ZeroUnstakeable,
    InvalidDestination,
    GreaterThanMaxCooldownSec,
    StakingNotStartedYet,
    InvalidStakingStartTime,
    NotSupported
} from "./Errors.sol";

/// @dev The staked token should be deployed on Ethereum.
/// This is adapted from https://github.com/bgd-labs/aave-stk-v1-5/blob/8867dd5b1137d4d46acd9716fe98759cb16b1606/src/contracts/StakedTokenV3.sol
// solhint-disable not-rely-on-time, var-name-mixedcase
// slither-disable-start timestamp
abstract contract StakedMultiToken is IStakedMultiToken, ERC1155SupplyUpgradeable, RewardDistribution, AlertSystem {
    using SafeERC20 for IERC20;

    struct ProtocolConfig {
        address vault;
        /// @dev Seconds between starting cooldown and being able to update fee
        uint40 cooldownSeconds;
        Fee fee;
    }

    struct OperatorConfig {
        /// @dev Seconds between starting cooldown and being able to update fee
        uint40 cooldownSeconds;
        mapping(address => Fee) fees;
    }

    struct Fee {
        uint40 cooldownEndTimestamp;
        uint16 bps;
        uint16 pendingBPS;
    }

    /// @dev MAX_BPS the maximum number of basis points.
    /// 10000 basis points are equivalent to 100%.
    uint256 public constant MAX_BPS = 1e4;

    /// @dev total fee BPS should not exceed MAX_BPS
    uint16 public constant MAX_PROTOCOL_FEE_BPS = 2e3;

    /// @dev total fee BPS should not exceed MAX_BPS
    uint16 public constant MAX_OPERATOR_FEE_BPS = 2e3;

    uint40 public constant MAX_COOLDOWN_SEC = 4320000;

    IERC20 public immutable stakedToken;
    uint40 public immutable stakingStartTimestamp;

    ProtocolConfig public protocolConfig;

    OperatorConfig public operatorConfig;

    /// @dev Seconds between starting cooldown and being able to withdraw
    uint40 public cooldownSeconds;

    /// hash(operator, distribution id, staker) => rewardsBalance
    mapping(bytes32 => uint256) private _rewardsBalances;

    uint256 public totalStakedAmount;
    uint256 public totalCooldownAmount;
    uint256 public totalFrozenAmount;
    uint256 public totalFrozenCooldownAmount;

    // operator => total cooldown amount
    mapping(address => uint256) public totalCooldownAmounts;

    struct CooldownSnapshot {
        uint40 timestamp;
        uint216 amount;
    }

    mapping(address => mapping(address => CooldownSnapshot)) public cooldowns;

    /// @notice Minimum stake required to vote on an alert
    uint256 public minVotingStake;

    /// @dev This empty reserved space is put in place to allow future versions to add new
    /// variables without shifting down storage in the inheritance chain.
    /// See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
    // slither-disable-next-line unused-state
    uint256[39] private __gap;

    modifier onlyValidCooldownSec(uint40 cooldownSec_) {
        if (cooldownSec_ > MAX_COOLDOWN_SEC) {
            revert GreaterThanMaxCooldownSec();
        }
        _;
    }

    modifier onlyValidOperator(address operator) {
        if (!isOperator(operator)) {
            revert NotOperator();
        }
        _;
    }

    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor(IERC20 stakedToken_, uint40 stakingStartTimestamp_) {
        _disableInitializers();

        if (address(stakedToken_) == address(0)) {
            revert ZeroAddress();
        }

        if (stakingStartTimestamp_ <= block.timestamp) {
            revert InvalidStakingStartTime();
        }

        stakedToken = stakedToken_;
        stakingStartTimestamp = stakingStartTimestamp_;
    }

    ///////////////////////
    // External Functions
    ///////////////////////

    function initialize(
        address initialOwner_,
        string calldata uri_,
        uint40 cooldownSec_,
        uint40 cooldownSecForOperatorFeeUpdate_,
        uint40 cooldownSecForProtocolFeeUpdate_,
        address protocolFeeVault_,
        uint16 initialProtocolFeeBPS_,
        uint256 initialMinVotingStake_,
        uint16 initialExpiryDuration
    ) external initializer {
        if (initialOwner_ == address(0) || protocolFeeVault_ == address(0)) {
            revert ZeroAddress();
        }
        if (initialProtocolFeeBPS_ > MAX_PROTOCOL_FEE_BPS) {
            revert InvalidBPS();
        }

        __Pausable_init();
        // This is a multisig account
        __Ownable_init(initialOwner_);
        __ERC1155_init(uri_);
        __ERC1155Supply_init();
        __AlertSystem_init(initialExpiryDuration);
        _setProtocolFeeBPS(initialProtocolFeeBPS_);

        cooldownSeconds = cooldownSec_;
        operatorConfig.cooldownSeconds = cooldownSecForOperatorFeeUpdate_;

        protocolConfig.cooldownSeconds = cooldownSecForProtocolFeeUpdate_;
        protocolConfig.vault = protocolFeeVault_;

        minVotingStake = initialMinVotingStake_;
    }

    /// @inheritdoc IStakedMultiToken
    function registerOperator(address operator, uint16 feeBPS_) external onlyOwner {
        if (feeBPS_ > MAX_OPERATOR_FEE_BPS) {
            revert InvalidBPS();
        }

        if (isOperator(operator)) {
            revert AlreadyRegistered();
        }

        // slither-disable-next-line unused-return
        _addOperator(operator);

        _updateAllDistribution(totalVotingStake());
        _setOperatorFeeBPS(operator, feeBPS_);
        emit OperatorRegistered(operator);
    }

    /// @inheritdoc IStakedMultiToken
    function setMinVotingStake(uint256 minVotingStake_) external onlyOwner {
        minVotingStake = minVotingStake_;
        emit SetMinVotingStake(minVotingStake_);
    }

    /// @inheritdoc IStakedMultiToken
    function setCooldownSecForOperatorFee(uint40 cooldownSec_) external onlyOwner onlyValidCooldownSec(cooldownSec_) {
        operatorConfig.cooldownSeconds = cooldownSec_;
        emit SetCooldownSecForOperatorFee(cooldownSec_);
    }

    /// @inheritdoc IStakedMultiToken
    function setCooldownSecForProtocolFee(uint40 cooldownSec_) external onlyOwner onlyValidCooldownSec(cooldownSec_) {
        protocolConfig.cooldownSeconds = cooldownSec_;
        emit SetCooldownSecForProtocolFee(cooldownSec_);
    }

    /// @inheritdoc IStakedMultiToken
    function setCooldownSecForUnstaking(uint40 cooldownSec_) external onlyOwner onlyValidCooldownSec(cooldownSec_) {
        cooldownSeconds = cooldownSec_;
        emit SetCooldownSecForUnstaking(cooldownSec_);
    }

    /// @inheritdoc IStakedMultiToken
    function cooldownToUpdateProtocolFee(uint16 feeBPS_) external onlyOwner {
        if (feeBPS_ > MAX_PROTOCOL_FEE_BPS) {
            revert InvalidBPS();
        }
        uint40 cooldownEndTimestamp = uint40(block.timestamp) + protocolConfig.cooldownSeconds;
        protocolConfig.fee.cooldownEndTimestamp = cooldownEndTimestamp;
        protocolConfig.fee.pendingBPS = feeBPS_;
        emit CooldownToUpdateProtocolFee(feeBPS_, cooldownEndTimestamp);
    }

    /// @inheritdoc IStakedMultiToken
    function setProtocolFeeBPS() external onlyOwner {
        if (protocolConfig.fee.cooldownEndTimestamp > block.timestamp) {
            revert InsufficientCooldown();
        }
        _setProtocolFeeBPS(protocolConfig.fee.pendingBPS);
    }

    /// @inheritdoc IStakedMultiToken
    function setOperatorFeeBPS() external onlyOperator whenNotPaused {
        address operator = _msgSender();
        if (operatorConfig.fees[operator].cooldownEndTimestamp > block.timestamp) {
            revert InsufficientCooldown();
        }
        _setOperatorFeeBPS(operator, operatorConfig.fees[operator].pendingBPS);
    }

    /// @inheritdoc IStakedMultiToken
    function cooldownToUpdateOperatorFee(uint16 feeBPS_) external onlyOperator whenNotPaused {
        if (feeBPS_ > MAX_OPERATOR_FEE_BPS) {
            revert InvalidBPS();
        }
        address operator = _msgSender();
        uint40 cooldownEndTimestamp = uint40(block.timestamp) + operatorConfig.cooldownSeconds;
        operatorConfig.fees[operator].cooldownEndTimestamp = cooldownEndTimestamp;
        operatorConfig.fees[operator].pendingBPS = feeBPS_;

        emit CooldownToUpdateOperatorFee(operator, feeBPS_, cooldownEndTimestamp);
    }

    /// @inheritdoc IStakedMultiToken
    function stake(address to, address operator, uint256 amount) external {
        if (amount == 0) {
            revert ZeroAmount();
        }
        if (stakingStartTimestamp > block.timestamp) {
            revert StakingNotStartedYet();
        }
        address from = _msgSender();
        _updateCurrentUnclaimedRewards(to, operator, votingStake(to, operator));
        _stake(from, to, operator, amount);
    }

    /// @inheritdoc IStakedMultiToken
    function cooldownToUnstake(address operator, uint256 amountToAdd)
        external
        onlyValidOperator(operator)
        whenNotPaused
    {
        address from = _msgSender();
        uint256 balance = balanceOf(from, operator);

        CooldownSnapshot storage currentCooldown = cooldowns[operator][from];

        uint256 newCooldownAmount = amountToAdd + currentCooldown.amount;

        if (amountToAdd == 0 || newCooldownAmount > balance) {
            revert InvalidCooldownAmount();
        }

        _updateCurrentUnclaimedRewards(from, operator, votingStake(from, operator));

        emit CooldownToUnstake(from, operator, newCooldownAmount);

        currentCooldown.amount = uint216(newCooldownAmount);
        currentCooldown.timestamp = uint40(block.timestamp);

        totalCooldownAmounts[operator] += amountToAdd;
        totalCooldownAmount += amountToAdd;
        if (isFrozenOperator(operator)) {
            totalFrozenCooldownAmount += amountToAdd;
        }
    }

    /// @inheritdoc IStakedMultiToken
    /// @dev This function allows a token holder to transfer their voting stake from one operator to another.
    /// If the `amount` is 0 or the sender has a zero voting stake with the `fromOperator`, the transaction reverts.
    /// It first unstakes the voting stake from the `fromOperator` and then stakes the same amount with the `toOperator`.
    /// The function uses `_msgSender` to identify the caller.
    function switchOperator(address fromOperator, address toOperator, uint256 amount) external {
        if (amount == 0) {
            revert ZeroAmount();
        }

        if (fromOperator == toOperator) {
            revert InvalidDestination();
        }

        address sender = _msgSender();
        uint256 max = votingStake(sender, fromOperator);

        if (max == 0) {
            revert ZeroVotingStake();
        }

        uint256 amountToTransfer = (amount > max) ? max : amount;

        _updateCurrentUnclaimedRewards(sender, fromOperator, votingStake(sender, fromOperator));
        _unstake(sender, sender, fromOperator, amountToTransfer);

        _updateCurrentUnclaimedRewards(sender, toOperator, votingStake(sender, toOperator));
        _stake(sender, sender, toOperator, amountToTransfer);
    }

    /// @inheritdoc IStakedMultiToken
    function unstake(address to, address operator, uint256 amount) external {
        if (amount == 0) {
            revert ZeroAmount();
        }

        address from = _msgSender();
        CooldownSnapshot memory cooldownSnapshot = cooldowns[operator][from];
        if (block.timestamp < cooldownSnapshot.timestamp + cooldownSeconds) {
            revert InsufficientCooldown();
        }

        uint256 max = cooldownSnapshot.amount;
        if (max == 0) {
            revert ZeroUnstakeable();
        }

        _updateCurrentUnclaimedRewards(from, operator, votingStake(from, operator));

        uint256 amountToUnstake = (amount > max) ? max : amount;

        if (cooldownSnapshot.timestamp > 0) {
            if (cooldownSnapshot.amount - amountToUnstake == 0) {
                delete cooldowns[operator][from];
            } else {
                cooldowns[operator][from].amount -= uint216(amountToUnstake);
            }
            totalCooldownAmount -= amountToUnstake;
            totalCooldownAmounts[operator] -= amountToUnstake;
            if (isFrozenOperator(operator)) {
                totalFrozenCooldownAmount -= amountToUnstake;
            }
        }
        _unstake(from, to, operator, amountToUnstake);
    }

    /// @inheritdoc IStakedMultiToken
    function claimRewardsBatch(
        uint16[] calldata ids_,
        address[] calldata recipients_,
        address[] calldata operators_,
        uint256[] calldata amounts_
    ) external {
        // Check that all input arrays are of equal length
        if (ids_.length != recipients_.length || ids_.length != operators_.length || ids_.length != amounts_.length) {
            revert ArrayLengthMismatch();
        }

        // Proceed with claiming rewards for each set of parameters
        for (uint256 i; i < ids_.length; ++i) {
            claimRewards(ids_[i], recipients_[i], operators_[i], amounts_[i]);
        }
    }

    /// @inheritdoc IStakedMultiToken
    function claimRewards(uint16 distributionId, address to, address operator, uint256 amount)
        public
        onlyValidOperator(operator)
        whenNotPaused
    {
        address from = _msgSender();
        _updateCurrentUnclaimedRewards(from, operator, votingStake(from, operator));

        bytes32 key = rewardBalanceKey(distributionId, operator, from);
        uint256 unclaimedRewards = _rewardsBalances[key];

        uint256 amountToClaim = amount > unclaimedRewards ? unclaimedRewards : amount;

        // slither-disable-next-line incorrect-equality
        if (amountToClaim == 0) {
            revert ZeroAmount();
        }

        _rewardsBalances[key] = unclaimedRewards - amountToClaim;

        emit RewardsClaimed(from, to, operator, amountToClaim);

        DistributionData storage distribution = distributions[distributionId];

        // slither-disable-next-line arbitrary-send-erc20
        distribution.rewardToken.safeTransferFrom(distribution.rewardVault, to, amountToClaim);
    }

    /// @inheritdoc IStakedMultiToken
    function freezeOperator(address operator) external onlyOwner onlyOperatorNotFrozen(operator) {
        // before freezing, all distributions should be updated
        _updateAllDistribution(totalVotingStake());
        _freezeOperator(operator);
        totalFrozenAmount += totalSupply(operator);
        totalFrozenCooldownAmount += totalCooldownAmounts[operator];
        _clearVotes(operator);
    }

    /// @inheritdoc IStakedMultiToken
    function rewardBalance(uint16 distributionId, address operator, address staker) public view returns (uint256) {
        return _rewardsBalances[rewardBalanceKey(distributionId, operator, staker)];
    }

    /// @inheritdoc IStakedMultiToken
    function operatorFee(address operator)
        public
        view
        returns (uint40 cooldownEndTimestamp, uint16 bps, uint16 pendingBPS)
    {
        Fee memory fee = operatorConfig.fees[operator];
        cooldownEndTimestamp = fee.cooldownEndTimestamp;
        bps = fee.bps;
        pendingBPS = fee.pendingBPS;
    }

    /// @inheritdoc IStakedMultiToken
    function isActiveOperator(address operator) public view returns (bool) {
        return totalVotingStake(operator) >= minVotingStake && !isFrozenOperator(operator);
    }

    /// @inheritdoc IStakedMultiToken
    function totalActiveOperators() public view returns (uint256) {
        uint256 total;

        // Note: Assume the total number of operator is small
        address[] memory operatorArray = queryOperators(0, totalOperators());

        for (uint256 i; i < operatorArray.length; ++i) {
            if (isActiveOperator(operatorArray[i])) {
                unchecked {
                    ++total;
                }
            }
        }
        return total;
    }

    /// @inheritdoc IStakedMultiToken
    function balanceOf(address staker, address operator) public view returns (uint256) {
        return balanceOf(staker, addressToUint256(operator));
    }

    function totalVotingStake() public view returns (uint256) {
        return totalStakedAmount + totalFrozenCooldownAmount - totalFrozenAmount - totalCooldownAmount;
    }

    /// @inheritdoc IStakedMultiToken
    function totalVotingStake(address operator) public view returns (uint256) {
        return isFrozenOperator(operator) ? 0 : totalSupply(operator) - totalCooldownAmounts[operator];
    }

    /// @inheritdoc IStakedMultiToken
    function votingStake(address staker, address operator) public view returns (uint256) {
        return isFrozenOperator(operator) ? 0 : balanceOf(staker, operator) - cooldowns[operator][staker].amount;
    }

    /// @inheritdoc IStakedMultiToken
    function totalSupply(address operator) public view returns (uint256) {
        return totalSupply(addressToUint256(operator));
    }

    /// @inheritdoc IStakedMultiToken
    function activationThreshold() public view returns (uint256) {
        return (totalActiveOperators() * 2) / 3;
    }

    /// @inheritdoc IStakedMultiToken
    function isActiveAlert(uint128 voteCount) public view override(IStakedMultiToken, AlertSystem) returns (bool) {
        return voteCount >= activationThreshold();
    }

    /// @inheritdoc IStakedMultiToken
    function getAccruedRewards(uint16 distributionId, address staker, address operator)
        external
        view
        returns (uint256)
    {
        DistributionData storage distribution = distributions[distributionId];

        uint256 ditributionIndex = _getDistributionIndex(
            distributionId, distribution.index, _lastUpdateTimestamp(distribution), totalVotingStake()
        );
        uint256 userIndex = distribution.userIndices[operator][staker];

        uint256 accruedRewards = _getAccruedRewards(votingStake(staker, operator), ditributionIndex, userIndex);

        return accruedRewards;
    }

    /// @inheritdoc IStakedMultiToken
    function rewardBalanceKey(uint16 distributionId, address operator, address staker) public pure returns (bytes32) {
        return keccak256(abi.encode(distributionId, operator, staker));
    }

    /// @inheritdoc IStakedMultiToken
    function addressToUint256(address operator) public pure returns (uint256) {
        return uint256(uint160(operator));
    }

    ///////////////////////
    // Internal Functions
    ///////////////////////

    function _collectFee(uint16 distributionId, address operator, uint256 rewards)
        internal
        override
        returns (uint256)
    {
        DistributionData storage distribution = distributions[distributionId];
        IERC20 rewardToken = distribution.rewardToken;
        address rewardVault = distribution.rewardVault;

        // Calculate the protocol fee as a percentage of the rewards.
        uint256 protocolFeeAmount = (rewards * protocolConfig.fee.bps) / MAX_BPS;
        // Calculate the operator fee similarly as a percentage of the rewards.
        uint256 operatorFeeAmount = (rewards * operatorConfig.fees[operator].bps) / MAX_BPS;

        uint256 userRewards = rewards - (protocolFeeAmount + operatorFeeAmount);

        // Emit an event for the fee collection, providing transparency and traceability.
        emit CollectFee(distributionId, operator, protocolFeeAmount, operatorFeeAmount, userRewards);

        if (protocolFeeAmount > 0) {
            // slither-disable-next-line arbitrary-send-erc20
            rewardToken.safeTransferFrom(rewardVault, protocolConfig.vault, protocolFeeAmount);
        }

        if (operatorFeeAmount > 0) {
            // slither-disable-next-line arbitrary-send-erc20
            rewardToken.safeTransferFrom(rewardVault, operator, operatorFeeAmount);
        }

        // Return the remaining rewards after deducting both the protocol and operator fees.
        return userRewards;
    }

    function _setProtocolFeeBPS(uint16 feeBPS) internal {
        protocolConfig.fee.bps = feeBPS;
        emit SetProtocolFeeBPS(feeBPS);
    }

    function _setOperatorFeeBPS(address operator, uint16 feeBPS) internal {
        operatorConfig.fees[operator].bps = feeBPS;
        emit SetOperatorFeeBPS(operator, feeBPS);
    }

    function _stake(address from, address to, address operator, uint256 amount)
        internal
        onlyValidOperator(operator)
        onlyOperatorNotFrozen(operator)
    {
        emit Stake(from, to, operator, amount);

        // NOTE: Ensure users must transfer the stakedToken funds before receiving the funds and code execution from the receiver hook.
        stakedToken.safeTransferFrom(from, address(this), amount);

        _mint(to, addressToUint256(operator), amount, "");
        totalStakedAmount += amount;
    }

    function _unstake(address from, address to, address operator, uint256 amount)
        internal
        onlyValidOperator(operator)
    {
        emit Unstake(from, to, operator, amount);

        _burn(from, addressToUint256(operator), amount);
        totalStakedAmount -= amount;
        if (isFrozenOperator(operator)) {
            totalFrozenAmount -= amount;
        }

        if (!isActiveOperator(operator)) {
            _clearVotes(operator);
        }

        IERC20(stakedToken).safeTransfer(to, amount);
    }

    function _clearVotes(address operator) internal {
        // clear all the votes where the alert is not valid yet.
        bytes32[] memory hashes = votedAlerts[operator];
        for (uint256 i; i < hashes.length; ++i) {
            bytes32 messageHash = hashes[i];

            AlertData storage currentAlert = alerts[messageHash];
            // NOTE: vote count can be zero when admin has removed this alert
            if (!currentAlert.isActive && currentAlert.voteCount > 0) {
                currentAlert.voteCount--;
                delete currentAlert.voted[currentAlert.resetCount][operator];
            }
        }
        // reinitialize it
        votedAlerts[operator] = new bytes32[](0);
    }

    function _vote(bytes32 messageHash, uint40 expiry, address nodeKey) internal override(AlertSystem) {
        address operator = operators[nodeKey];

        // Revert if the operator is frozen
        if (isFrozenOperator(operator)) {
            revert FrozenOperator();
        }

        // Revert if the operator has less stake than the minimum required to vote
        if (totalVotingStake(operator) < minVotingStake) {
            revert LessThanMinStakeToVote();
        }

        super._vote(messageHash, expiry, nodeKey);
    }

    /// @dev Updates the user state related with his accrued rewards
    /// @param user Address of the user
    /// @param operator The identifier of the staking pool
    /// @param votingStake_ The current voting stake of the user
    function _updateCurrentUnclaimedRewards(address user, address operator, uint256 votingStake_) internal {
        for (uint16 distributionId = 1; distributionId <= totalDistributions; ++distributionId) {
            uint256 accruedRewards = _updateUser(distributionId, user, operator, votingStake_, totalVotingStake());
            if (accruedRewards != 0) {
                bytes32 key = rewardBalanceKey(distributionId, operator, user);
                _rewardsBalances[key] += accruedRewards;
                emit RewardsAccrued(user, operator, accruedRewards);
            }
        }
    }

    function _update(address from, address to, uint256[] memory ids, uint256[] memory values)
        internal
        override
        whenNotPaused
    {
        // When safeTransferFrom
        // Update unclaimed rewards first
        if (from != address(0) && to != address(0)) {
            // Assume the length of ids and values are the same.
            for (uint256 i; i < ids.length; ++i) {
                address operator = address(uint160(ids[i]));

                // Sender
                _updateCurrentUnclaimedRewards(from, operator, votingStake(from, operator));

                // Recipient
                if (from != to) {
                    _updateCurrentUnclaimedRewards(to, operator, votingStake(to, operator));
                }
            }
        }

        super._update(from, to, ids, values);

        // NOTE: cooldown amount cannot be transferred.
        // cooldown amount only can be unstaked.
        // balance - cooldown amount = votingStake
        for (uint256 i; i < ids.length; ++i) {
            address operator = address(uint160(ids[i]));
            CooldownSnapshot storage currentCooldown = cooldowns[operator][from];
            // Make sure the cooldown amount is not greater than the balance
            if (currentCooldown.amount > balanceOf(from, operator)) {
                revert InsufficientAmount();
            }
        }
    }
}

// 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) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

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

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/extensions/ERC1155Supply.sol)

pragma solidity ^0.8.20;

import {ERC1155Upgradeable} from "../ERC1155Upgradeable.sol";
import {Initializable} from "../../../proxy/utils/Initializable.sol";

/**
 * @dev Extension of ERC1155 that adds tracking of total supply per id.
 *
 * Useful for scenarios where Fungible and Non-fungible tokens have to be
 * clearly identified. Note: While a totalSupply of 1 might mean the
 * corresponding is an NFT, there is no guarantees that no other token with the
 * same id are not going to be minted.
 *
 * NOTE: This contract implies a global limit of 2**256 - 1 to the number of tokens
 * that can be minted.
 *
 * CAUTION: This extension should not be added in an upgrade to an already deployed contract.
 */
abstract contract ERC1155SupplyUpgradeable is Initializable, ERC1155Upgradeable {
    /// @custom:storage-location erc7201:openzeppelin.storage.ERC1155Supply
    struct ERC1155SupplyStorage {
        mapping(uint256 id => uint256) _totalSupply;
        uint256 _totalSupplyAll;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC1155Supply")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant ERC1155SupplyStorageLocation = 0x4a593662ee04d27b6a00ebb31be7fe0c102c2ade82a7c5d764f2df05dc4e2800;

    function _getERC1155SupplyStorage() private pure returns (ERC1155SupplyStorage storage $) {
        assembly {
            $.slot := ERC1155SupplyStorageLocation
        }
    }

    function __ERC1155Supply_init() internal onlyInitializing {
    }

    function __ERC1155Supply_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev Total value of tokens in with a given id.
     */
    function totalSupply(uint256 id) public view virtual returns (uint256) {
        ERC1155SupplyStorage storage $ = _getERC1155SupplyStorage();
        return $._totalSupply[id];
    }

    /**
     * @dev Total value of tokens.
     */
    function totalSupply() public view virtual returns (uint256) {
        ERC1155SupplyStorage storage $ = _getERC1155SupplyStorage();
        return $._totalSupplyAll;
    }

    /**
     * @dev Indicates whether any token exist with a given id, or not.
     */
    function exists(uint256 id) public view virtual returns (bool) {
        return totalSupply(id) > 0;
    }

    /**
     * @dev See {ERC1155-_update}.
     */
    function _update(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values
    ) internal virtual override {
        ERC1155SupplyStorage storage $ = _getERC1155SupplyStorage();
        super._update(from, to, ids, values);

        if (from == address(0)) {
            uint256 totalMintValue = 0;
            for (uint256 i = 0; i < ids.length; ++i) {
                uint256 value = values[i];
                // Overflow check required: The rest of the code assumes that totalSupply never overflows
                $._totalSupply[ids[i]] += value;
                totalMintValue += value;
            }
            // Overflow check required: The rest of the code assumes that totalSupplyAll never overflows
            $._totalSupplyAll += totalMintValue;
        }

        if (to == address(0)) {
            uint256 totalBurnValue = 0;
            for (uint256 i = 0; i < ids.length; ++i) {
                uint256 value = values[i];

                unchecked {
                    // Overflow not possible: values[i] <= balanceOf(from, ids[i]) <= totalSupply(ids[i])
                    $._totalSupply[ids[i]] -= value;
                    // Overflow not possible: sum_i(values[i]) <= sum_i(totalSupply(ids[i])) <= totalSupplyAll
                    totalBurnValue += value;
                }
            }
            unchecked {
                // Overflow not possible: totalBurnValue = sum_i(values[i]) <= sum_i(totalSupply(ids[i])) <= totalSupplyAll
                $._totalSupplyAll -= totalBurnValue;
            }
        }
    }
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity =0.8.23;

/// @title IStakedMultiToken Interface
/// @notice Interface for the Staked MultiToken system, allowing for token staking, operator management, and reward distribution.
interface IStakedMultiToken {
    ////////////////
    // Events
    ////////////////

    event OperatorRegistered(address operator);
    event Stake(address indexed from, address indexed onBehalfOf, address operator, uint256 assets);

    event RewardsAccrued(address user, address operator, uint256 amount);
    event RewardsClaimed(address indexed from, address indexed to, address operator, uint256 amount);

    event CooldownToUnstake(address indexed user, address indexed operator, uint256 amount);
    event CooldownToUpdateProtocolFee(uint16 feeBPS, uint40 cooldownEndTimestamp);
    event CooldownToUpdateOperatorFee(address operator, uint16 feeBPS, uint40 cooldownEndTimestamp);

    event Unstake(address indexed from, address indexed to, address operator, uint256 assets);
    event SetOperatorFeeBPS(address operator, uint16 feeBPS);
    event SetProtocolFeeBPS(uint16 feeBPS);

    event SetMinVotingStake(uint256 minVotingStake);
    event SetCooldownSecForUnstaking(uint40 cooldownSeconds);
    event SetCooldownSecForOperatorFee(uint40 cooldownSeconds);
    event SetCooldownSecForProtocolFee(uint40 cooldownSeconds);
    event CollectFee(
        uint16 distributionId, address operator, uint256 protocolFee, uint256 operatorFee, uint256 userRewards
    );

    ////////////////
    // Functions
    ////////////////

    /// @notice Registers a new operator and sets their fee in basis points
    /// @param operator The address of the operator to register
    /// @param feeBPS The fee in basis points
    function registerOperator(address operator, uint16 feeBPS) external;

    /// @notice Freezes an operator, preventing them from performing certain actions
    /// @param operator The address of the operator to freeze
    function freezeOperator(address operator) external;

    /// @notice Gets the balance of a staker for a specific operator
    /// @param staker The address of the staker
    /// @param operator The address of the operator
    /// @return The balance of staked tokens
    function balanceOf(address staker, address operator) external view returns (uint256);

    /// @notice Gets the voting stake of a staker for a specific operator
    /// @param staker The address of the staker
    /// @param operator The address of the operator
    /// @return The voting stake amount
    function votingStake(address staker, address operator) external view returns (uint256);

    /// @notice Gets the total voting stake of a operator
    /// @param operator The address of the operator
    /// @return The total voting stake amount
    function totalVotingStake(address operator) external view returns (uint256);

    /// @notice Gets the total supply of staked tokens for a specific operator
    /// @param operator The address of the operator
    /// @return The total supply of staked tokens
    function totalSupply(address operator) external view returns (uint256);

    /// @notice Sets the minimum voting stake
    /// @param minVotingStake_ The minimum voting stake
    function setMinVotingStake(uint256 minVotingStake_) external;

    /// @notice Sets the cooldown seconds for operator fee updates
    /// @param cooldownSeconds_ The cooldown period in seconds
    function setCooldownSecForOperatorFee(uint40 cooldownSeconds_) external;

    /// @notice Sets the cooldown seconds for protocol fee updates
    /// @param cooldownSeconds_ The cooldown period in seconds
    function setCooldownSecForProtocolFee(uint40 cooldownSeconds_) external;

    /// @notice Sets the general cooldown period in seconds
    /// @param cooldownSeconds_ The cooldown period in seconds
    function setCooldownSecForUnstaking(uint40 cooldownSeconds_) external;

    /// @notice Initiates the cooldown period for protocol fee updates
    /// @param feeBPS The fee in basis points
    function cooldownToUpdateProtocolFee(uint16 feeBPS) external;

    /// @notice Initiates the cooldown period for operator fee updates
    /// @param feeBPS The fee in basis points
    function cooldownToUpdateOperatorFee(uint16 feeBPS) external;

    /// @notice Sets the protocol fee in basis points
    function setProtocolFeeBPS() external;

    /// @notice Sets the operator fee in basis points
    function setOperatorFeeBPS() external;

    /// @notice Claims accrued rewards for a staker
    /// @param distributionId The distribution ID
    /// @param to The address to send rewards to
    /// @param operator The address of the operator
    /// @param amount The amount of rewards to claim
    function claimRewards(uint16 distributionId, address to, address operator, uint256 amount) external;

    /// @notice Claims accrued rewards for multiple stakers in a single transaction.
    /// @param ids Array of distribution IDs for which rewards are being claimed.
    /// @param recipients Array of addresses to receive the claimed rewards, corresponding to each distribution ID.
    /// @param operators Array of operator addresses associated with each reward distribution, managing the distribution rules and potentially fees.
    /// @param amounts Array of amounts of rewards to be claimed for each distribution ID.
    function claimRewardsBatch(
        uint16[] calldata ids,
        address[] calldata recipients,
        address[] calldata operators,
        uint256[] calldata amounts
    ) external;

    /// @notice Stakes tokens on behalf of a user
    /// @param to The address on whose behalf tokens are being staked
    /// @param operator The address of the operator
    /// @param amount The amount of tokens to stake
    function stake(address to, address operator, uint256 amount) external;

    /// @notice Switches voting power from one operator to another for a specified amount.
    /// @param fromOperator The address of the current operator from which the voting power is being moved.
    /// @param toOperator The address of the new operator to which the voting power will be moved.
    /// @param amount The amount of voting power to transfer.
    function switchOperator(address fromOperator, address toOperator, uint256 amount) external;

    /// @notice Initiates the cooldown period for a user's staked tokens
    /// @param operator The address of the operator
    /// @param amountToAdd The amount of tokens to cooldown. This is additive.
    function cooldownToUnstake(address operator, uint256 amountToAdd) external;

    /// @notice Unstakes tokens and stops earning rewards
    /// @param to The address to unstake tokens to
    /// @param operator The address of the operator
    /// @param amount The amount of tokens to unstake
    function unstake(address to, address operator, uint256 amount) external;

    /// @notice Gets the accrued rewards for a staker within a specific distribution and operator context
    /// @param distributionId The distribution ID for which to query rewards
    /// @param staker The address of the staker
    /// @param operator The address of the operator
    /// @return The amount of accrued rewards
    function getAccruedRewards(uint16 distributionId, address staker, address operator)
        external
        view
        returns (uint256);

    /// @notice Gets the reward balance for a specific distribution, operator, and staker combination
    /// @param distributionId The ID of the distribution for which the reward balance is queried
    /// @param operator The address of the operator
    /// @param staker The address of the staker
    /// @return The amount of accrued rewards
    function rewardBalance(uint16 distributionId, address operator, address staker) external view returns (uint256);

    /// Gets operator fee information
    /// @param operator The address of the operator
    function operatorFee(address operator)
        external
        view
        returns (uint40 cooldownEndTimestamp, uint16 bps, uint16 pendingBPS);

    /// @notice Checks if an operator is active based on their total voting stake.
    /// @dev An operator is considered active if their total voting stake is at least the minimum required.
    /// @param operator The address of the operator to check.
    /// @return True if the operator's total voting stake is at least the minimum required, false otherwise.
    function isActiveOperator(address operator) external view returns (bool);

    /// @notice Counts the total number of active operators.
    /// @dev Iterates through all operators and counts those that are active.
    /// @return The total number of active operators.
    function totalActiveOperators() external view returns (uint256);

    /// @notice Calculates the activation threshold for alerts.
    /// @dev The activation threshold is determined as two-thirds of the total number of active operators.
    /// @return The calculated activation threshold.
    function activationThreshold() external view returns (uint256);

    /// @notice Determines if an alert is active based on the given vote count.
    /// @dev An alert is considered active if the vote count meets or exceeds the activation threshold.
    /// @param voteCount The number of votes to check against the activation threshold.
    /// @return True if the vote count meets or exceeds the activation threshold, false otherwise.
    function isActiveAlert(uint128 voteCount) external view returns (bool);

    /// @notice Generates a unique key for a reward balance based on distribution ID, operator, and staker
    /// @param distributionId The ID of the distribution
    /// @param operator The address of the operator
    /// @param staker The address of the staker
    /// @return A unique key for querying reward balances
    function rewardBalanceKey(uint16 distributionId, address operator, address staker)
        external
        pure
        returns (bytes32);

    /// @notice Converts an address to a `uint256` representation
    /// @param operator The address to convert
    /// @return The `uint256` representation of the address
    function addressToUint256(address operator) external pure returns (uint256);
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity =0.8.23;

import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ZeroAddress, InvalidDistributionStartTime, InvalidDistributionEndTime} from "./Errors.sol";
import {OperatorRegistry} from "./OperatorRegistry.sol";
import {IRewardDistribution} from "./interfaces/IRewardDistribution.sol";

struct DistributionData {
    uint128 emissionPerSecond;
    IERC20 rewardToken;
    /// @dev Address to pull from the rewards, needs to have approved this contract
    address rewardVault;
    uint40 startTime;
    uint40 endTime;
    uint256 index;
    uint40 updateTimestamp;
    mapping(address => mapping(address => uint256)) userIndices;
}

/// @dev Accounting contract to manage staking distributions
/// This is adapted from https://github.com/bgd-labs/aave-stk-v1-5/blob/8867dd5b1137d4d46acd9716fe98759cb16b1606/src/contracts/AaveDistributionManager.sol
// solhint-disable not-rely-on-time
abstract contract RewardDistribution is OperatorRegistry, IRewardDistribution {
    using SafeERC20 for IERC20;

    uint256 public constant PRECISION_FACTOR = 1e18;
    uint16 public totalDistributions;

    // Distribution ID => Distribution Data
    mapping(uint16 => DistributionData) public distributions;

    /// @dev This empty reserved space is put in place to allow future versions to add new
    /// variables without shifting down storage in the inheritance chain.
    /// See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
    // slither-disable-next-line unused-state
    uint256[48] private __gap;

    modifier onlyValidDistributionEndTime(uint40 endTime) {
        if (endTime < block.timestamp) {
            revert InvalidDistributionEndTime();
        }
        _;
    }

    ///////////////////////
    // External Functions
    ///////////////////////

    /// @inheritdoc IRewardDistribution
    function createDistribution(
        uint128 emissionPerSecond_,
        uint40 startTime_,
        uint40 endTime_,
        IERC20 rewardToken_,
        address rewardVault_
    ) external onlyOwner onlyValidDistributionEndTime(endTime_) {
        if (startTime_ <= block.timestamp) {
            revert InvalidDistributionStartTime();
        }

        if (startTime_ >= endTime_) {
            revert InvalidDistributionEndTime();
        }

        if (address(rewardToken_) == address(0)) {
            revert ZeroAddress();
        }
        if (rewardVault_ == address(0)) {
            revert ZeroAddress();
        }

        totalDistributions++;
        uint16 distributionId = totalDistributions;

        DistributionData storage distribution = distributions[distributionId];

        distribution.emissionPerSecond = emissionPerSecond_;
        distribution.startTime = startTime_;
        distribution.endTime = endTime_;
        distribution.rewardToken = rewardToken_;
        distribution.rewardVault = rewardVault_;
    }

    /// @inheritdoc IRewardDistribution
    function setDistributionEnd(uint16 distributionId, uint40 endTime)
        external
        onlyOwner
        onlyValidDistributionEndTime(endTime)
    {
        DistributionData storage distribution = distributions[distributionId];

        if (endTime <= distribution.startTime) {
            revert InvalidDistributionEndTime();
        }

        distribution.endTime = endTime;
    }

    /// @inheritdoc IRewardDistribution
    function distributionIndex(uint16 distributionId) external view returns (uint256) {
        return distributions[distributionId].index;
    }

    /// @inheritdoc IRewardDistribution
    function distributionUserIndex(uint16 distributionId, address operator, address staker)
        external
        view
        returns (uint256)
    {
        return distributions[distributionId].userIndices[operator][staker];
    }

    ///////////////////////
    // Internal Functions
    ///////////////////////

    /// @dev Updates the distribution index based on time elapsed and emission rate, respecting the distribution period and supply constraints.
    /// @param distributionId Identifier for the specific distribution.
    /// @param currentIndex The current index reflecting the accumulated distribution up to the last update.
    /// @param lastUpdateTimestamp_ Timestamp of the last update, used to calculate time elapsed.
    /// @param totalSupply The total token supply.
    /// @return The updated index, or the current index if conditions prevent recalculation (e.g., no time elapsed, emission rate or total supply is zero, outside distribution period).
    function _getDistributionIndex(
        uint16 distributionId,
        uint256 currentIndex,
        uint40 lastUpdateTimestamp_,
        uint256 totalSupply
    ) internal view returns (uint256) {
        DistributionData storage distribution = distributions[distributionId];
        if (
            // slither-disable-next-line incorrect-equality
            lastUpdateTimestamp_ == block.timestamp || distribution.emissionPerSecond == 0 || totalSupply == 0
                || block.timestamp < distribution.startTime || lastUpdateTimestamp_ >= distribution.endTime
        ) {
            return currentIndex;
        }

        uint256 currentTimestamp = block.timestamp > distribution.endTime ? distribution.endTime : block.timestamp;

        uint256 timeDelta = currentTimestamp - lastUpdateTimestamp_;

        uint256 newIndex = (distribution.emissionPerSecond * timeDelta * PRECISION_FACTOR) / totalSupply;

        return newIndex + currentIndex;
    }

    /// @dev Iterates and updates each distribution's state for a given operator.
    /// @param totalStaked Total amount staked, affecting distribution indices.
    function _updateAllDistribution(uint256 totalStaked) internal {
        for (uint16 distributionId = 1; distributionId <= totalDistributions; ++distributionId) {
            _updateDistribution(distributionId, totalStaked);
        }
    }

    /// @dev Updates the state of one distribution, mainly rewards index and timestamp
    /// @param totalStaked Current total of staked assets for this distribution
    /// @return The new distribution index
    function _updateDistribution(uint16 distributionId, uint256 totalStaked) internal returns (uint256) {
        DistributionData storage distribution = distributions[distributionId];

        uint256 oldIndex = distribution.index;
        uint40 lastUpdateTimestamp = _lastUpdateTimestamp(distribution);

        // Note that it's inclusive
        if (distribution.endTime <= lastUpdateTimestamp || block.timestamp <= lastUpdateTimestamp) {
            return oldIndex;
        }

        uint256 newIndex = _getDistributionIndex(distributionId, oldIndex, lastUpdateTimestamp, totalStaked);

        if (newIndex != oldIndex) {
            distribution.index = newIndex;
            emit DistributionIndexUpdated(distributionId, newIndex);
        }

        distribution.updateTimestamp = uint40(block.timestamp);

        return newIndex;
    }

    /// @dev Updates the state of an user in a distribution
    /// @param user The user's address
    /// @param operator The id of the reference asset of the distribution
    /// @param stakedByUser Amount of tokens staked by the user in the distribution at the moment
    /// @param totalStaked Total tokens staked in the distribution
    /// @return The accrued rewards for the user until the moment
    function _updateUser(
        uint16 distributionId,
        address user,
        address operator,
        uint256 stakedByUser,
        uint256 totalStaked
    ) internal returns (uint256) {
        DistributionData storage distribution = distributions[distributionId];

        uint256 newIndex = _updateDistribution(distributionId, totalStaked);
        uint256 userIndex = distribution.userIndices[operator][user];

        uint256 accruedRewards = 0;

        if (userIndex != newIndex) {
            if (stakedByUser != 0) {
                accruedRewards = _getAccruedRewards(stakedByUser, newIndex, userIndex);
            }

            distribution.userIndices[operator][user] = newIndex;
            emit UserIndexUpdated(distributionId, user, operator, newIndex);
        }

        if (accruedRewards > 0) {
            accruedRewards = _collectFee(distributionId, operator, accruedRewards);
        }

        return accruedRewards;
    }

    function _lastUpdateTimestamp(DistributionData storage distribution) internal view returns (uint40) {
        return distribution.updateTimestamp < distribution.startTime
            ? distribution.startTime
            : distribution.updateTimestamp;
    }

    /// @dev Internal function for the calculation of user's rewards on a distribution
    /// @param stakedByUser Amount staked by the user on a distribution
    /// @param distributionIndex_ Current index of the distribution
    /// @param userIndex Index stored for the user, representation his staking moment
    /// @return The rewards
    function _getAccruedRewards(uint256 stakedByUser, uint256 distributionIndex_, uint256 userIndex)
        internal
        pure
        returns (uint256)
    {
        uint256 indexDelta = (distributionIndex_ - userIndex);
        return (stakedByUser * indexDelta) / PRECISION_FACTOR;
    }

    /// @dev Collects fees from the rewards and distributes them to the protocol and the operator.
    /// The fees are determined based on the `FEE_BPS` constant.
    /// @param distributionId Distribution ID
    /// @param operator The identifier of the asset or operation for which the fees are being collected.
    /// @param rewards The total amount of rewards from which fees will be deducted.
    /// @return The remaining rewards after deducting the protocol and operator fees.
    function _collectFee(uint16 distributionId, address operator, uint256 rewards) internal virtual returns (uint256);
}

// SPDX-License-Identifier: agpl-3.0
// Copyright (c) 2024, Alt Research Ltd.
pragma solidity =0.8.23;

import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

import {
    NotOperator,
    AlreadyRegistered,
    AlreadyAuthenticated,
    AlreadyRemoved,
    InvalidExpiryDuration,
    InvalidStartIndex,
    OperatorMismatch,
    NodeKeyNotAuthenticated,
    AlreadyVoted,
    AlreadyActiveAlert
} from "./Errors.sol";
import {IAlertSystem} from "./interfaces/IAlertSystem.sol";
import {OperatorRegistry} from "./OperatorRegistry.sol";

// solhint-disable not-rely-on-time, var-name-mixedcase
abstract contract AlertSystem is IAlertSystem, OperatorRegistry {
    using EnumerableSet for EnumerableSet.Bytes32Set;

    uint40 public constant MAX_EXPIRY = type(uint40).max;

    // A struct for storing alert data
    struct AlertData {
        uint128 voteCount; // The total number of votes for this alert
        uint40 expiry; // The timestamp when the alert was created
        uint16 resetCount;
        bool isActive;
        // reset count => operator => voted
        mapping(uint16 => mapping(address => bool)) voted; // Tracks whether an address has voted on this alert
    }

    EnumerableSet.Bytes32Set private _messageHashes;

    uint16 public expiryDuration;

    // Maps operator addresses to unique node keys for secure one-to-one authentication.
    mapping(address => address) public nodeKeys;

    // Maps node keys back to operators, ensuring each node is tied to a single operator.
    mapping(address => address) public operators;

    /// @notice hash of message to alert data
    mapping(bytes32 => AlertData) public alerts;

    /// @notice operator => voted alert message hashes
    mapping(address => bytes32[]) public votedAlerts;

    uint256[44] private __gap;

    modifier onlyAuthenticatedNodeKey() {
        if (!isAuthenticated(_msgSender())) {
            revert NodeKeyNotAuthenticated();
        }
        _;
    }

    // solhint-disable-next-line func-name-mixedcase
    function __AlertSystem_init(uint16 initialExpiryDuration_) internal onlyInitializing {
        expiryDuration = initialExpiryDuration_;
    }

    ///////////////////////
    // External Functions
    ///////////////////////

    /// @inheritdoc IAlertSystem
    function removeAlert(bytes32 messageHash) external onlyOwner {
        // slither-disable-next-line mapping-deletion
        delete alerts[messageHash];
        _messageHashes.remove(messageHash);
        emit AlertRemoved(messageHash, _msgSender());
    }

    /// @inheritdoc IAlertSystem
    function setExpiryDuration(uint16 duration) external onlyOwner {
        expiryDuration = duration;
        emit ExpiryDurationUpdated(duration, _msgSender());
    }

    /// @inheritdoc IAlertSystem
    function registerNodeKey(address operator) external whenNotPaused {
        if (!isOperator(operator)) {
            revert NotOperator();
        }

        address nodeKey = _msgSender();

        if (nodeKeys[operator] != address(0)) {
            revert AlreadyRegistered();
        }

        operators[nodeKey] = operator;
        emit NodeKeyRegistered(nodeKey, operator);
    }

    /// @inheritdoc IAlertSystem
    function authenticateNodeKey(address nodeKey) external onlyOperator whenNotPaused {
        address operator = _msgSender();

        if (operators[nodeKey] != operator) {
            revert OperatorMismatch();
        }

        if (nodeKeys[operator] == nodeKey) {
            revert AlreadyAuthenticated();
        }

        nodeKeys[operator] = nodeKey;
        emit NodeKeyAuthenticated(nodeKey, operator);
    }

    function removeNodeKey() external onlyOperator whenNotPaused {
        address operator = _msgSender();
        address oldNodeKey = nodeKeys[operator];

        if (oldNodeKey == address(0)) {
            revert AlreadyRemoved();
        }

        // Clear both
        delete nodeKeys[operator];
        delete operators[oldNodeKey];

        emit NodeKeyRemoved(oldNodeKey, operator);
    }

    /// @inheritdoc IAlertSystem
    function voteForBlockAlert(uint256 blockNumber) external whenNotPaused onlyAuthenticatedNodeKey {
        // max expiry
        uint40 expiry = type(uint40).max;
        address nodeKey = _msgSender();
        _vote(keccak256(abi.encode(blockNumber)), expiry, nodeKey);
    }

    /// @inheritdoc IAlertSystem
    function voteForMessageAlert(string memory message) external whenNotPaused onlyAuthenticatedNodeKey {
        uint40 expiry = uint40(block.timestamp) + uint40(expiryDuration);
        address nodeKey = _msgSender();
        _vote(keccak256(abi.encode(message)), expiry, nodeKey);
    }
    /// @inheritdoc IAlertSystem

    function getVotedAlerts(address operator) external view returns (bytes32[] memory) {
        return votedAlerts[operator];
    }

    /// @inheritdoc IAlertSystem
    function isAuthenticated(address nodeKey) public view returns (bool) {
        return nodeKeys[operators[nodeKey]] == nodeKey;
    }

    /// @inheritdoc IAlertSystem
    function isActiveAlert(uint128 voteCount) public view virtual returns (bool);

    /// @inheritdoc IAlertSystem
    function totalAlerts() public view returns (uint256) {
        return _messageHashes.length();
    }

    /// @inheritdoc IAlertSystem
    function contains(bytes32 messageHash) public view returns (bool) {
        return _messageHashes.contains(messageHash);
    }

    /// @inheritdoc IAlertSystem
    function queryMessageHashes(uint256 start, uint256 querySize) external view returns (bytes32[] memory) {
        uint256 length = totalAlerts();

        if (start >= length) {
            revert InvalidStartIndex();
        }

        uint256 end = start + querySize;

        if (end > length) {
            end = length;
        }

        bytes32[] memory output = new bytes32[](end - start);

        for (uint256 i = start; i < end; ++i) {
            output[i - start] = _messageHashes.at(i);
        }

        return output;
    }

    ///////////////////////
    // Internal Functions
    ///////////////////////

    function _vote(bytes32 messageHash, uint40 expiry, address nodeKey) internal virtual {
        AlertData storage currentAlert = alerts[messageHash];

        if (currentAlert.isActive) {
            revert AlreadyActiveAlert();
        }

        if (currentAlert.expiry != 0 && currentAlert.expiry < block.timestamp) {
            currentAlert.resetCount++;
            currentAlert.voteCount = 0;
        }

        address operator = operators[nodeKey];
        uint16 resetCount = currentAlert.resetCount;
        // Ensure voting can be done only once per operator per alert
        if (currentAlert.voted[resetCount][operator]) {
            revert AlreadyVoted();
        }

        // Mark the sender as having voted and increment the vote count
        currentAlert.voted[resetCount][operator] = true;
        currentAlert.voteCount++;
        currentAlert.expiry = expiry;

        bool isActive = isActiveAlert(currentAlert.voteCount);
        currentAlert.isActive = isActive;

        if (!contains(messageHash)) {
            _messageHashes.add(messageHash);
        }

        emit AlertVoted(messageHash, operator, currentAlert.voteCount, isActive);

        bytes32[] memory currentVotedAlerts = votedAlerts[operator];

        bool voted;
        for (uint256 i; i < currentVotedAlerts.length; ++i) {
            if (messageHash == currentVotedAlerts[i]) {
                voted = true;
                break;
            }
        }

        if (!voted) {
            votedAlerts[operator].push(messageHash);
        }
    }
}

// SPDX-License-Identifier: agpl-3.0
// Copyright (c) 2024, Alt Research Ltd.
pragma solidity =0.8.23;

import {Ownable2StepUpgradeable} from "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
import {PausableUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {IOperatorRegistry} from "./interfaces/IOperatorRegistry.sol";
import {FrozenOperator, NotOperator, InvalidStartIndex} from "./Errors.sol";

// solhint-disable not-rely-on-time, var-name-mixedcase
abstract contract OperatorRegistry is PausableUpgradeable, Ownable2StepUpgradeable, IOperatorRegistry {
    using EnumerableSet for EnumerableSet.AddressSet;

    /// @dev Set of operator address for enumeration
    EnumerableSet.AddressSet private _operators;
    mapping(address => bool) private frozenOperators;

    uint256[48] private __gap;

    modifier onlyOperator() {
        if (!isOperator(_msgSender())) {
            revert NotOperator();
        }
        _;
    }

    modifier onlyOperatorNotFrozen(address operator) {
        // Revert if the operator is frozen
        if (isFrozenOperator(operator)) {
            revert FrozenOperator();
        }
        _;
    }

    ///////////////////////
    // External Functions
    ///////////////////////

    /// @inheritdoc IOperatorRegistry
    function pause() external onlyOwner {
        _pause();
    }

    /// @inheritdoc IOperatorRegistry
    function unpause() external onlyOwner {
        _unpause();
    }

    /// @inheritdoc IOperatorRegistry
    function totalOperators() public view returns (uint256) {
        return _operators.length();
    }

    /// @inheritdoc IOperatorRegistry
    function isOperator(address operator) public view returns (bool) {
        return _operators.contains(operator);
    }

    /// @inheritdoc IOperatorRegistry
    function queryOperators(uint256 start, uint256 querySize) public view returns (address[] memory) {
        uint256 length = totalOperators();

        if (start >= length) {
            revert InvalidStartIndex();
        }

        uint256 end = start + querySize;

        if (end > length) {
            end = length;
        }

        address[] memory output = new address[](end - start);

        for (uint256 i = start; i < end; ++i) {
            output[i - start] = _operators.at(i);
        }

        return output;
    }

    function isFrozenOperator(address operator) public view returns (bool) {
        return frozenOperators[operator];
    }

    ///////////////////////
    // Internal Functions
    ///////////////////////

    function _addOperator(address operator) internal {
        _operators.add(operator);
        emit OperatorAdded(operator, _msgSender());
    }

    function _freezeOperator(address operator) internal {
        frozenOperators[operator] = true;
        emit Frozen(operator, _msgSender());
    }
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity =0.8.23;

error ArrayLengthMismatch();
error FrozenOperator();
error InsufficientAmount();
error ZeroVotingStake();
error ZeroAddress();
error NotOperator();
error NodeKeyNotAuthenticated();
error LessThanMinStakeToVote();
error AlreadyVoted();
error AlreadyActiveAlert();
error InvalidExpiryDuration();
error OperatorMismatch();
error InvalidStartIndex();
error InvalidStakingStartTime();
error InvalidDistributionStartTime();
error InvalidDistributionEndTime();
error AlreadyRegistered();
error AlreadyAuthenticated();
error AlreadyRemoved();
error InvalidBPS();
error ZeroExchangeRate();
error ZeroAmount();
error InvalidCooldownAmount();
error InsufficientCooldown();
error ZeroUnstakeable();
error InvalidDestination();
error GreaterThanMaxCooldownSec();
error StakingNotStartedYet();
error NotSupported();

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

pragma solidity ^0.8.20;

import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import {IERC1155MetadataURI} from "@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol";
import {ContextUpgradeable} from "../../utils/ContextUpgradeable.sol";
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {ERC165Upgradeable} from "../../utils/introspection/ERC165Upgradeable.sol";
import {Arrays} from "@openzeppelin/contracts/utils/Arrays.sol";
import {IERC1155Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 */
abstract contract ERC1155Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC1155, IERC1155MetadataURI, IERC1155Errors {
    using Arrays for uint256[];
    using Arrays for address[];

    /// @custom:storage-location erc7201:openzeppelin.storage.ERC1155
    struct ERC1155Storage {
        mapping(uint256 id => mapping(address account => uint256)) _balances;

        mapping(address account => mapping(address operator => bool)) _operatorApprovals;

        // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
        string _uri;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC1155")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant ERC1155StorageLocation = 0x88be536d5240c274a3b1d3a1be54482fd9caa294f08c62a7cde569f49a3c4500;

    function _getERC1155Storage() private pure returns (ERC1155Storage storage $) {
        assembly {
            $.slot := ERC1155StorageLocation
        }
    }

    /**
     * @dev See {_setURI}.
     */
    function __ERC1155_init(string memory uri_) internal onlyInitializing {
        __ERC1155_init_unchained(uri_);
    }

    function __ERC1155_init_unchained(string memory uri_) internal onlyInitializing {
        _setURI(uri_);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165) returns (bool) {
        return
            interfaceId == type(IERC1155).interfaceId ||
            interfaceId == type(IERC1155MetadataURI).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC1155MetadataURI-uri}.
     *
     * This implementation returns the same URI for *all* token types. It relies
     * on the token type ID substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * Clients calling this function must replace the `\{id\}` substring with the
     * actual token type ID.
     */
    function uri(uint256 /* id */) public view virtual returns (string memory) {
        ERC1155Storage storage $ = _getERC1155Storage();
        return $._uri;
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     */
    function balanceOf(address account, uint256 id) public view virtual returns (uint256) {
        ERC1155Storage storage $ = _getERC1155Storage();
        return $._balances[id][account];
    }

    /**
     * @dev See {IERC1155-balanceOfBatch}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] memory accounts,
        uint256[] memory ids
    ) public view virtual returns (uint256[] memory) {
        if (accounts.length != ids.length) {
            revert ERC1155InvalidArrayLength(ids.length, accounts.length);
        }

        uint256[] memory batchBalances = new uint256[](accounts.length);

        for (uint256 i = 0; i < accounts.length; ++i) {
            batchBalances[i] = balanceOf(accounts.unsafeMemoryAccess(i), ids.unsafeMemoryAccess(i));
        }

        return batchBalances;
    }

    /**
     * @dev See {IERC1155-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC1155-isApprovedForAll}.
     */
    function isApprovedForAll(address account, address operator) public view virtual returns (bool) {
        ERC1155Storage storage $ = _getERC1155Storage();
        return $._operatorApprovals[account][operator];
    }

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) public virtual {
        address sender = _msgSender();
        if (from != sender && !isApprovedForAll(from, sender)) {
            revert ERC1155MissingApprovalForAll(sender, from);
        }
        _safeTransferFrom(from, to, id, value, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) public virtual {
        address sender = _msgSender();
        if (from != sender && !isApprovedForAll(from, sender)) {
            revert ERC1155MissingApprovalForAll(sender, from);
        }
        _safeBatchTransferFrom(from, to, ids, values, data);
    }

    /**
     * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`. Will mint (or burn) if `from`
     * (or `to`) is the zero address.
     *
     * Emits a {TransferSingle} event if the arrays contain one element, and {TransferBatch} otherwise.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement either {IERC1155Receiver-onERC1155Received}
     *   or {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
     * - `ids` and `values` must have the same length.
     *
     * NOTE: The ERC-1155 acceptance check is not performed in this function. See {_updateWithAcceptanceCheck} instead.
     */
    function _update(address from, address to, uint256[] memory ids, uint256[] memory values) internal virtual {
        ERC1155Storage storage $ = _getERC1155Storage();
        if (ids.length != values.length) {
            revert ERC1155InvalidArrayLength(ids.length, values.length);
        }

        address operator = _msgSender();

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids.unsafeMemoryAccess(i);
            uint256 value = values.unsafeMemoryAccess(i);

            if (from != address(0)) {
                uint256 fromBalance = $._balances[id][from];
                if (fromBalance < value) {
                    revert ERC1155InsufficientBalance(from, fromBalance, value, id);
                }
                unchecked {
                    // Overflow not possible: value <= fromBalance
                    $._balances[id][from] = fromBalance - value;
                }
            }

            if (to != address(0)) {
                $._balances[id][to] += value;
            }
        }

        if (ids.length == 1) {
            uint256 id = ids.unsafeMemoryAccess(0);
            uint256 value = values.unsafeMemoryAccess(0);
            emit TransferSingle(operator, from, to, id, value);
        } else {
            emit TransferBatch(operator, from, to, ids, values);
        }
    }

    /**
     * @dev Version of {_update} that performs the token acceptance check by calling
     * {IERC1155Receiver-onERC1155Received} or {IERC1155Receiver-onERC1155BatchReceived} on the receiver address if it
     * contains code (eg. is a smart contract at the moment of execution).
     *
     * IMPORTANT: Overriding this function is discouraged because it poses a reentrancy risk from the receiver. So any
     * update to the contract state after this function would break the check-effect-interaction pattern. Consider
     * overriding {_update} instead.
     */
    function _updateWithAcceptanceCheck(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) internal virtual {
        _update(from, to, ids, values);
        if (to != address(0)) {
            address operator = _msgSender();
            if (ids.length == 1) {
                uint256 id = ids.unsafeMemoryAccess(0);
                uint256 value = values.unsafeMemoryAccess(0);
                _doSafeTransferAcceptanceCheck(operator, from, to, id, value, data);
            } else {
                _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, values, data);
            }
        }
    }

    /**
     * @dev Transfers a `value` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `from` must have a balance of tokens of type `id` of at least `value` amount.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value);
        _updateWithAcceptanceCheck(from, to, ids, values, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     * - `ids` and `values` must have the same length.
     */
    function _safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        _updateWithAcceptanceCheck(from, to, ids, values, data);
    }

    /**
     * @dev Sets a new URI for all token types, by relying on the token type ID
     * substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * By this mechanism, any occurrence of the `\{id\}` substring in either the
     * URI or any of the values in the JSON file at said URI will be replaced by
     * clients with the token type ID.
     *
     * For example, the `https://token-cdn-domain/\{id\}.json` URI would be
     * interpreted by clients as
     * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
     * for token type ID 0x4cce0.
     *
     * See {uri}.
     *
     * Because these URIs cannot be meaningfully represented by the {URI} event,
     * this function emits no events.
     */
    function _setURI(string memory newuri) internal virtual {
        ERC1155Storage storage $ = _getERC1155Storage();
        $._uri = newuri;
    }

    /**
     * @dev Creates a `value` amount of tokens of type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(address to, uint256 id, uint256 value, bytes memory data) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value);
        _updateWithAcceptanceCheck(address(0), to, ids, values, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `values` must have the same length.
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(address to, uint256[] memory ids, uint256[] memory values, bytes memory data) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        _updateWithAcceptanceCheck(address(0), to, ids, values, data);
    }

    /**
     * @dev Destroys a `value` amount of tokens of type `id` from `from`
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `value` amount of tokens of type `id`.
     */
    function _burn(address from, uint256 id, uint256 value) internal {
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value);
        _updateWithAcceptanceCheck(from, address(0), ids, values, "");
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `value` amount of tokens of type `id`.
     * - `ids` and `values` must have the same length.
     */
    function _burnBatch(address from, uint256[] memory ids, uint256[] memory values) internal {
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        _updateWithAcceptanceCheck(from, address(0), ids, values, "");
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the zero address.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        ERC1155Storage storage $ = _getERC1155Storage();
        if (operator == address(0)) {
            revert ERC1155InvalidOperator(address(0));
        }
        $._operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Performs an acceptance check by calling {IERC1155-onERC1155Received} on the `to` address
     * if it contains code at the moment of execution.
     */
    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 value,
        bytes memory data
    ) private {
        if (to.code.length > 0) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, value, data) returns (bytes4 response) {
                if (response != IERC1155Receiver.onERC1155Received.selector) {
                    // Tokens rejected
                    revert ERC1155InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-ERC1155Receiver implementer
                    revert ERC1155InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }

    /**
     * @dev Performs a batch acceptance check by calling {IERC1155-onERC1155BatchReceived} on the `to` address
     * if it contains code at the moment of execution.
     */
    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) private {
        if (to.code.length > 0) {
            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, values, data) returns (
                bytes4 response
            ) {
                if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
                    // Tokens rejected
                    revert ERC1155InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-ERC1155Receiver implementer
                    revert ERC1155InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }

    /**
     * @dev Creates an array in memory with only one value for each of the elements provided.
     */
    function _asSingletonArrays(
        uint256 element1,
        uint256 element2
    ) private pure returns (uint256[] memory array1, uint256[] memory array2) {
        /// @solidity memory-safe-assembly
        assembly {
            // Load the free memory pointer
            array1 := mload(0x40)
            // Set array length to 1
            mstore(array1, 1)
            // Store the single element at the next word after the length (where content starts)
            mstore(add(array1, 0x20), element1)

            // Repeat for next array locating it right after the first array
            array2 := add(array1, 0x40)
            mstore(array2, 1)
            mstore(add(array2, 0x20), element2)

            // Update the free memory pointer by pointing after the second array
            mstore(0x40, add(array2, 0x40))
        }
    }
}

// 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: agpl-3.0
pragma solidity =0.8.23;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

/// @title Interface for RewardDistribution
/// @notice This interface outlines the public and external functions for managing distribution of rewards in a staking contract.
interface IRewardDistribution {
    ////////////////
    // Events
    ////////////////

    /// @notice Indicates a distribution index was updated
    /// @dev This event should be emitted when a distribution's index is updated
    /// @param distributionID The ID of the distribution being updated
    /// @param index The new index after the update
    event DistributionIndexUpdated(uint256 indexed distributionID, uint256 index);

    /// @notice Indicates a user's index in a distribution was updated
    /// @dev This event should be emitted when a user's index within a distribution is updated
    /// @param distributionID The ID of the distribution being referenced
    /// @param user The address of the user for whom the index was updated
    /// @param operator The address of the operator associated with the distribution
    /// @param index The new user-specific index after the update
    event UserIndexUpdated(
        uint256 indexed distributionID, address indexed user, address indexed operator, uint256 index
    );

    ////////////////
    // Functions
    ////////////////

    /// @notice Creates a new distribution
    /// @param emissionPerSecond The amount of reward token emitted per second
    /// @param startTime The start time of the distribution in UNIX timestamp
    /// @param endTime The end time of the distribution in UNIX timestamp
    /// @param rewardToken The ERC20 token to be used as the reward. The rewardToken must be strictly ERC-20 compliant.
    /// @param rewardVault The address from which the reward tokens will be distributed
    /// @dev Emits a DistributionIndexUpdated event on success
    function createDistribution(
        uint128 emissionPerSecond,
        uint40 startTime,
        uint40 endTime,
        IERC20 rewardToken,
        address rewardVault
    ) external;

    /// @notice Sets the end time for an existing distribution
    /// @param distributionId The ID of the distribution to be modified
    /// @param endTime The new end time for the distribution
    /// @dev This action can only be performed by the owner of the contract
    function setDistributionEnd(uint16 distributionId, uint40 endTime) external;

    /// @notice Gets the current index of a distribution for an operator
    /// @param distributionId The ID of the distribution
    /// @return The current index of the distribution
    function distributionIndex(uint16 distributionId) external view returns (uint256);

    /// @notice Gets the user-specific index within a distribution for an operator-staker pair
    /// @param distributionId The ID of the distribution
    /// @param operator The address of the operator
    /// @param staker The address of the staker
    /// @return The current user-specific index within the distribution
    function distributionUserIndex(uint16 distributionId, address operator, address staker)
        external
        view
        returns (uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position is the index of the value in the `values` array plus 1.
        // Position 0 is used to mean a value is not in the set.
        mapping(bytes32 value => uint256) _positions;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._positions[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We cache the value's position to prevent multiple reads from the same storage slot
        uint256 position = set._positions[value];

        if (position != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 valueIndex = position - 1;
            uint256 lastIndex = set._values.length - 1;

            if (valueIndex != lastIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the lastValue to the index where the value to delete is
                set._values[valueIndex] = lastValue;
                // Update the tracked position of the lastValue (that was just moved)
                set._positions[lastValue] = position;
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the tracked position for the deleted slot
            delete set._positions[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._positions[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: agpl-3.0
// Copyright (c) 2024, Alt Research Ltd.
pragma solidity =0.8.23;

/// @title Interface for AlertSystem
/// @notice This interface outlines the functionalities for managing alerts and votes in a contract system.
interface IAlertSystem {
    ///////////////////////
    // Events
    ///////////////////////

    /// @notice Emitted when the expiry duration is updated
    /// @param duration The new expiry duration
    /// @param admin The admin who updated the duration
    event ExpiryDurationUpdated(uint16 duration, address admin);

    /// @notice Emitted when an alert is removed
    /// @param messageHash The hash of the message corresponding to the removed alert
    /// @param admin The admin who removed the alert
    event AlertRemoved(bytes32 messageHash, address admin);

    /// @notice Emitted when a vote is cast for an alert
    /// @param messageHash The hash of the message corresponding to the alert voted on
    /// @param operator The operator address
    /// @param voteCount The current vote count after the vote
    /// @param isActive Whether the alert is active after the vote
    event AlertVoted(bytes32 messageHash, address operator, uint128 voteCount, bool isActive);

    /// @notice Emitted when a node key is registered for an operator
    /// @param nodeKey The node key that is registered
    /// @param operator The operator associated with the node key
    event NodeKeyRegistered(address nodeKey, address operator);

    /// @notice Emitted when a node key is authenticated
    /// @param nodeKey The node key authenticated
    /// @param operator The operator associated with the node key
    event NodeKeyAuthenticated(address nodeKey, address operator);

    /// @notice Emitted when a node key is removed
    /// @param nodeKey The node key removed
    /// @param operator The operator associated with the node key
    event NodeKeyRemoved(address nodeKey, address operator);

    ///////////////////////
    // External Functions
    ///////////////////////

    /// @notice Removes an alert from the system
    /// @param messageHash The hash of the message corresponding to the alert to remove
    function removeAlert(bytes32 messageHash) external;

    /// @notice Sets the expiry duration for alerts
    /// @param duration The new expiry duration
    function setExpiryDuration(uint16 duration) external;

    /// @notice Registers a node key for an operator
    /// @param operator The operator associated with the node key
    function registerNodeKey(address operator) external;

    /// @notice Authenticates a previously set node key, allowing it to participate in alert votes
    /// @param nodeKey The node key to authenticate
    function authenticateNodeKey(address nodeKey) external;

    /// @notice Removes the currently authenticated node key
    function removeNodeKey() external;

    /// @notice Votes for a block alert using the caller's node key
    /// @param blockNumber The block number to associate with the alert
    function voteForBlockAlert(uint256 blockNumber) external;

    /// @notice Votes for a message alert using the caller's node key
    /// @param message The message to associate with the alert
    function voteForMessageAlert(string calldata message) external;

    ///////////////////////
    // View Functions
    ///////////////////////

    /// @notice Checks if the given node key is authenticated
    /// @param nodeKey The address of the node key to verify authentication.
    /// @return bool Returns true if the node key is authenticated, false otherwise.
    function isAuthenticated(address nodeKey) external view returns (bool);

    /// @notice Gets a list of alerts voted on by a nodeKey
    /// @param nodeKey The node key to query for voted alerts
    /// @return An array of message hashes corresponding to alerts voted on by the node key
    function getVotedAlerts(address nodeKey) external view returns (bytes32[] memory);

    /// @notice Checks whether an alert with a given vote count is considered active
    /// @param voteCount The vote count of the alert
    /// @return True if the alert is active, false otherwise
    function isActiveAlert(uint128 voteCount) external view returns (bool);

    /// @notice Returns the total number of alerts in the system
    /// @return The total number of alerts
    function totalAlerts() external view returns (uint256);

    /// @notice Checks if a specific alert exists in the system
    /// @param messageHash The hash of the message corresponding to the alert
    /// @return True if the alert exists, false otherwise
    function contains(bytes32 messageHash) external view returns (bool);

    /// @notice Queries a range of message hashes from the system
    /// @param start The start index for querying
    /// @param querySize The number of message hashes to query
    /// @return An array of message hashes
    function queryMessageHashes(uint256 start, uint256 querySize) external view returns (bytes32[] memory);
}

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

pragma solidity ^0.8.20;

import {OwnableUpgradeable} from "./OwnableUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module which provides access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is specified at deployment time in the constructor for `Ownable`. This
 * can later be changed with {transferOwnership} and {acceptOwnership}.
 *
 * This module is used through inheritance. It will make available all functions
 * from parent (Ownable).
 */
abstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {
    /// @custom:storage-location erc7201:openzeppelin.storage.Ownable2Step
    struct Ownable2StepStorage {
        address _pendingOwner;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Ownable2Step")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant Ownable2StepStorageLocation = 0x237e158222e3e6968b72b9db0d8043aacf074ad9f650f0d1606b4d82ee432c00;

    function _getOwnable2StepStorage() private pure returns (Ownable2StepStorage storage $) {
        assembly {
            $.slot := Ownable2StepStorageLocation
        }
    }

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

    function __Ownable2Step_init() internal onlyInitializing {
    }

    function __Ownable2Step_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev Returns the address of the pending owner.
     */
    function pendingOwner() public view virtual returns (address) {
        Ownable2StepStorage storage $ = _getOwnable2StepStorage();
        return $._pendingOwner;
    }

    /**
     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual override onlyOwner {
        Ownable2StepStorage storage $ = _getOwnable2StepStorage();
        $._pendingOwner = newOwner;
        emit OwnershipTransferStarted(owner(), newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual override {
        Ownable2StepStorage storage $ = _getOwnable2StepStorage();
        delete $._pendingOwner;
        super._transferOwnership(newOwner);
    }

    /**
     * @dev The new owner accepts the ownership transfer.
     */
    function acceptOwnership() public virtual {
        address sender = _msgSender();
        if (pendingOwner() != sender) {
            revert OwnableUnauthorizedAccount(sender);
        }
        _transferOwnership(sender);
    }
}

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

pragma solidity ^0.8.20;

import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
    /// @custom:storage-location erc7201:openzeppelin.storage.Pausable
    struct PausableStorage {
        bool _paused;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Pausable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant PausableStorageLocation = 0xcd5ed15c6e187e77e9aee88184c21f4f2182ab5827cb3b7e07fbedcd63f03300;

    function _getPausableStorage() private pure returns (PausableStorage storage $) {
        assembly {
            $.slot := PausableStorageLocation
        }
    }

    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

    /**
     * @dev Initializes the contract in unpaused state.
     */
    function __Pausable_init() internal onlyInitializing {
        __Pausable_init_unchained();
    }

    function __Pausable_init_unchained() internal onlyInitializing {
        PausableStorage storage $ = _getPausableStorage();
        $._paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        PausableStorage storage $ = _getPausableStorage();
        return $._paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        PausableStorage storage $ = _getPausableStorage();
        $._paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        PausableStorage storage $ = _getPausableStorage();
        $._paused = false;
        emit Unpaused(_msgSender());
    }
}

// SPDX-License-Identifier: agpl-3.0
// Copyright (c) 2024, Alt Research Ltd.
pragma solidity =0.8.23;

/// @title Interface for OperatorRegistry
/// @notice This interface outlines the functionalities for managing and querying operators in a contract.
interface IOperatorRegistry {
    ////////////////
    // Events
    ////////////////

    /// @notice Emitted when a new operator is added
    /// @param operator The address of the operator added
    event OperatorAdded(address operator, address owner);

    /// @notice Emitted when an operator is frozen
    /// @param operator The address of the operator frozen
    /// @param owner The address of the owner who froze the operator
    event Frozen(address operator, address owner);

    ////////////////
    // Functions
    ////////////////

    /// @notice Triggers the stopped state.
    function pause() external;

    /// @notice Returns to normal state.
    function unpause() external;

    /// @notice Returns the total number of operators
    /// @return The total number of operators
    function totalOperators() external view returns (uint256);

    /// @notice Checks if the given address is an operator
    /// @param operator The address to check
    /// @return True if the address is an operator, false otherwise
    function isOperator(address operator) external view returns (bool);

    /// @notice Returns an array of operator addresses starting from the specified index up to the query size
    /// @param start The start index to retrieve operator addresses
    /// @param querySize The number of operator addresses to retrieve
    /// @return An array of operator addresses
    function queryOperators(uint256 start, uint256 querySize) external view returns (address[] memory);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` amount of tokens of type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the value of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] calldata accounts,
        uint256[] calldata ids
    ) external view returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`.
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155Received} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `value` amount.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155BatchReceived} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits either a {TransferSingle} or a {TransferBatch} event, depending on the length of the array arguments.
     *
     * Requirements:
     *
     * - `ids` and `values` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external;
}

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

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

/**
 * @dev Interface that must be implemented by smart contracts in order to receive
 * ERC-1155 token transfers.
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.20;

import {IERC1155} from "../IERC1155.sol";

/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
 */
interface IERC1155MetadataURI is IERC1155 {
    /**
     * @dev Returns the URI for token type `id`.
     *
     * If the `\{id\}` substring is present in the URI, it must be replaced by
     * clients with the actual token type ID.
     */
    function uri(uint256 id) external view returns (string memory);
}

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

pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @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 ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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

pragma solidity ^0.8.20;

import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165Upgradeable is Initializable, IERC165 {
    function __ERC165_init() internal onlyInitializing {
    }

    function __ERC165_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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

pragma solidity ^0.8.20;

import {StorageSlot} from "./StorageSlot.sol";
import {Math} from "./math/Math.sol";

/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
    using StorageSlot for bytes32;

    /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        uint256 low = 0;
        uint256 high = array.length;

        if (high == 0) {
            return 0;
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds towards zero (it does integer division with truncation).
            if (unsafeAccess(array, mid).value > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && unsafeAccess(array, low - 1).value == element) {
            return low - 1;
        } else {
            return low;
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(address[] storage arr, uint256 pos) internal pure returns (StorageSlot.AddressSlot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getAddressSlot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(bytes32[] storage arr, uint256 pos) internal pure returns (StorageSlot.Bytes32Slot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getBytes32Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(uint256[] storage arr, uint256 pos) internal pure returns (StorageSlot.Uint256Slot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getUint256Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(uint256[] memory arr, uint256 pos) internal pure returns (uint256 res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(address[] memory arr, uint256 pos) internal pure returns (address res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

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

pragma solidity ^0.8.20;

import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.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 OwnableUpgradeable is Initializable, ContextUpgradeable {
    /// @custom:storage-location erc7201:openzeppelin.storage.Ownable
    struct OwnableStorage {
        address _owner;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Ownable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;

    function _getOwnableStorage() private pure returns (OwnableStorage storage $) {
        assembly {
            $.slot := OwnableStorageLocation
        }
    }

    /**
     * @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.
     */
    function __Ownable_init(address initialOwner) internal onlyInitializing {
        __Ownable_init_unchained(initialOwner);
    }

    function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {
        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) {
        OwnableStorage storage $ = _getOwnableStorage();
        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 {
        OwnableStorage storage $ = _getOwnableStorage();
        address oldOwner = $._owner;
        $._owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(newImplementation.code.length > 0);
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

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

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

{
  "remappings": [
    "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"altToken_","type":"address"},{"internalType":"uint40","name":"stakingStartTimestamp_","type":"uint40"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"AlreadyActiveAlert","type":"error"},{"inputs":[],"name":"AlreadyAuthenticated","type":"error"},{"inputs":[],"name":"AlreadyRegistered","type":"error"},{"inputs":[],"name":"AlreadyRemoved","type":"error"},{"inputs":[],"name":"AlreadyVoted","type":"error"},{"inputs":[],"name":"ArrayLengthMismatch","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC1155InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC1155InvalidApprover","type":"error"},{"inputs":[{"internalType":"uint256","name":"idsLength","type":"uint256"},{"internalType":"uint256","name":"valuesLength","type":"uint256"}],"name":"ERC1155InvalidArrayLength","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC1155InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC1155InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC1155InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC1155MissingApprovalForAll","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"FrozenOperator","type":"error"},{"inputs":[],"name":"GreaterThanMaxCooldownSec","type":"error"},{"inputs":[],"name":"InsufficientAmount","type":"error"},{"inputs":[],"name":"InsufficientCooldown","type":"error"},{"inputs":[],"name":"InvalidBPS","type":"error"},{"inputs":[],"name":"InvalidCooldownAmount","type":"error"},{"inputs":[],"name":"InvalidDestination","type":"error"},{"inputs":[],"name":"InvalidDistributionEndTime","type":"error"},{"inputs":[],"name":"InvalidDistributionStartTime","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"InvalidStakingStartTime","type":"error"},{"inputs":[],"name":"InvalidStartIndex","type":"error"},{"inputs":[],"name":"LessThanMinStakeToVote","type":"error"},{"inputs":[],"name":"NodeKeyNotAuthenticated","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[],"name":"NotOperator","type":"error"},{"inputs":[],"name":"OperatorMismatch","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"StakingNotStartedYet","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[],"name":"ZeroAmount","type":"error"},{"inputs":[],"name":"ZeroUnstakeable","type":"error"},{"inputs":[],"name":"ZeroVotingStake","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"messageHash","type":"bytes32"},{"indexed":false,"internalType":"address","name":"admin","type":"address"}],"name":"AlertRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"messageHash","type":"bytes32"},{"indexed":false,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint128","name":"voteCount","type":"uint128"},{"indexed":false,"internalType":"bool","name":"isActive","type":"bool"}],"name":"AlertVoted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"distributionId","type":"uint16"},{"indexed":false,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint256","name":"protocolFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"operatorFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"userRewards","type":"uint256"}],"name":"CollectFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"CooldownToUnstake","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint16","name":"feeBPS","type":"uint16"},{"indexed":false,"internalType":"uint40","name":"cooldownEndTimestamp","type":"uint40"}],"name":"CooldownToUpdateOperatorFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"feeBPS","type":"uint16"},{"indexed":false,"internalType":"uint40","name":"cooldownEndTimestamp","type":"uint40"}],"name":"CooldownToUpdateProtocolFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"distributionID","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"}],"name":"DistributionIndexUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"duration","type":"uint16"},{"indexed":false,"internalType":"address","name":"admin","type":"address"}],"name":"ExpiryDurationUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"address","name":"owner","type":"address"}],"name":"Frozen","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"nodeKey","type":"address"},{"indexed":false,"internalType":"address","name":"operator","type":"address"}],"name":"NodeKeyAuthenticated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"nodeKey","type":"address"},{"indexed":false,"internalType":"address","name":"operator","type":"address"}],"name":"NodeKeyRegistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"nodeKey","type":"address"},{"indexed":false,"internalType":"address","name":"operator","type":"address"}],"name":"NodeKeyRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"address","name":"owner","type":"address"}],"name":"OperatorAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"operator","type":"address"}],"name":"OperatorRegistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardsAccrued","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardsClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint40","name":"cooldownSeconds","type":"uint40"}],"name":"SetCooldownSecForOperatorFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint40","name":"cooldownSeconds","type":"uint40"}],"name":"SetCooldownSecForProtocolFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint40","name":"cooldownSeconds","type":"uint40"}],"name":"SetCooldownSecForUnstaking","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"minVotingStake","type":"uint256"}],"name":"SetMinVotingStake","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint16","name":"feeBPS","type":"uint16"}],"name":"SetOperatorFeeBPS","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"feeBPS","type":"uint16"}],"name":"SetProtocolFeeBPS","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"onBehalfOf","type":"address"},{"indexed":false,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"}],"name":"Stake","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"","type":"string"}],"name":"URIUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"}],"name":"Unstake","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"distributionID","type":"uint256"},{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"}],"name":"UserIndexUpdated","type":"event"},{"inputs":[],"name":"MAX_BPS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_COOLDOWN_SEC","outputs":[{"internalType":"uint40","name":"","type":"uint40"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_EXPIRY","outputs":[{"internalType":"uint40","name":"","type":"uint40"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_OPERATOR_FEE_BPS","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_PROTOCOL_FEE_BPS","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRECISION_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"activationThreshold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"addressToUint256","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"alerts","outputs":[{"internalType":"uint128","name":"voteCount","type":"uint128"},{"internalType":"uint40","name":"expiry","type":"uint40"},{"internalType":"uint16","name":"resetCount","type":"uint16"},{"internalType":"bool","name":"isActive","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"nodeKey","type":"address"}],"name":"authenticateNodeKey","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"distributionId","type":"uint16"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16[]","name":"ids_","type":"uint16[]"},{"internalType":"address[]","name":"recipients_","type":"address[]"},{"internalType":"address[]","name":"operators_","type":"address[]"},{"internalType":"uint256[]","name":"amounts_","type":"uint256[]"}],"name":"claimRewardsBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"messageHash","type":"bytes32"}],"name":"contains","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cooldownSeconds","outputs":[{"internalType":"uint40","name":"","type":"uint40"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"amountToAdd","type":"uint256"}],"name":"cooldownToUnstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"feeBPS_","type":"uint16"}],"name":"cooldownToUpdateOperatorFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"feeBPS_","type":"uint16"}],"name":"cooldownToUpdateProtocolFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"cooldowns","outputs":[{"internalType":"uint40","name":"timestamp","type":"uint40"},{"internalType":"uint216","name":"amount","type":"uint216"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint128","name":"emissionPerSecond_","type":"uint128"},{"internalType":"uint40","name":"startTime_","type":"uint40"},{"internalType":"uint40","name":"endTime_","type":"uint40"},{"internalType":"contract IERC20","name":"rewardToken_","type":"address"},{"internalType":"address","name":"rewardVault_","type":"address"}],"name":"createDistribution","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint16","name":"distributionId","type":"uint16"}],"name":"distributionIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"distributionId","type":"uint16"},{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"staker","type":"address"}],"name":"distributionUserIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"","type":"uint16"}],"name":"distributions","outputs":[{"internalType":"uint128","name":"emissionPerSecond","type":"uint128"},{"internalType":"contract IERC20","name":"rewardToken","type":"address"},{"internalType":"address","name":"rewardVault","type":"address"},{"internalType":"uint40","name":"startTime","type":"uint40"},{"internalType":"uint40","name":"endTime","type":"uint40"},{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"uint40","name":"updateTimestamp","type":"uint40"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"expiryDuration","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"freezeOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"distributionId","type":"uint16"},{"internalType":"address","name":"staker","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"getAccruedRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"getVotedAlerts","outputs":[{"internalType":"bytes32[]","name":"","type":"bytes32[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"initialOwner_","type":"address"},{"internalType":"string","name":"uri_","type":"string"},{"internalType":"uint40","name":"cooldownSec_","type":"uint40"},{"internalType":"uint40","name":"cooldownSecForOperatorFeeUpdate_","type":"uint40"},{"internalType":"uint40","name":"cooldownSecForProtocolFeeUpdate_","type":"uint40"},{"internalType":"address","name":"protocolFeeVault_","type":"address"},{"internalType":"uint16","name":"initialProtocolFeeBPS_","type":"uint16"},{"internalType":"uint256","name":"initialMinVotingStake_","type":"uint256"},{"internalType":"uint16","name":"initialExpiryDuration","type":"uint16"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"voteCount","type":"uint128"}],"name":"isActiveAlert","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"isActiveOperator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"nodeKey","type":"address"}],"name":"isAuthenticated","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"isFrozenOperator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"isOperator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minVotingStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nodeKeys","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operatorConfig","outputs":[{"internalType":"uint40","name":"cooldownSeconds","type":"uint40"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"operatorFee","outputs":[{"internalType":"uint40","name":"cooldownEndTimestamp","type":"uint40"},{"internalType":"uint16","name":"bps","type":"uint16"},{"internalType":"uint16","name":"pendingBPS","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"operators","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"protocolConfig","outputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"uint40","name":"cooldownSeconds","type":"uint40"},{"components":[{"internalType":"uint40","name":"cooldownEndTimestamp","type":"uint40"},{"internalType":"uint16","name":"bps","type":"uint16"},{"internalType":"uint16","name":"pendingBPS","type":"uint16"}],"internalType":"struct StakedMultiToken.Fee","name":"fee","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"querySize","type":"uint256"}],"name":"queryMessageHashes","outputs":[{"internalType":"bytes32[]","name":"","type":"bytes32[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"querySize","type":"uint256"}],"name":"queryOperators","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"registerNodeKey","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint16","name":"feeBPS_","type":"uint16"}],"name":"registerOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"messageHash","type":"bytes32"}],"name":"removeAlert","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"removeNodeKey","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"distributionId","type":"uint16"},{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"staker","type":"address"}],"name":"rewardBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"distributionId","type":"uint16"},{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"staker","type":"address"}],"name":"rewardBalanceKey","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint40","name":"cooldownSec_","type":"uint40"}],"name":"setCooldownSecForOperatorFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint40","name":"cooldownSec_","type":"uint40"}],"name":"setCooldownSecForProtocolFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint40","name":"cooldownSec_","type":"uint40"}],"name":"setCooldownSecForUnstaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"distributionId","type":"uint16"},{"internalType":"uint40","name":"endTime","type":"uint40"}],"name":"setDistributionEnd","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"duration","type":"uint16"}],"name":"setExpiryDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"minVotingStake_","type":"uint256"}],"name":"setMinVotingStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setOperatorFeeBPS","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setProtocolFeeBPS","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newuri","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakedToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingStartTimestamp","outputs":[{"internalType":"uint40","name":"","type":"uint40"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"fromOperator","type":"address"},{"internalType":"address","name":"toOperator","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"switchOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"totalActiveOperators","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAlerts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalCooldownAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"totalCooldownAmounts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDistributions","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFrozenAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFrozenCooldownAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalOperators","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStakedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalVotingStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"totalVotingStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"voteForBlockAlert","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"message","type":"string"}],"name":"voteForMessageAlert","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"votedAlerts","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"votingStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000008457ca5040ad67fdebbcc8edce889a335bc0fbfb0000000000000000000000000000000000000000000000000000000066181710

-----Decoded View---------------
Arg [0] : altToken_ (address): 0x8457CA5040ad67fdebbCC8EdCE889A335Bc0fbFB
Arg [1] : stakingStartTimestamp_ (uint40): 1712854800

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000008457ca5040ad67fdebbcc8edce889a335bc0fbfb
Arg [1] : 0000000000000000000000000000000000000000000000000000000066181710