Cryo Explorer Ethereum Mainnet

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

pragma solidity ^0.8.0;

import "../utils/Context.sol";

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.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 Pausable is Context {
    /**
     * @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);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _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) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @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.
 */
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].
     */
    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 v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @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 amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` 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 amount) 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 `amount` 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 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` 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 amount) external returns (bool);
}

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

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../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 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.encodeWithSelector(token.transfer.selector, 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.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 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);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @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.encodeWithSelector(token.approve.selector, spender, value);

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

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @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, "SafeERC20: low-level call failed");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    }

    /**
     * @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.isContract(address(token));
    }
}

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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @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.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @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, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * 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.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @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`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) 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(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";

/**
 * ██████╗  ██████╗  █████╗ ██╗    ███████╗ ██████╗ █████╗ ██╗     ██████╗ ███████╗██████╗
 * ██╔══██╗██╔═══██╗██╔══██╗██║    ██╔════╝██╔════╝██╔══██╗██║     ██╔══██╗██╔════╝██╔══██╗
 * ██████╔╝██║   ██║███████║██║    ███████╗██║     ███████║██║     ██████╔╝█████╗  ██████╔╝
 * ██╔══██╗██║   ██║██╔══██║██║    ╚════██║██║     ██╔══██║██║     ██╔═══╝ ██╔══╝  ██╔══██╗
 * ██║  ██║╚██████╔╝██║  ██║██║    ███████║╚██████╗██║  ██║███████╗██║     ███████╗██║  ██║
 * ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝    ╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝╚═╝     ╚══════╝╚═╝  ╚═╝
 *
 * ROAI Scalper - Advanced AI Trading & Staking Platform
 *
 * Website: https://roaiscalper.com
 * Twitter: https://x.com/roaiscalper
 * Telegram: https://t.me/roaiscalper_official
 *
 * Professional-grade staking infrastructure with multi-signature security,
 * role-based access control, and automated reward distribution.
 */

/**
 * @title AccessControl
 * @author ROAI Scalper Team
 * @notice Advanced role-based access control system for ROAI staking platform
 * @dev Features:
 *      - Granular role-based permissions
 *      - Multi-signature integration support
 *      - Emergency pause/unpause capabilities
 *      - Batch role management
 *      - Comprehensive access tracking
 *
 * Architecture:
 * - Centralized permission management for all platform contracts
 * - Role-based access with metadata and member tracking
 * - Emergency functions with appropriate role restrictions
 * - Pausable system for security incidents
 *
 * Security Features:
 * - Owner-only role management
 * - ReentrancyGuard protection
 * - Pausable emergency controls
 * - Comprehensive input validation
 * - Event logging for all role changes
 *
 * Roles:
 * - POOL_MANAGER_ROLE: Can create and manage staking pools
 * - REWARD_DISTRIBUTOR_ROLE: Can distribute rewards to pools
 * - EMERGENCY_ADMIN_ROLE: Can execute emergency functions
 * - PAUSER_ROLE: Can pause/unpause system functions
 *
 * @custom:security-contact [email protected]
 */
contract AccessControl is Ownable, ReentrancyGuard, Pausable {
    
    // Role definitions
    bytes32 public constant POOL_MANAGER_ROLE = keccak256("POOL_MANAGER_ROLE");
    bytes32 public constant REWARD_DISTRIBUTOR_ROLE = keccak256("REWARD_DISTRIBUTOR_ROLE");
    bytes32 public constant EMERGENCY_ADMIN_ROLE = keccak256("EMERGENCY_ADMIN_ROLE");
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
    
    // Role storage
    mapping(bytes32 => mapping(address => bool)) private _roles;
    mapping(bytes32 => address[]) private _roleMembers;
    mapping(address => bytes32[]) private _userRoles;
    
    // Role metadata
    struct RoleInfo {
        string name;
        string description;
        bool active;
        uint256 memberCount;
    }
    
    mapping(bytes32 => RoleInfo) public roleInfo;
    bytes32[] public allRoles;
    
    // Events
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
    event RoleCreated(bytes32 indexed role, string name, string description);
    event RoleDeactivated(bytes32 indexed role);
    event RoleActivated(bytes32 indexed role);
    
    /**
     * @dev Constructor sets up default roles
     */
    constructor() {
        _setupDefaultRoles();
        
        // Grant all roles to deployer initially
        _grantRole(POOL_MANAGER_ROLE, msg.sender);
        _grantRole(REWARD_DISTRIBUTOR_ROLE, msg.sender);
        _grantRole(EMERGENCY_ADMIN_ROLE, msg.sender);
        _grantRole(PAUSER_ROLE, msg.sender);
    }
    
    /**
     * @dev Setup default roles with metadata
     */
    function _setupDefaultRoles() internal {
        _createRole(POOL_MANAGER_ROLE, "Pool Manager", "Can create and manage staking pools");
        _createRole(REWARD_DISTRIBUTOR_ROLE, "Reward Distributor", "Can distribute rewards to pools");
        _createRole(EMERGENCY_ADMIN_ROLE, "Emergency Admin", "Can execute emergency functions");
        _createRole(PAUSER_ROLE, "Pauser", "Can pause/unpause system functions");
    }
    
    /**
     * @dev Create a new role
     */
    function _createRole(bytes32 role, string memory name, string memory description) internal {
        require(bytes(roleInfo[role].name).length == 0, "Role already exists");
        
        roleInfo[role] = RoleInfo({
            name: name,
            description: description,
            active: true,
            memberCount: 0
        });
        
        allRoles.push(role);
        emit RoleCreated(role, name, description);
    }
    
    /**
     * @dev Grant role to account
     */
    function grantRole(bytes32 role, address account) external onlyOwner {
        require(account != address(0), "Invalid account address");
        require(roleInfo[role].active, "Role is not active");
        
        _grantRole(role, account);
    }
    
    /**
     * @dev Internal function to grant role
     */
    function _grantRole(bytes32 role, address account) internal {
        if (!_roles[role][account]) {
            _roles[role][account] = true;
            _roleMembers[role].push(account);
            _userRoles[account].push(role);
            roleInfo[role].memberCount++;
            
            emit RoleGranted(role, account, msg.sender);
        }
    }
    
    /**
     * @dev Revoke role from account
     */
    function revokeRole(bytes32 role, address account) external onlyOwner {
        require(account != address(0), "Invalid account address");
        
        _revokeRole(role, account);
    }
    
    /**
     * @dev Internal function to revoke role
     */
    function _revokeRole(bytes32 role, address account) internal {
        if (_roles[role][account]) {
            _roles[role][account] = false;
            
            // Remove from role members array
            address[] storage members = _roleMembers[role];
            for (uint256 i = 0; i < members.length; i++) {
                if (members[i] == account) {
                    members[i] = members[members.length - 1];
                    members.pop();
                    break;
                }
            }
            
            // Remove from user roles array
            bytes32[] storage userRoles = _userRoles[account];
            for (uint256 i = 0; i < userRoles.length; i++) {
                if (userRoles[i] == role) {
                    userRoles[i] = userRoles[userRoles.length - 1];
                    userRoles.pop();
                    break;
                }
            }
            
            roleInfo[role].memberCount--;
            emit RoleRevoked(role, account, msg.sender);
        }
    }
    
    /**
     * @dev Check if account has role
     */
    function hasRole(bytes32 role, address account) public view returns (bool) {
        return _roles[role][account] && roleInfo[role].active;
    }
    
    /**
     * @dev Get all members of a role
     */
    function getRoleMembers(bytes32 role) external view returns (address[] memory) {
        return _roleMembers[role];
    }
    
    /**
     * @dev Get all roles for a user
     */
    function getUserRoles(address account) external view returns (bytes32[] memory) {
        return _userRoles[account];
    }
    
    /**
     * @dev Get all available roles
     */
    function getAllRoles() external view returns (bytes32[] memory) {
        return allRoles;
    }
    
    /**
     * @dev Get role information
     */
    function getRoleInfo(bytes32 role) external view returns (RoleInfo memory) {
        return roleInfo[role];
    }
    
    /**
     * @dev Deactivate a role (prevents new grants, existing members keep access)
     */
    function deactivateRole(bytes32 role) external onlyOwner {
        require(roleInfo[role].active, "Role already inactive");
        roleInfo[role].active = false;
        emit RoleDeactivated(role);
    }
    
    /**
     * @dev Activate a role
     */
    function activateRole(bytes32 role) external onlyOwner {
        require(!roleInfo[role].active, "Role already active");
        roleInfo[role].active = true;
        emit RoleActivated(role);
    }
    
    /**
     * @dev Modifier to check if caller has specific role
     */
    modifier onlyRole(bytes32 role) {
        require(hasRole(role, msg.sender) || msg.sender == owner(), "Access denied: insufficient role");
        _;
    }
    
    /**
     * @dev Modifier to check if caller has any of the specified roles
     */
    modifier onlyRoles(bytes32[] memory roles) {
        bool hasAnyRole = false;
        for (uint256 i = 0; i < roles.length; i++) {
            if (hasRole(roles[i], msg.sender)) {
                hasAnyRole = true;
                break;
            }
        }
        require(hasAnyRole || msg.sender == owner(), "Access denied: insufficient role");
        _;
    }
    
    /**
     * @dev Emergency pause function
     */
    function emergencyPause() external onlyRole(EMERGENCY_ADMIN_ROLE) {
        _pause();
    }
    
    /**
     * @dev Emergency unpause function
     */
    function emergencyUnpause() external onlyRole(EMERGENCY_ADMIN_ROLE) {
        _unpause();
    }
    
    /**
     * @dev Pause function for pausers
     */
    function pauseSystem() external onlyRole(PAUSER_ROLE) {
        _pause();
    }
    
    /**
     * @dev Unpause function for pausers
     */
    function unpauseSystem() external onlyRole(PAUSER_ROLE) {
        _unpause();
    }
    
    /**
     * @dev Check if system is paused
     */
    function isPaused() external view returns (bool) {
        return paused();
    }
    
    /**
     * @dev Batch grant roles to multiple accounts
     */
    function batchGrantRoles(bytes32[] calldata roles, address[] calldata accounts) external onlyOwner {
        require(roles.length == accounts.length, "Arrays length mismatch");
        
        for (uint256 i = 0; i < roles.length; i++) {
            require(accounts[i] != address(0), "Invalid account address");
            require(roleInfo[roles[i]].active, "Role is not active");
            _grantRole(roles[i], accounts[i]);
        }
    }
    
    /**
     * @dev Batch revoke roles from multiple accounts
     */
    function batchRevokeRoles(bytes32[] calldata roles, address[] calldata accounts) external onlyOwner {
        require(roles.length == accounts.length, "Arrays length mismatch");
        
        for (uint256 i = 0; i < roles.length; i++) {
            require(accounts[i] != address(0), "Invalid account address");
            _revokeRole(roles[i], accounts[i]);
        }
    }
    
    /**
     * @dev Get comprehensive access summary for an account
     */
    function getAccessSummary(address account) external view returns (
        bytes32[] memory roles,
        string[] memory roleNames,
        bool isOwner,
        bool systemPaused
    ) {
        bytes32[] memory userRoles = _userRoles[account];
        string[] memory names = new string[](userRoles.length);
        
        for (uint256 i = 0; i < userRoles.length; i++) {
            names[i] = roleInfo[userRoles[i]].name;
        }
        
        return (
            userRoles,
            names,
            account == owner(),
            paused()
        );
    }
}

// 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/IERC20Metadata.sol)

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol"; // Adjusted import path

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
} 

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ROAIStakingPool.sol"; // Import the actual ROAIStakingPool contract

/**
 * ██████╗  ██████╗  █████╗ ██╗    ███████╗ ██████╗ █████╗ ██╗     ██████╗ ███████╗██████╗
 * ██╔══██╗██╔═══██╗██╔══██╗██║    ██╔════╝██╔════╝██╔══██╗██║     ██╔══██╗██╔════╝██╔══██╗
 * ██████╔╝██║   ██║███████║██║    ███████╗██║     ███████║██║     ██████╔╝█████╗  ██████╔╝
 * ██╔══██╗██║   ██║██╔══██║██║    ╚════██║██║     ██╔══██║██║     ██╔═══╝ ██╔══╝  ██╔══██╗
 * ██║  ██║╚██████╔╝██║  ██║██║    ███████║╚██████╗██║  ██║███████╗██║     ███████╗██║  ██║
 * ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝    ╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝╚═╝     ╚══════╝╚═╝  ╚═╝
 *
 * ROAI Scalper - Advanced AI Trading & Staking Platform
 *
 * Website: https://roaiscalper.com
 * Twitter: https://x.com/roaiscalper
 * Telegram: https://t.me/roaiscalper_official
 *
 * Professional-grade staking infrastructure with multi-signature security,
 * role-based access control, and automated reward distribution.
 */

// Forward declaration of ROAIStakingPool interface to avoid import conflicts
interface IROAIStakingPool { // This interface is still useful for the call
    function transferOwnership(address newOwner) external;
}

// The local stub 'contract ROAIStakingPool' has been removed.
// 'type(ROAIStakingPool).creationCode' will now refer to the imported contract's bytecode.

/**
 * @title ROAIStakingFactory
 * @author ROAI Scalper Team
 * @notice Factory contract for creating and managing multiple ROAI staking pools
 * @dev Features:
 *      - Deterministic pool creation with CREATE2
 *      - Multi-pool reward distribution
 *      - AccessControl integration for new pools
 *      - Centralized pool management
 *      - Secure ownership transfer capabilities
 *
 * Architecture:
 * - Creates staking pools with standardized parameters
 * - Integrates with AccessControl for role-based permissions
 * - Manages reward distribution across multiple pools
 * - Provides pool discovery and validation
 *
 * Security Features:
 * - Secure salt generation for CREATE2
 * - Input validation for all parameters
 * - Access control integration
 * - Emergency functions support
 *
 * @custom:security-contact [email protected]
 */
contract ROAIStakingFactory is Ownable, ReentrancyGuard {
    // Token contract
    IERC20 public roaiToken;

    // Array of all staking pools
    address[] public stakingPools;

    // Mapping to check if an address is a staking pool
    mapping(address => bool) public isStakingPool;

    // Reward pool address
    address public rewardPool;

    // AccessControl contract address
    address public accessControl;

    // FIXED: Add nonce for secure salt generation
    uint256 private _poolCreationNonce;

    // DoS protection storage
    mapping(address => uint256) public failedDistributions;

    // Events
    event StakingPoolCreated(address poolAddress, uint256 maxStakers, uint256 fixedStakeAmount, string name);
    event RewardsDistributed(address[] pools, uint256[] percentages, uint256 totalAmount);
    event RewardPoolUpdated(address newRewardPool);
    event AccessControlUpdated(address newAccessControl);
    event DistributionFailed(address indexed pool, uint256 amount, string reason);
    event BatchDistributionCompleted(uint256 totalDistributed, uint256 totalFailed);
    event FailedDistributionRetried(address indexed pool, uint256 amount);

    /**
     * @dev Constructor
     * @param _roaiToken Address of the ROAI token contract
     */
    constructor(address _roaiToken) {
        require(_roaiToken != address(0), "Invalid token address");
        require(_roaiToken.code.length > 0, "Token must be a contract");
        _transferOwnership(msg.sender);
        roaiToken = IERC20(_roaiToken);
    }

    /**
     * @dev Set reward pool address
     * @param _rewardPool Address of the reward pool contract
     */
    function setRewardPool(address _rewardPool) external onlyOwner {
        require(_rewardPool != address(0), "Invalid reward pool address");
        require(_rewardPool.code.length > 0, "Reward pool must be a contract");
        rewardPool = _rewardPool;
        emit RewardPoolUpdated(_rewardPool);
    }

    /**
     * @dev Set AccessControl contract address
     * @param _accessControl Address of the AccessControl contract
     */
    function setAccessControl(address _accessControl) external onlyOwner {
        require(_accessControl != address(0), "Invalid AccessControl address");
        accessControl = _accessControl;
        emit AccessControlUpdated(_accessControl);
    }

    /**
     * @dev Create a new staking pool
     * @param _maxStakers Maximum number of stakers allowed in the pool
     * @param _fixedStakeAmount Fixed amount of tokens required to stake (in whole tokens)
     * @param _name Name of the staking pool
     * @return Address of the newly created staking pool
     */
    function createStakingPool(
        uint256 _maxStakers,
        uint256 _fixedStakeAmount,
        string memory _name
    ) external onlyOwner returns (address) {
        // FIXED: Add comprehensive input validation
        require(_maxStakers > 0 && _maxStakers <= 10000, "Invalid max stakers");
        require(_fixedStakeAmount > 0, "Invalid stake amount");
        require(bytes(_name).length > 0 && bytes(_name).length <= 50, "Invalid pool name");

        // FIXED: Validate AccessControl address is set before pool creation
        require(accessControl != address(0), "AccessControl not set");

        // Deploy a new ROAIStakingPool contract using the create2 opcode
        // This avoids directly importing the ROAIStakingPool contract

        // Get the bytecode of ROAIStakingPool from the contract
        bytes memory bytecode = type(ROAIStakingPool).creationCode;

        // Encode constructor parameters (including AccessControl address)
        bytes memory constructorArgs = abi.encode(
            address(roaiToken),
            _maxStakers,
            _fixedStakeAmount,
            _name,
            msg.sender,
            accessControl  // Pass AccessControl address to new pools
        );

        // Combine bytecode and constructor arguments
        bytes memory combinedBytecode = abi.encodePacked(bytecode, constructorArgs);

        // FIXED: Create secure salt with enhanced entropy to prevent predictability attacks
        // Include multiple sources of entropy for maximum security
        bytes32 salt = keccak256(abi.encodePacked(
            msg.sender,
            _poolCreationNonce,
            _name,
            _maxStakers,
            _fixedStakeAmount,
            block.timestamp,
            block.prevrandao, // Updated from block.difficulty for post-merge compatibility
            block.gaslimit,
            blockhash(block.number - 1),
            blockhash(block.number - 2),
            tx.gasprice,
            tx.origin
        ));

        // Increment nonce for next deployment
        _poolCreationNonce++;

        // Deploy the contract using create2
        address poolAddress;
        assembly {
            poolAddress := create2(0, add(combinedBytecode, 32), mload(combinedBytecode), salt)
            if iszero(extcodesize(poolAddress)) {
                revert(0, 0)
            }
        }

        // Register the new pool
        stakingPools.push(poolAddress);
        isStakingPool[poolAddress] = true;

        // The ROAIStakingPool's ownership is set to msg.sender (the factory's owner)
        // in its constructor. This explicit transfer is not needed and causes an error
        // because the factory contract itself is not the owner of the new pool.
        // IROAIStakingPool(poolAddress).transferOwnership(msg.sender);

        emit StakingPoolCreated(poolAddress, _maxStakers, _fixedStakeAmount, _name);

        return poolAddress;
    }

    /**
     * @dev Get the number of staking pools
     * @return Number of staking pools
     */
    function getStakingPoolCount() external view returns (uint256) {
        return stakingPools.length;
    }

    /**
     * @dev Distribute rewards to multiple staking pools
     * @param _poolAddresses Array of pool addresses to distribute rewards to
     * @param _percentages Array of percentages for each pool (must sum to 100)
     * @param _totalAmount Total amount of ETH to distribute
     * This can only be called by the reward pool
     */
    function distributeRewardsToMultiplePools(
        address[] calldata _poolAddresses,
        uint256[] calldata _percentages,
        uint256 _totalAmount
    ) external nonReentrant {
        require(msg.sender == rewardPool, "Only reward pool can distribute");
        require(_poolAddresses.length == _percentages.length, "Arrays must be same length");

        uint256 totalPercentage = 0;
        for (uint256 i = 0; i < _percentages.length; i++) {
            totalPercentage += _percentages[i];
        }
        require(totalPercentage == 100, "Percentages must sum to 100");

        // FIXED: Perform additional validations BEFORE external calls (CEI pattern)
        for (uint256 i = 0; i < _poolAddresses.length; i++) {
            require(_poolAddresses[i] != address(0), "Invalid pool address");
            require(isStakingPool[_poolAddresses[i]], "Not a valid staking pool");
            // FIXED: Validate pool exists and has code
            require(_poolAddresses[i].code.length > 0, "Pool no longer alive");
        }

        // Track successful and failed distributions
        uint256 totalDistributed = 0;
        uint256 totalFailed = 0;

        for (uint256 i = 0; i < _poolAddresses.length; i++) {
            address poolAddress = _poolAddresses[i];
            uint256 amount = (_totalAmount * _percentages[i]) / 100;

            // Skip zero amounts to avoid unnecessary gas costs
            if (amount > 0) {
                // FIXED: Use try/catch pattern to prevent single pool failure from reverting entire batch
                try this.safeTransferETH(poolAddress, amount) {
                    totalDistributed += amount;
                } catch Error(string memory reason) {
                    // Store failed distribution for retry and continue with others
                    failedDistributions[poolAddress] += amount;
                    totalFailed += amount;
                    emit DistributionFailed(poolAddress, amount, reason);
                } catch {
                    // Store failed distribution for retry and continue with others
                    failedDistributions[poolAddress] += amount;
                    totalFailed += amount;
                    emit DistributionFailed(poolAddress, amount, "Unknown error");
                }
            }
        }

        emit RewardsDistributed(_poolAddresses, _percentages, _totalAmount);
        emit BatchDistributionCompleted(totalDistributed, totalFailed);
    }

    /**
     * @dev Safe ETH transfer function that can be called externally for try/catch pattern
     * @param _to Address to send ETH to
     * @param _amount Amount of ETH to send
     */
    function safeTransferETH(address _to, uint256 _amount) external {
        require(msg.sender == address(this), "Only self can call");

        // Reserve 1/64th of remaining gas for this call (EIP-150)
        uint256 gasToUse = gasleft() - (gasleft() / 64);

        (bool success, bytes memory returnData) = _to.call{value: _amount, gas: gasToUse}("");
        if (!success) {
            // Provide detailed error information
            if (returnData.length > 0) {
                assembly {
                    let returnDataSize := mload(returnData)
                    revert(add(32, returnData), returnDataSize)
                }
            } else {
                revert("ETH transfer failed");
            }
        }
    }

    /**
     * @dev Retry failed distribution to a specific pool
     * @param _pool Address of the pool to retry distribution to
     */
    function retryFailedDistribution(address _pool) external onlyOwner nonReentrant {
        require(_pool != address(0), "Invalid pool address");
        require(isStakingPool[_pool], "Not a valid staking pool");

        uint256 amount = failedDistributions[_pool];
        require(amount > 0, "No failed distribution for this pool");
        require(address(this).balance >= amount, "Insufficient contract balance");

        // Clear the failed distribution before retry
        failedDistributions[_pool] = 0;

        // Attempt to send ETH to the pool
        (bool success, ) = _pool.call{value: amount}("");
        if (!success) {
            // If it fails again, restore the failed amount
            failedDistributions[_pool] = amount;
            revert("Retry distribution failed");
        }

        emit FailedDistributionRetried(_pool, amount);
    }

    /**
     * @dev Receive ETH (for direct distributions)
     */
    receive() external payable {
        // This allows the contract to receive ETH if needed
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

/**
 * ██████╗  ██████╗  █████╗ ██╗    ███████╗ ██████╗ █████╗ ██╗     ██████╗ ███████╗██████╗
 * ██╔══██╗██╔═══██╗██╔══██╗██║    ██╔════╝██╔════╝██╔══██╗██║     ██╔══██╗██╔════╝██╔══██╗
 * ██████╔╝██║   ██║███████║██║    ███████╗██║     ███████║██║     ██████╔╝█████╗  ██████╔╝
 * ██╔══██╗██║   ██║██╔══██║██║    ╚════██║██║     ██╔══██║██║     ██╔═══╝ ██╔══╝  ██╔══██╗
 * ██║  ██║╚██████╔╝██║  ██║██║    ███████║╚██████╗██║  ██║███████╗██║     ███████╗██║  ██║
 * ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝    ╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝╚═╝     ╚══════╝╚═╝  ╚═╝
 *
 * ROAI Scalper - Advanced AI Trading & Staking Platform
 *
 * Website: https://roaiscalper.com
 * Twitter: https://x.com/roaiscalper
 * Telegram: https://t.me/roaiscalper_official
 *
 * Professional-grade staking infrastructure with multi-signature security,
 * role-based access control, and automated reward distribution.
 */

// Interface for AccessControl contract
interface IAccessControl {
    function hasRole(bytes32 role, address account) external view returns (bool);
    function owner() external view returns (address);
}

/**
 * @title ROAIStakingPool
 * @author ROAI Scalper Team
 * @notice Advanced staking pool contract for ROAI tokens with ETH rewards
 * @dev Features:
 *      - Fixed-amount staking with multiple lock periods
 *      - Tiered bonus system (30, 90, 180 days)
 *      - Role-based access control integration
 *      - Emergency functions with multi-signature security
 *      - Gas-efficient reward claiming
 *      - Pausable operations for security
 *
 * Security Features:
 * - AccessControl integration for decentralized governance
 * - ReentrancyGuard protection
 * - Emergency withdrawal capabilities
 * - Multi-signature transaction support
 * - Comprehensive input validation
 *
 * @custom:security-contact [email protected]
 */
contract ROAIStakingPool is Ownable, ReentrancyGuard {
    // FIXED: Use SafeERC20 for secure token transfers
    using SafeERC20 for IERC20;

    // Token contract
    IERC20 public roaiToken;
    uint256 public constant TOKEN_DECIMALS = 9; // Define token decimals

    // AccessControl integration
    IAccessControl public accessControl;

    // Role definitions (must match AccessControl contract)
    bytes32 public constant POOL_MANAGER_ROLE = keccak256("POOL_MANAGER_ROLE");
    bytes32 public constant EMERGENCY_ADMIN_ROLE = keccak256("EMERGENCY_ADMIN_ROLE");
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");

    // Pool configuration
    uint256 public maxStakers;
    uint256 public fixedStakeAmount; // Stores fixed stake amount in ATOMIC UNITS (e.g., 25000 * 10**9)
    string public poolName;
    uint256 public currentStakerCount;
    uint256 public totalStaked; // Stores total staked in ATOMIC UNITS

    // FIXED: Add position limit per user to prevent unbounded growth
    uint256 public constant MAX_POSITIONS_PER_USER = 1;

    // Mapping to track if user has already staked (for single stake per user enforcement)
    mapping(address => bool) public hasStaked;

    // Lock period configuration
    struct LockPeriod {
        uint256 durationDays;
        uint256 bonusPercentage;
        bool active; // Added as per improvement plan
    }

    LockPeriod[] public lockPeriods;

    // Staking position
    struct StakingPosition {
        uint256 amount; // Stores amount in ATOMIC UNITS
        uint256 lockPeriodIndex;
        uint256 startTime;
        uint256 endTime;
        uint256 lastRewardCalculation;
        uint256 accumulatedRewards; // Stores ETH rewards in wei
        bool active;
    }

    // Mapping from user address to their staking positions
    mapping(address => StakingPosition[]) public stakingPositions;

    // Mapping to track if an address is currently staking
    mapping(address => bool) public isStaking;

    // Array to track all stakers for enumeration
    address[] public stakers;
    mapping(address => uint256) public stakerIndex; // Maps staker address to index in stakers array

    // Total rewards in the pool (ETH in wei)
    uint256 public totalRewards;

    // FIXED: Pull-based reward pattern to prevent DoS/theft vectors
    mapping(address => uint256) public pendingRewards;
    uint256 public totalPendingRewards;

    // Pool status
    bool public paused; // Added as per improvement plan

    // Access control modifiers
    modifier onlyPoolManager() {
        require(
            (address(accessControl) != address(0) && accessControl.hasRole(POOL_MANAGER_ROLE, msg.sender)) ||
            msg.sender == owner() ||
            (address(accessControl) != address(0) && msg.sender == accessControl.owner()),
            "Access denied: Pool Manager role required"
        );
        _;
    }

    modifier onlyEmergencyAdmin() {
        require(
            (address(accessControl) != address(0) && accessControl.hasRole(EMERGENCY_ADMIN_ROLE, msg.sender)) ||
            msg.sender == owner() ||
            (address(accessControl) != address(0) && msg.sender == accessControl.owner()),
            "Access denied: Emergency Admin role required"
        );
        _;
    }

    modifier onlyPauser() {
        require(
            (address(accessControl) != address(0) && accessControl.hasRole(PAUSER_ROLE, msg.sender)) ||
            msg.sender == owner() ||
            (address(accessControl) != address(0) && msg.sender == accessControl.owner()),
            "Access denied: Pauser role required"
        );
        _;
    }

    // Events
    event Staked(address indexed user, uint256 amount, uint256 lockPeriodIndex, uint256 positionIndex);
    event Unstaked(address indexed user, uint256 amount, uint256 positionIndex);
    event RewardsClaimed(address indexed user, uint256 amount, uint256 positionIndex);
    event RewardsAdded(uint256 amount);
    event LockPeriodAdded(uint256 durationDays, uint256 bonusPercentage, bool active);
    event LockPeriodStatusUpdated(uint256 indexed index, bool active);
    event FixedStakeAmountUpdated(uint256 newFixedStakeAmount);
    event PoolNameUpdated(string oldName, string newName);
    event PoolPaused();
    event PoolUnpaused();
    event EmergencyTokensWithdrawn(address indexed token, uint256 amount);
    event EmergencyETHWithdrawn(address indexed to, uint256 amount);
    event RewardsPending(address indexed user, uint256 amount);
    event RewardsWithdrawn(address indexed user, uint256 amount);

    /**
     * @dev Constructor
     * @param _roaiToken Address of the ROAI token contract
     * @param _maxStakers Maximum number of stakers allowed in the pool
     * @param _fixedStakeAmountInWholeTokens Fixed amount of WHOLE tokens required to stake (e.g., 25000)
     * @param _poolName Name of the staking pool
     * @param _owner Address of the contract owner
     * @param _accessControl Address of the AccessControl contract (can be zero for backward compatibility)
     */
    constructor(
        address _roaiToken,
        uint256 _maxStakers,
        uint256 _fixedStakeAmountInWholeTokens,
        string memory _poolName,
        address _owner,
        address _accessControl
    ) {
        // FIXED: Add comprehensive input validation
        require(_roaiToken != address(0), "Invalid token address");
        require(_owner != address(0), "Invalid owner address");
        require(_maxStakers > 0 && _maxStakers <= 10000, "Invalid max stakers");
        require(_fixedStakeAmountInWholeTokens > 0, "Invalid stake amount");
        require(bytes(_poolName).length > 0 && bytes(_poolName).length <= 50, "Invalid pool name");
        // Note: _accessControl can be zero for backward compatibility

        _transferOwnership(_owner);
        roaiToken = IERC20(_roaiToken);
        maxStakers = _maxStakers;
        fixedStakeAmount = _fixedStakeAmountInWholeTokens * (10**TOKEN_DECIMALS); // Convert to atomic units
        poolName = _poolName;

        // Set AccessControl contract (can be zero for backward compatibility)
        if (_accessControl != address(0)) {
            accessControl = IAccessControl(_accessControl);
        }

        // Initialize with default lock periods (marked as active)
        // 1 minute for testing, then 30, 60, 90, 180 days
        _addLockPeriod(0, 0, true);   // 1 minute for testing (0 days + 1 minute in seconds)
        _addLockPeriod(30, 5, true);  // 30 days, 5% bonus
        _addLockPeriod(60, 15, true); // 60 days, 15% bonus
        _addLockPeriod(90, 25, true); // 90 days, 25% bonus
        _addLockPeriod(180, 35, true); // 180 days, 35% bonus
    }

    /**
     * @dev Set AccessControl contract address (callable by owner)
     * @param _accessControl Address of the AccessControl contract
     */
    function setAccessControl(address _accessControl) external onlyOwner {
        accessControl = IAccessControl(_accessControl);
    }

    // Internal function to add lock periods, used by constructor and admin function
    function _addLockPeriod(uint256 _durationDays, uint256 _bonusPercentage, bool _active) private {
        lockPeriods.push(LockPeriod({
            durationDays: _durationDays,
            bonusPercentage: _bonusPercentage,
            active: _active
        }));
        emit LockPeriodAdded(_durationDays, _bonusPercentage, _active);
    }

    /**
     * @dev Add a new lock period (callable by pool manager)
     * @param _durationDays Duration in days
     * @param _bonusPercentage Bonus percentage for this lock period
     * @param _active Whether the lock period is initially active
     */
    function addLockPeriod(uint256 _durationDays, uint256 _bonusPercentage, bool _active) public onlyPoolManager {
        // FIXED: Add input validation
        require(_durationDays <= 3650, "Duration too long"); // Max 10 years
        require(_bonusPercentage <= 1000, "Bonus too high"); // Max 1000% bonus

        _addLockPeriod(_durationDays, _bonusPercentage, _active);
    }

    /**
     * @dev Disable a lock period (callable by pool manager)
     * @param _index Index of the lock period to disable
     */
    function disableLockPeriod(uint256 _index) public onlyPoolManager {
        require(_index < lockPeriods.length, "Invalid lock period index");
        lockPeriods[_index].active = false;
        emit LockPeriodStatusUpdated(_index, false);
    }

    /**
     * @dev Enable a lock period (callable by pool manager)
     * @param _index Index of the lock period to enable
     */
    function enableLockPeriod(uint256 _index) public onlyPoolManager {
        require(_index < lockPeriods.length, "Invalid lock period index");
        lockPeriods[_index].active = true;
        emit LockPeriodStatusUpdated(_index, true);
    }
    
    /**
     * @dev Update the fixed stake amount (callable by pool manager)
     * @param _newFixedStakeAmountInWholeTokens New fixed stake amount in WHOLE tokens (e.g., 20000)
     */
    function updateFixedStakeAmount(uint256 _newFixedStakeAmountInWholeTokens) public onlyPoolManager {
        // FIXED: Add input validation
        require(_newFixedStakeAmountInWholeTokens > 0, "Invalid stake amount");
        require(_newFixedStakeAmountInWholeTokens <= 1000000, "Stake amount too high"); // Max 1M tokens

        fixedStakeAmount = _newFixedStakeAmountInWholeTokens * (10**TOKEN_DECIMALS); // Convert to atomic units
        emit FixedStakeAmountUpdated(fixedStakeAmount);
    }

    /**
     * @dev Update the pool name (callable by pool manager)
     * @param _newPoolName New name for the pool
     */
    function updatePoolName(string memory _newPoolName) public onlyPoolManager {
        require(bytes(_newPoolName).length > 0, "Pool name cannot be empty");
        string memory oldName = poolName;
        poolName = _newPoolName;
        emit PoolNameUpdated(oldName, _newPoolName);
    }

    /**
     * @dev Pause staking and unstaking operations (callable by pauser)
     */
    function pausePool() public onlyPauser {
        paused = true;
        emit PoolPaused();
    }

    /**
     * @dev Unpause staking and unstaking operations (callable by pauser)
     */
    function unpausePool() public onlyPauser {
        paused = false;
        emit PoolUnpaused();
    }

    /**
     * @dev Emergency withdraw of tokens from the contract (callable by emergency admin)
     * @param _tokenAddress The address of the ERC20 token to withdraw
     * @param _amount The amount of tokens to withdraw (in atomic units)
     */
    function emergencyWithdrawTokens(address _tokenAddress, uint256 _amount) public onlyEmergencyAdmin nonReentrant {
        require(_tokenAddress != address(0), "Invalid token address");
        require(_amount > 0, "Amount must be greater than 0");

        IERC20 token = IERC20(_tokenAddress);
        require(token.balanceOf(address(this)) >= _amount, "Insufficient token balance");

        // FIXED: Follow CEI pattern - emit event before external call for consistency
        emit EmergencyTokensWithdrawn(_tokenAddress, _amount);

        // FIXED: Use SafeERC20 for secure token transfer
        token.safeTransfer(owner(), _amount);
    }

    /**
     * @dev Emergency withdraw of ETH from the contract (callable by emergency admin)
     * @param _amount The amount of ETH to withdraw (in wei)
     * @param _to Address to send ETH to
     * FIXED: Add restrictions to prevent abuse
     */
    function emergencyWithdrawETH(uint256 _amount, address payable _to) external onlyEmergencyAdmin nonReentrant {
        require(_to != address(0), "Invalid recipient address");
        require(_amount > 0, "Amount must be greater than 0");
        require(address(this).balance >= _amount, "Insufficient contract balance");

        // FIXED: Restrict emergency withdrawals to not drain all user rewards
        uint256 maxWithdrawable = totalRewards > totalPendingRewards ? totalRewards - totalPendingRewards : 0;
        require(_amount <= maxWithdrawable, "Cannot withdraw pending user rewards");

        // FIXED: Follow CEI pattern - update state BEFORE external call
        uint256 amountToWithdraw = _amount;

        // FIXED: Account for pending rewards in emergency withdrawal
        uint256 availableForWithdrawal = totalRewards;
        if (amountToWithdraw <= availableForWithdrawal) {
            totalRewards -= amountToWithdraw;
        } else {
            totalRewards = 0;
        }

        // External interaction last
        (bool success, ) = _to.call{value: amountToWithdraw}("");
        require(success, "ETH transfer failed");

        emit EmergencyETHWithdrawn(_to, amountToWithdraw);
    }

    /**
     * @dev Emergency withdraw all ETH from the contract (callable by emergency admin)
     * @param _to Address to send all ETH to
     * FIXED: Add warning and restrictions for complete drainage
     */
    function emergencyWithdrawAllETH(address payable _to) external onlyEmergencyAdmin nonReentrant {
        require(_to != address(0), "Invalid recipient address");
        uint256 balance = address(this).balance;
        require(balance > 0, "No ETH to withdraw");

        // FIXED: This function should only be used in extreme emergencies
        // as it will prevent users from withdrawing their pending rewards

        // FIXED: Follow CEI pattern - update state BEFORE external call
        uint256 amountToWithdraw = balance;

        // Reset totalRewards since we're withdrawing everything
        totalRewards = 0;

        // External interaction last
        (bool success, ) = _to.call{value: amountToWithdraw}("");
        require(success, "ETH transfer failed");

        emit EmergencyETHWithdrawn(_to, amountToWithdraw);
    }
    
    /**
     * @dev Stake tokens. Uses the fixed stake amount defined for this pool.
     * @param _lockPeriodIndex Index of the lock period to use
     */
    function stake(uint256 _lockPeriodIndex) external nonReentrant whenNotPaused {
        require(_lockPeriodIndex < lockPeriods.length, "Invalid lock period index");
        require(lockPeriods[_lockPeriodIndex].active, "Lock period not active");
        require(currentStakerCount < maxStakers, "Pool is full");
        require(!hasStaked[msg.sender], "User has already staked in this pool");

        // FIXED: Check ACTIVE position limit per user to prevent unbounded growth
        uint256 activePositions = 0;
        for (uint256 i = 0; i < stakingPositions[msg.sender].length; i++) {
            if (stakingPositions[msg.sender][i].active) {
                activePositions++;
            }
        }
        require(activePositions < MAX_POSITIONS_PER_USER, "Max active positions per user reached");

        // Perform state updates BEFORE interaction
        currentStakerCount++;
        isStaking[msg.sender] = true;
        hasStaked[msg.sender] = true;

        // Add user to stakers array for enumeration
        stakers.push(msg.sender);
        stakerIndex[msg.sender] = stakers.length - 1;

        uint256 lockDurationSeconds;
        if (lockPeriods[_lockPeriodIndex].durationDays == 0) {
            // Special case for testing: 1 minute lock period
            lockDurationSeconds = 1 minutes;
        } else {
            lockDurationSeconds = lockPeriods[_lockPeriodIndex].durationDays * 1 days;
        }
        uint256 endTime = block.timestamp + lockDurationSeconds;

        stakingPositions[msg.sender].push(StakingPosition({
            amount: fixedStakeAmount,
            lockPeriodIndex: _lockPeriodIndex,
            startTime: block.timestamp,
            endTime: endTime,
            lastRewardCalculation: block.timestamp,
            accumulatedRewards: 0,
            active: true
        }));

        totalStaked += fixedStakeAmount;

        emit Staked(msg.sender, fixedStakeAmount, _lockPeriodIndex, stakingPositions[msg.sender].length - 1);

        // FIXED: Use SafeERC20 for secure token transfer
        roaiToken.safeTransferFrom(msg.sender, address(this), fixedStakeAmount);
    }

    /**
     * @dev Unstake tokens. Position amount is in ATOMIC UNITS.
     * @param _positionIndex Index of the staking position to unstake
     */
    function unstake(uint256 _positionIndex) external nonReentrant whenNotPaused { // Added whenNotPaused
        require(_positionIndex < stakingPositions[msg.sender].length, "Invalid position index");

        StakingPosition storage position = stakingPositions[msg.sender][_positionIndex];
        require(position.active, "Position not active");
        require(block.timestamp >= position.endTime, "Lock period not ended");

        // FIXED: Calculate any remaining rewards BEFORE marking position inactive
        updateRewards(_positionIndex);

        // FIXED: Store values before state changes (CEI pattern)
        uint256 stakedAmount = position.amount;
        uint256 accumulatedRewards = position.accumulatedRewards;

        // FIXED: Update state variables BEFORE external calls
        position.amount = 0;
        position.accumulatedRewards = 0;
        position.active = false;
        totalStaked -= stakedAmount;

        // FIXED: Only reduce totalRewards if there are rewards to claim
        if (accumulatedRewards > 0) {
            totalRewards -= accumulatedRewards;
        }

        // FIXED: Automatically clean up inactive positions and check if user has any active positions left
        StakingPosition[] storage positions = stakingPositions[msg.sender];
        uint256 originalLength = positions.length;

        // Count active positions and create new array with only active positions
        uint256 activeCount = 0;
        for (uint256 i = 0; i < positions.length; i++) {
            if (positions[i].active) {
                activeCount++;
            }
        }

        // If there are inactive positions, clean them up
        if (activeCount < originalLength) {
            // Create new array with only active positions
            StakingPosition[] memory activePositions = new StakingPosition[](activeCount);
            uint256 activeIndex = 0;

            for (uint256 i = 0; i < positions.length; i++) {
                if (positions[i].active) {
                    activePositions[activeIndex] = positions[i];
                    activeIndex++;
                }
            }

            // Replace the storage array
            delete stakingPositions[msg.sender];
            for (uint256 i = 0; i < activePositions.length; i++) {
                stakingPositions[msg.sender].push(activePositions[i]);
            }
        }

        // If no active positions, user is no longer staking
        if (activeCount == 0) {
            isStaking[msg.sender] = false;
            hasStaked[msg.sender] = false; // Allow user to stake again
            currentStakerCount--;

            // Remove user from stakers array
            uint256 userIndex = stakerIndex[msg.sender];
            uint256 lastIndex = stakers.length - 1;

            if (userIndex != lastIndex) {
                // Move the last staker to the position of the removed staker
                address lastStaker = stakers[lastIndex];
                stakers[userIndex] = lastStaker;
                stakerIndex[lastStaker] = userIndex;
            }

            stakers.pop();
            delete stakerIndex[msg.sender];
        }

        // FIXED: Use SafeERC20 for secure token transfer back to user
        roaiToken.safeTransfer(msg.sender, stakedAmount);

        // FIXED: Use pull-based pattern for rewards to prevent DoS/theft vectors
        if (accumulatedRewards > 0) {
            pendingRewards[msg.sender] += accumulatedRewards;
            totalPendingRewards += accumulatedRewards;
            emit RewardsPending(msg.sender, accumulatedRewards);
            emit RewardsClaimed(msg.sender, accumulatedRewards, _positionIndex);
        }

        emit Unstaked(msg.sender, stakedAmount, _positionIndex);
    }

    /**
     * @dev Claim rewards. Rewards are in ETH (wei).
     * @param _positionIndex Index of the staking position to claim rewards for
     * FIXED: Use pull-based pattern to prevent DoS/theft vectors
     */
    function claimRewards(uint256 _positionIndex) external nonReentrant whenNotPaused { // Added whenNotPaused
        require(_positionIndex < stakingPositions[msg.sender].length, "Invalid position index");

        StakingPosition storage position = stakingPositions[msg.sender][_positionIndex];
        require(position.active, "Position not active");

        // Update rewards
        updateRewards(_positionIndex);

        // Add rewards to pending instead of direct transfer
        uint256 rewards = position.accumulatedRewards;
        require(rewards > 0, "No rewards to claim");

        position.accumulatedRewards = 0;
        totalRewards -= rewards;

        // FIXED: Add to pending rewards instead of direct transfer
        pendingRewards[msg.sender] += rewards;
        totalPendingRewards += rewards;

        emit RewardsPending(msg.sender, rewards);
        emit RewardsClaimed(msg.sender, rewards, _positionIndex);
    }

    /**
     * @dev Withdraw pending rewards (pull-based pattern)
     * FIXED: Separate function for withdrawing rewards to prevent DoS/theft vectors
     */
    function withdrawPendingRewards() external nonReentrant whenNotPaused {
        uint256 pending = pendingRewards[msg.sender];
        require(pending > 0, "No pending rewards");

        // Update state before external call (CEI pattern)
        pendingRewards[msg.sender] = 0;
        totalPendingRewards -= pending;

        // Transfer ETH to user
        (bool success, ) = payable(msg.sender).call{value: pending}("");
        require(success, "ETH transfer failed");

        emit RewardsWithdrawn(msg.sender, pending);
    }

    /**
     * @dev Get pending rewards for a user
     * @param _user Address of the user
     * @return Amount of pending rewards in wei
     */
    function getPendingRewards(address _user) external view returns (uint256) {
        return pendingRewards[_user];
    }

    /**
     * @dev Get all stakers in the pool
     * @return Array of staker addresses
     */
    function getAllStakers() external view returns (address[] memory) {
        return stakers;
    }

    /**
     * @dev Get staker information by index
     * @param _index Index of the staker in the stakers array
     * @return staker Address of the staker
     * @return userTotalStaked Total amount staked by the user
     * @return positionCount Number of positions the user has
     * @return pendingRewardsAmount Pending rewards for the user
     * @return isActive Whether the user has active positions
     */
    function getStakerInfo(uint256 _index) external view returns (
        address staker,
        uint256 userTotalStaked,
        uint256 positionCount,
        uint256 pendingRewardsAmount,
        bool isActive
    ) {
        require(_index < stakers.length, "Invalid staker index");

        address stakerAddress = stakers[_index];
        StakingPosition[] memory positions = stakingPositions[stakerAddress];

        uint256 stakerTotalStaked = 0;
        bool hasActivePosition = false;

        for (uint256 i = 0; i < positions.length; i++) {
            stakerTotalStaked += positions[i].amount;
            if (positions[i].active) {
                hasActivePosition = true;
            }
        }

        return (
            stakerAddress,
            stakerTotalStaked,
            positions.length,
            pendingRewards[stakerAddress],
            hasActivePosition
        );
    }

    /**
     * @dev Get detailed information for all stakers
     * @return stakerAddresses Array of staker addresses
     * @return userTotalStakedAmounts Array of total staked amounts for each staker
     * @return positionCounts Array of position counts for each staker
     * @return pendingRewardsAmounts Array of pending rewards for each staker
     * @return activeStatuses Array of active status for each staker
     */
    function getAllStakersInfo() external view returns (
        address[] memory stakerAddresses,
        uint256[] memory userTotalStakedAmounts,
        uint256[] memory positionCounts,
        uint256[] memory pendingRewardsAmounts,
        bool[] memory activeStatuses
    ) {
        uint256 stakerCount = stakers.length;

        stakerAddresses = new address[](stakerCount);
        userTotalStakedAmounts = new uint256[](stakerCount);
        positionCounts = new uint256[](stakerCount);
        pendingRewardsAmounts = new uint256[](stakerCount);
        activeStatuses = new bool[](stakerCount);

        for (uint256 i = 0; i < stakerCount; i++) {
            address stakerAddress = stakers[i];
            StakingPosition[] memory positions = stakingPositions[stakerAddress];

            uint256 stakerTotalStaked = 0;
            bool hasActivePosition = false;

            for (uint256 j = 0; j < positions.length; j++) {
                stakerTotalStaked += positions[j].amount;
                if (positions[j].active) {
                    hasActivePosition = true;
                }
            }

            stakerAddresses[i] = stakerAddress;
            userTotalStakedAmounts[i] = stakerTotalStaked;
            positionCounts[i] = positions.length;
            pendingRewardsAmounts[i] = pendingRewards[stakerAddress];
            activeStatuses[i] = hasActivePosition;
        }

        return (stakerAddresses, userTotalStakedAmounts, positionCounts, pendingRewardsAmounts, activeStatuses);
    }

    /**
     * @dev Update rewards for a staking position
     * @param _positionIndex Index of the staking position to update
     */
    function updateRewards(uint256 _positionIndex) public whenNotPaused {
        require(_positionIndex < stakingPositions[msg.sender].length, "Invalid position index");

        StakingPosition storage position = stakingPositions[msg.sender][_positionIndex];
        if (!position.active) return;

        // Calculate time since last reward calculation
        uint256 timeElapsed = block.timestamp - position.lastRewardCalculation;
        if (timeElapsed == 0) return;

        // If there are no rewards in the pool, just update the last calculation time
        if (totalRewards == 0 || totalStaked == 0) {
            position.lastRewardCalculation = block.timestamp;
            return;
        }

        // Calculate effective staking amount with bonus
        uint256 bonusPercentage = lockPeriods[position.lockPeriodIndex].bonusPercentage;
        // Fixed precision issue: multiply before divide to avoid precision loss
        uint256 bonusAmount = (position.amount * bonusPercentage) / 100;
        uint256 effectiveAmount = position.amount + bonusAmount;

        // Fixed precision issue: use scaled arithmetic to prevent precision loss
        // Scale by 1e18 for precision, then divide at the end
        uint256 scaledRewardRate = (totalRewards * 1e18) / totalStaked;
        uint256 scaledNewRewards = (effectiveAmount * scaledRewardRate * timeElapsed) / (365 days * 1e18);

        // Cap rewards to available total
        uint256 newRewards = scaledNewRewards > totalRewards ? totalRewards : scaledNewRewards;

        position.accumulatedRewards += newRewards;
        position.lastRewardCalculation = block.timestamp;
    }

    /**
     * @dev Get all staking positions for a user
     * @param _user Address of the user
     * @return Array of staking positions
     */
    function getStakingPositions(address _user) external view returns (StakingPosition[] memory) {
        return stakingPositions[_user];
    }

    /**
     * @dev Get all lock periods
     * @return Array of lock periods
     */
    function getLockPeriods() external view returns (LockPeriod[] memory) {
        return lockPeriods;
    }

    /**
     * @dev Get the fixed stake amount in whole tokens
     * @return Fixed stake amount in whole tokens
     */
    function getFixedStakeAmountInWholeTokens() external view returns (uint256) {
        return fixedStakeAmount / (10**TOKEN_DECIMALS);
    }

    /**
     * @dev Calculate rewards for a staking position
     * @param _user Address of the user
     * @param _positionIndex Index of the staking position
     * @return Calculated rewards
     */
    function calculateRewards(address _user, uint256 _positionIndex) external view returns (uint256) {
        require(_user != address(0), "Invalid user address");
        require(_positionIndex < stakingPositions[_user].length, "Invalid position index");

        StakingPosition memory position = stakingPositions[_user][_positionIndex];
        if (!position.active) return 0;

        // Calculate time since last reward calculation
        uint256 timeElapsed = block.timestamp - position.lastRewardCalculation;
        if (timeElapsed == 0 || totalRewards == 0 || totalStaked == 0) {
            return position.accumulatedRewards;
        }

        // Calculate effective staking amount with bonus
        uint256 bonusPercentage = lockPeriods[position.lockPeriodIndex].bonusPercentage;
        // Fixed precision issue: multiply before divide to avoid precision loss
        uint256 bonusAmount = (position.amount * bonusPercentage) / 100;
        uint256 effectiveAmount = position.amount + bonusAmount;

        // Fixed precision issue: use scaled arithmetic to prevent precision loss
        // Scale by 1e18 for precision, then divide at the end
        uint256 scaledRewardRate = (totalRewards * 1e18) / totalStaked;
        uint256 scaledNewRewards = (effectiveAmount * scaledRewardRate * timeElapsed) / (365 days * 1e18);

        // Cap rewards to available total
        uint256 newRewards = scaledNewRewards > totalRewards ? totalRewards : scaledNewRewards;

        return position.accumulatedRewards + newRewards;
    }

    /**
     * @dev Receive ETH rewards
     */
    receive() external payable {
        // Only add to totalRewards if value > 0
        if (msg.value > 0) {
            totalRewards += msg.value;
            emit RewardsAdded(msg.value);
        }
    }

    /**
     * @dev Fallback function to handle ETH sent via selfdestruct
     * @notice This prevents accounting mismatches when ETH is sent via selfdestruct
     */
    fallback() external payable {
        // Credit any ETH sent via selfdestruct to totalRewards
        if (msg.value > 0) {
            totalRewards += msg.value;
            emit RewardsAdded(msg.value);
        }
    }

    /**
     * @dev Get all active lock periods
     * @return Array of active lock periods
     */
    function getActiveLockPeriods() external view returns (LockPeriod[] memory) {
        uint256 activeCount = 0;
        for (uint256 i = 0; i < lockPeriods.length; i++) {
            if (lockPeriods[i].active) {
                activeCount++;
            }
        }

        LockPeriod[] memory activePeriods = new LockPeriod[](activeCount);
        uint256 currentIndex = 0;
        for (uint256 i = 0; i < lockPeriods.length; i++) {
            if (lockPeriods[i].active) {
                activePeriods[currentIndex] = lockPeriods[i];
                currentIndex++;
            }
        }
        return activePeriods;
    }

    /**
     * @dev Clean up inactive positions for a user to free up space
     * @param _user Address of the user to clean up positions for
     * NOTE: This function is now mostly redundant since unstaking automatically cleans up,
     * but kept for backward compatibility and manual cleanup if needed
     */
    function cleanupInactivePositions(address _user) external {
        require(_user != address(0), "Invalid user address");

        StakingPosition[] storage positions = stakingPositions[_user];
        uint256 originalLength = positions.length;

        // Count active positions
        uint256 activeCount = 0;
        for (uint256 i = 0; i < positions.length; i++) {
            if (positions[i].active) {
                activeCount++;
            }
        }

        // If all positions are active, nothing to clean
        if (activeCount == originalLength) {
            return;
        }

        // Create new array with only active positions
        StakingPosition[] memory activePositions = new StakingPosition[](activeCount);
        uint256 activeIndex = 0;

        for (uint256 i = 0; i < positions.length; i++) {
            if (positions[i].active) {
                activePositions[activeIndex] = positions[i];
                activeIndex++;
            }
        }

        // Replace the storage array
        delete stakingPositions[_user];
        for (uint256 i = 0; i < activePositions.length; i++) {
            stakingPositions[_user].push(activePositions[i]);
        }
    }

    /**
     * @dev Modifier to allow actions only when the contract is not paused.
     */
    modifier whenNotPaused() {
        require(!paused, "Contract is paused");
        _;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

/**
 * ██████╗  ██████╗  █████╗ ██╗    ███████╗ ██████╗ █████╗ ██╗     ██████╗ ███████╗██████╗
 * ██╔══██╗██╔═══██╗██╔══██╗██║    ██╔════╝██╔════╝██╔══██╗██║     ██╔══██╗██╔════╝██╔══██╗
 * ██████╔╝██║   ██║███████║██║    ███████╗██║     ███████║██║     ██████╔╝█████╗  ██████╔╝
 * ██╔══██╗██║   ██║██╔══██║██║    ╚════██║██║     ██╔══██║██║     ██╔═══╝ ██╔══╝  ██╔══██╗
 * ██║  ██║╚██████╔╝██║  ██║██║    ███████║╚██████╗██║  ██║███████╗██║     ███████╗██║  ██║
 * ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝    ╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝╚═╝     ╚══════╝╚═╝  ╚═╝
 *
 * ROAI Scalper - Advanced AI Trading & Staking Platform
 *
 * Website: https://roaiscalper.com
 * Twitter: https://x.com/roaiscalper
 * Telegram: https://t.me/roaiscalper_official
 *
 * Professional-grade staking infrastructure with multi-signature security,
 * role-based access control, and automated reward distribution.
 */

/**
 * @title SimpleRewardDistributor
 * @author ROAI Scalper Team
 * @notice Simplified reward distribution contract for efficient ETH distribution to staking pools
 * @dev Features:
 *      - Direct ETH transfers to multiple pools
 *      - Configurable reserve percentage for treasury
 *      - Emergency withdrawal capabilities
 *      - Multi-signature security integration
 *      - Gas-optimized distribution logic
 *
 * Architecture:
 * - Receives ETH deposits from various sources
 * - Maintains configurable reserve percentage
 * - Distributes remaining ETH to pools based on percentages
 * - Provides emergency functions for treasury management
 *
 * Security Features:
 * - ReentrancyGuard protection
 * - Owner-only administrative functions
 * - Treasury wallet integration
 * - Comprehensive input validation
 * - Emergency withdrawal capabilities
 *
 * @custom:security-contact [email protected]
 */
contract SimpleRewardDistributor is Ownable, ReentrancyGuard {

    // Reserve percentage (e.g., 20 = 20%)
    uint256 public reservePercentage = 20;

    // Maximum reserve percentage allowed
    uint256 public constant MAX_RESERVE_PERCENTAGE = 50;

    // Treasury wallet address for emergency withdrawals
    address public treasuryWallet;

    // Events
    event RewardsDistributed(address[] pools, uint256[] amounts, uint256 totalDistributed);
    event ReservePercentageUpdated(uint256 oldPercentage, uint256 newPercentage);
    event ETHDeposited(address indexed from, uint256 amount);
    event EmergencyWithdrawal(address indexed to, uint256 amount);
    event TreasuryWalletUpdated(address indexed oldTreasury, address indexed newTreasury);
    
    /**
     * @dev Constructor
     * @param _owner Address of the contract owner
     * @param _treasuryWallet Address of the treasury wallet (optional, can be set later)
     */
    constructor(address _owner, address _treasuryWallet) {
        _transferOwnership(_owner);
        if (_treasuryWallet != address(0)) {
            treasuryWallet = _treasuryWallet;
            emit TreasuryWalletUpdated(address(0), _treasuryWallet);
        }
    }
    
    /**
     * @dev Get the total balance of this contract
     * @return Total ETH balance in wei
     */
    function getTotalBalance() public view returns (uint256) {
        return address(this).balance;
    }
    
    /**
     * @dev Get the reserve amount (not distributable)
     * @return Reserve amount in wei
     */
    function getReserveAmount() public view returns (uint256) {
        return (address(this).balance * reservePercentage) / 100;
    }
    
    /**
     * @dev Get distributable amount (total balance minus reserve)
     * @return Amount of ETH that can be distributed in wei
     */
    function getDistributableAmount() public view returns (uint256) {
        uint256 totalBalance = address(this).balance;
        uint256 reserveAmount = getReserveAmount();
        return totalBalance > reserveAmount ? totalBalance - reserveAmount : 0;
    }
    
    /**
     * @dev Set treasury wallet address
     * @param _treasuryWallet New treasury wallet address
     */
    function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
        require(_treasuryWallet != address(0), "Invalid treasury address");

        address oldTreasury = treasuryWallet;
        treasuryWallet = _treasuryWallet;

        emit TreasuryWalletUpdated(oldTreasury, _treasuryWallet);
    }

    /**
     * @dev Get treasury wallet address
     * @return Address of the treasury wallet
     */
    function getTreasuryWallet() external view returns (address) {
        return treasuryWallet;
    }

    /**
     * @dev Set reserve percentage
     * @param _reservePercentage New reserve percentage (0-50)
     */
    function setReservePercentage(uint256 _reservePercentage) external onlyOwner {
        require(_reservePercentage <= MAX_RESERVE_PERCENTAGE, "Reserve cannot exceed 50%");

        uint256 oldPercentage = reservePercentage;
        reservePercentage = _reservePercentage;

        emit ReservePercentageUpdated(oldPercentage, _reservePercentage);
    }
    
    /**
     * @dev Distribute rewards to multiple pools
     * @param _poolAddresses Array of pool addresses to distribute rewards to
     * @param _percentages Array of percentages for each pool (must sum to 100)
     */
    function distributeRewards(
        address[] calldata _poolAddresses,
        uint256[] calldata _percentages
    ) external onlyOwner nonReentrant {
        require(_poolAddresses.length > 0, "No pools specified");
        require(_poolAddresses.length == _percentages.length, "Arrays length mismatch");
        
        // Validate percentages sum to 100
        uint256 totalPercentage = 0;
        for (uint256 i = 0; i < _percentages.length; i++) {
            totalPercentage += _percentages[i];
        }
        require(totalPercentage == 100, "Percentages must sum to 100");
        
        // Get distributable amount
        uint256 distributableAmount = getDistributableAmount();
        require(distributableAmount > 0, "No funds available for distribution");
        
        // Calculate and distribute amounts
        uint256[] memory amounts = new uint256[](_poolAddresses.length);
        uint256 totalDistributed = 0;
        
        for (uint256 i = 0; i < _poolAddresses.length; i++) {
            require(_poolAddresses[i] != address(0), "Invalid pool address");
            
            // Calculate amount for this pool
            uint256 amount = (distributableAmount * _percentages[i]) / 100;
            amounts[i] = amount;
            
            // Only transfer if amount > 0
            if (amount > 0) {
                // Direct ETH transfer to pool
                (bool success, ) = payable(_poolAddresses[i]).call{value: amount}("");
                require(success, string(abi.encodePacked("Transfer failed to pool: ", _addressToString(_poolAddresses[i]))));
                
                totalDistributed += amount;
            }
        }
        
        emit RewardsDistributed(_poolAddresses, amounts, totalDistributed);
    }
    
    /**
     * @dev Emergency withdrawal of ETH to treasury wallet
     * @param _amount Amount of ETH to withdraw (in wei)
     */
    function emergencyWithdrawToTreasury(uint256 _amount) external onlyOwner {
        require(treasuryWallet != address(0), "Treasury wallet not set");
        require(_amount > 0, "Amount must be greater than 0");
        require(address(this).balance >= _amount, "Insufficient contract balance");

        (bool success, ) = payable(treasuryWallet).call{value: _amount}("");
        require(success, "ETH transfer failed");

        emit EmergencyWithdrawal(treasuryWallet, _amount);
    }

    /**
     * @dev Emergency withdrawal of all ETH to treasury wallet
     */
    function emergencyWithdrawAllToTreasury() external onlyOwner {
        require(treasuryWallet != address(0), "Treasury wallet not set");
        uint256 balance = address(this).balance;
        require(balance > 0, "No ETH to withdraw");

        (bool success, ) = payable(treasuryWallet).call{value: balance}("");
        require(success, "ETH transfer failed");

        emit EmergencyWithdrawal(treasuryWallet, balance);
    }

    /**
     * @dev Emergency withdrawal of ETH (owner only) - Legacy function for custom address
     * @param _amount Amount of ETH to withdraw (in wei)
     * @param _to Address to send ETH to
     */
    function emergencyWithdrawETH(uint256 _amount, address payable _to) external onlyOwner {
        require(_to != address(0), "Invalid recipient address");
        require(_amount > 0, "Amount must be greater than 0");
        require(address(this).balance >= _amount, "Insufficient contract balance");

        (bool success, ) = _to.call{value: _amount}("");
        require(success, "ETH transfer failed");

        emit EmergencyWithdrawal(_to, _amount);
    }

    /**
     * @dev Emergency withdrawal of all ETH (owner only) - Legacy function for custom address
     * @param _to Address to send all ETH to
     */
    function emergencyWithdrawAllETH(address payable _to) external onlyOwner {
        require(_to != address(0), "Invalid recipient address");
        uint256 balance = address(this).balance;
        require(balance > 0, "No ETH to withdraw");

        (bool success, ) = _to.call{value: balance}("");
        require(success, "ETH transfer failed");

        emit EmergencyWithdrawal(_to, balance);
    }
    
    /**
     * @dev Receive ETH deposits
     */
    receive() external payable {
        require(msg.value > 0, "Cannot deposit zero ETH");
        emit ETHDeposited(msg.sender, msg.value);
    }
    
    /**
     * @dev Fallback function to receive ETH
     */
    fallback() external payable {
        require(msg.value > 0, "Cannot deposit zero ETH");
        emit ETHDeposited(msg.sender, msg.value);
    }
    
    /**
     * @dev Helper function to convert address to string
     * @param _addr Address to convert
     * @return String representation of the address
     */
    function _addressToString(address _addr) internal pure returns (string memory) {
        bytes32 value = bytes32(uint256(uint160(_addr)));
        bytes memory alphabet = "0123456789abcdef";
        bytes memory str = new bytes(42);
        str[0] = '0';
        str[1] = 'x';
        for (uint256 i = 0; i < 20; i++) {
            str[2+i*2] = alphabet[uint8(value[i + 12] >> 4)];
            str[3+i*2] = alphabet[uint8(value[i + 12] & 0x0f)];
        }
        return string(str);
    }
    
    /**
     * @dev Get contract info for debugging
     * @return totalBalance Current total balance
     * @return reserveAmount Current reserve amount
     * @return distributableAmount Current distributable amount
     * @return reservePerc Current reserve percentage
     * @return treasury Current treasury wallet address
     */
    function getContractInfo() external view returns (
        uint256 totalBalance,
        uint256 reserveAmount,
        uint256 distributableAmount,
        uint256 reservePerc,
        address treasury
    ) {
        totalBalance = getTotalBalance();
        reserveAmount = getReserveAmount();
        distributableAmount = getDistributableAmount();
        reservePerc = reservePercentage;
        treasury = treasuryWallet;
    }
}