Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• 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 StakedALT 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";
    }

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

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

        // slither-disable-next-line arbitrary-send-erc20
        rewardToken.safeTransferFrom(rewardVault, protocolConfig.vault, protocolFeeAmount);
        // 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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

0000000000000000000000008457ca5040ad67fdebbcc8edce889a335bc0fbfb000000000000000000000000000000000000000000000000000000006603d200

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

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