Contract Address Details

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

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

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

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;


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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


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

// File: @openzeppelin/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

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

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

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

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


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

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;




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

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

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

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

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

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

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

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

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

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

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

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

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

// File: PulseCoinStaking-05-05-24.sol

/**
* SPDX-License-Identifier: GPL-3.0
*
* ██████╗ ██╗   ██╗██╗     ███████╗███████╗ ██████╗ ██████╗ ██╗███╗   ██╗
* ██╔══██╗██║   ██║██║     ██╔════╝██╔════╝██╔════╝██╔═══██╗██║████╗  ██║
* ██████╔╝██║   ██║██║     ███████╗█████╗  ██║     ██║   ██║██║██╔██╗ ██║
* ██╔═══╝ ██║   ██║██║     ╚════██║██╔══╝  ██║     ██║   ██║██║██║╚██╗██║
* ██║     ╚██████╔╝███████╗███████║███████╗╚██████╗╚██████╔╝██║██║ ╚████║
* ╚═╝      ╚═════╝ ╚══════╝╚══════╝╚══════╝ ╚═════╝ ╚═════╝ ╚═╝╚═╝  ╚═══╝ 
* __  __                               _                            
* \ \/ /___  __  _______   _________  (_)___                        
*  \  / __ \/ / / / ___/  / ___/ __ \/ / __ \                       
*  / / /_/ / /_/ / /     / /__/ /_/ / / / / /                       
* /_/\____/\__,_/_/ ____ \___/\____/_/_/ /_/________          _     
*   ____  ____     / __ \__  __/ /_______  / ____/ /_  ____ _(_)___ 
*  / __ \/ __ \   / /_/ / / / / / ___/ _ \/ /   / __ \/ __ `/ / __ \
* / /_/ / / / /  / ____/ /_/ / (__  )  __/ /___/ / / / /_/ / / / / /
* \____/_/ /_/  /_/    \__,_/_/____/\___/\____/_/ /_/\__,_/_/_/ /_/ 
*                                                                                                         
* @title PulseCoin Staking Contract
* @notice This contract is released under the GNU General Public License v3.0
* 
* 
* Copyright (C) 2024 PulseCoin
* Last changed 2024-05-05
*/
                                                                       


pragma solidity 0.8.24;





// Interface for WPLS token
interface IWPLS {
    function deposit() external payable;
    function withdraw(uint256 wad) external;
    function approve(address guy, uint256 wad) external returns (bool);
    function transfer(address dst, uint256 wad) external returns (bool);
}


// Interface for PulseX's Factory contract
interface IPulseXFactory {
    function createPair(address tokenA, address tokenB) external returns (address pair);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
}

interface IPulseXPair {
    function mint(address to) external returns (uint256 liquidity);
    function burn(uint256 amount) external;
    function transfer(address to, uint256 amount) external returns (bool);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}

interface IPulseXRouter {
    
    // Add the addLiquidityETH function
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);

    // Function to get the address of WPLS token
    function WPLS() external view returns (address);

    function factory() external view returns (address);
}




contract PulseCoinStaking is ReentrancyGuard, Ownable {
    
    using SafeERC20 for IERC20;
    uint256 public constant PulseCoin_TOTAL_SUPPLY = 21e6 * 1e18; // Total supply of PulseCoin tokens
    address public burnAddress = 0x000000000000000000000000000000000000dEaD;
    uint256 public constant CLAIM_PERIOD_IN_BLOCKS = 92 * 24 * 3600 / 10;
    uint256 public liquidityPercentage; // 10%
    address public liquidityContractAddress;
    uint256 public beneficiaryPercentage;
    address public beneficiaryAddress;
    uint256 public unstakeFee;
    address public pulseXFactoryAddress;
    address public WPLSContractAddress;
    address public pulseXRouterAddress;
    address public stakingTokenAddress;
//    For testing, use Pulsechain Testnet V4 and the following testnet contracts
//    address public constant pulseXFactoryAddress = 0xFf0538782D122d3112F75dc7121F61562261c0f7;
//    address public constant WPLSContractAddress = 0x70499adEBB11Efd915E3b69E700c331778628707;
//    address public constant pulseXRouterAddress = 0xDaE9dd3d1A52CfCe9d5F2fAC7fDe164D500E50f7;
//    address public constant stakingTokenAddress = 0x4994093e0c753aF4534B2f3dfCd99DbCf45421EF;
    uint256 public burntSupplyPercentage = 17;
    uint256 public totalStakersCount;





    struct Stake {
        uint256 amount;
        uint256 stakeBlockNumber;
    }

    struct StakeDetail {
        uint256 stakeID;
        address staker;
        uint256 amount;
        uint256 stakeBlockNumber;
        bool isActive;
    }

    struct Airdrop {
        IERC20 airdropToken;
        uint256 airdropAmount;
        uint256 snapshotTotalStaked;
        uint256 airdropBlockNumber;
        bool redistributed;
        address pCCreatedLPAddress;
        bool isExternal;
        mapping(address => bool) claimed;
        address msgSender;
        bool useSnapshot;
        uint256 remainingBalance;
    }

    

    mapping(address => Stake) public stakes; 
    mapping(uint256 => StakeDetail) public stakeDetails; // Mapping from stake ID to StakeDetail struct
    mapping(address => uint256[]) public userStakeIDs; // Mapping from user address to list of their stake IDs
    uint256 private stakeIDCounter = 0; // Counter to generate unique stake IDs
    Airdrop[] public airdrops;
    uint256 public totalStaked;
    //mapping(address => uint256) public liquidityProvisionBalance;
    mapping(address => bool) public factoryContracts; // Mapping to keep track of factory contracts
    mapping(address => bool) public whitelistedTokens; // Whitelist of external tokens to accept


    receive() external payable {}

    // Constructor
    constructor(
        address _pulseXFactoryAddress,
        address _WPLSContractAddress,
        address _pulseXRouterAddress,
        address _stakingTokenAddress
    ) Ownable(msg.sender) {
        beneficiaryAddress = 0x000000000000000000000000000000000000dEaD;
        liquidityContractAddress = 0x000000000000000000000000000000000000dEaD;
        unstakeFee = 369;
        liquidityPercentage = 10;
        beneficiaryPercentage = 369;
        pulseXFactoryAddress = _pulseXFactoryAddress;
        WPLSContractAddress = _WPLSContractAddress;
        pulseXRouterAddress = _pulseXRouterAddress;
        stakingTokenAddress = _stakingTokenAddress;
        PulseCoinToken = IERC20(_stakingTokenAddress);
        pulseXFactory = IPulseXFactory(_pulseXFactoryAddress);
        wpls = IWPLS(_WPLSContractAddress);
        pulseXRouter = IPulseXRouter(_pulseXRouterAddress);
    }
    

    event Staked(address indexed user, uint256 amount, uint256 stakeID);
    event Unstaked(address indexed user, uint256 amount);
    event AirdropTokenReceived(address token, uint256 amount, uint256 airdropID);
    event Claimed(address indexed user, uint256 airdropID);
    event LiquidityPairCreated(address indexed token, address indexed wpls, address pair);
    event LPTokensBurned(address indexed pair, uint256 amount, address burnAddress);
    event LiquidityAdded(uint amountToken, uint amountETH, uint liquidity);
    event FactoryContractAdded(address factoryAddress);
    event FactoryContractRemoved(address factoryAddress);
    event BeneficiaryAddressUpdated(address indexed newBeneficiaryAddress);
    event UnstakeFeeUpdated(uint256 unstakeFee);
    event LiquidityPercentageUpdated(uint256 newLiquidityPercentage);
    event LiquidityContractAddressUpdated(address indexed newLiquidityContractAddress);
    event BeneficiaryPercentageUpdated(uint256 newBeneficiaryPercentage);


    


    // New constants for LP creation
    IERC20 public PulseCoinToken = IERC20(stakingTokenAddress);
    IPulseXFactory public pulseXFactory = IPulseXFactory(pulseXFactoryAddress);
    IWPLS public wpls = IWPLS(WPLSContractAddress);
    IPulseXRouter private pulseXRouter = IPulseXRouter(pulseXRouterAddress);


    /**
    * @dev Ensures that the function can only be called by addresses that have been designated as factory contracts.
    * This modifier checks the calling address against a set of addresses marked as factory contracts within the contract's state. If the caller is not recognized as a factory contract, the transaction is reverted with an error message.
    */
    modifier onlyFactoryContracts() {
        require(factoryContracts[msg.sender], "Caller is not a factory contract");
        _;
    }


    /**
    * @notice Adds a new address to the list of factory contracts allowed to interact with certain functions.
    * @dev Marks an address as a factory contract, enabling it to call functions protected by the `onlyFactoryContracts` modifier. Only callable by the contract owner.
    * @param _factoryAddress The address of the factory contract to be added.
    * Emits a `FactoryContractAdded` event upon successfully adding a new factory contract address.
    */
    function addFactoryContract(address _factoryAddress) public onlyOwner {
        factoryContracts[_factoryAddress] = true;
        emit FactoryContractAdded(_factoryAddress);
    }

    /**
    * @notice Removes an address from the list of factory contracts.
    * @dev Deletes an address from the set of addresses marked as factory contracts, effectively revoking its ability to call functions protected by the `onlyFactoryContracts` modifier. Only callable by the contract owner.
    * @param _factoryAddress The address of the factory contract to be removed.
    * Emits a `FactoryContractRemoved` event upon successfully removing a factory contract address.
    */
    function removeFactoryContract(address _factoryAddress) public onlyOwner {
        delete factoryContracts[_factoryAddress];
        emit FactoryContractRemoved(_factoryAddress);
    }

    /**
    * @notice Adds a token to the whitelist, allowing it to be used for external airdrops.
    * @dev Only the contract owner can add tokens to the whitelist. This control mechanism ensures that only tokens vetted and approved by the contract's administrators can participate in external airdrop processes. The function checks for the zero address to prevent invalid entries.
    * @param _token The address of the token to be added to the whitelist.
    * Requires that the provided token address is not the zero address, ensuring that only valid tokens are whitelisted.
    * Sets the token's status in the `whitelistedTokens` mapping to `true`, effectively adding it to the whitelist.
    */
    function addTokenToWhitelist(address _token) external onlyOwner {
        require(_token != address(0), "Invalid token address");
        whitelistedTokens[_token] = true;
    }

    /**
    * @notice Removes a token from the whitelist, preventing it from being used for future external airdrops.
    * @dev Only the contract owner can remove tokens from the whitelist, providing a mechanism for maintaining control over which tokens are approved for airdrops. This function ensures that tokens can be dynamically managed based on ongoing assessments and criteria.
    * @param _token The address of the token to be removed from the whitelist.
    * Requires that the token is currently whitelisted, ensuring that only previously approved tokens can be removed from the whitelist.
    * Deletes the token's entry from the `whitelistedTokens` mapping, effectively removing it from the whitelist.
    */
    function removeTokenFromWhitelist(address _token) external onlyOwner {
        require(whitelistedTokens[_token], "Token not in whitelist");
        delete whitelistedTokens[_token];
    }

    /**
    * @notice Updates the beneficiary address where a portion of the fees or other designated funds may be sent.
    * @dev Sets a new beneficiary address, ensuring it is not the zero address. Only callable by the contract owner.
    * @param _newBeneficiaryAddress The new address to be set as the beneficiary.
    * Requires that the new beneficiary address is not the zero address.
    * Emits a `BeneficiaryAddressUpdated` event upon successfully updating the beneficiary address.
    */
    function setBeneficiaryAddress(address _newBeneficiaryAddress) external onlyOwner {
        require(_newBeneficiaryAddress != address(0), "Invalid address: cannot be the zero address");
        beneficiaryAddress = _newBeneficiaryAddress;
        emit BeneficiaryAddressUpdated(beneficiaryAddress);
    }

    /**
    * @notice Updates the liquidity contract address which may be used for liquidity-related operations.
    * @dev Sets a new liquidity contract address, ensuring it is not the zero address. Only callable by the contract owner. This address can be used for operations related to managing liquidity, such as adding liquidity to a pool.
    * @param _newLiquidityContractAddress The new address to be set as the liquidity contract.
    * Requires that the new liquidity contract address is not the zero address.
    * Emits a `LiquidityContractAddressUpdated` event upon successfully updating the liquidity contract address.
    */
    function setLiquidityContractAddress(address _newLiquidityContractAddress) external onlyOwner {
        require(_newLiquidityContractAddress != address(0), "Invalid address: cannot be the zero address");
        liquidityContractAddress = _newLiquidityContractAddress;
        emit LiquidityContractAddressUpdated(_newLiquidityContractAddress);
    }


    /**
    * @notice Updates the fee percentage charged when unstaking tokens early.
    * @dev Sets a new unstake fee percentage, ensuring it is within the range 0% to 3.69%. Only callable by the contract owner.
    * @param _newUnstakeFee The new unstake fee percentage to be set (in basis points).
    * Requires that the new unstake fee is not negative and does not exceed 3.69%.
    * Emits an `UnstakeFeeUpdated` event upon successfully updating the unstake fee.
    */
    function setUnstakeFee(uint256 _newUnstakeFee) external onlyOwner {
        require(_newUnstakeFee >= 0, "Unstake fee must not be negative");
        require(_newUnstakeFee <= 369, "Unstake fee must not exceed 3.69%");
        unstakeFee = _newUnstakeFee;
        emit UnstakeFeeUpdated(unstakeFee);
    }

    /**
    * @notice Updates the percentage of certain funds allocated for liquidity provision.
    * @dev Sets a new liquidity percentage, ensuring it falls within the valid range of 0% to 100%. Only callable by the contract owner.
    * @param _liquidityPercentage The new percentage of funds to be allocated towards liquidity provision.
    * Requires that the new liquidity percentage is between 0% and 100%.
    * Emits a `LiquidityPercentageUpdated` event upon successfully updating the liquidity percentage.
    */
    function setLiquidityPercentage(uint256 _liquidityPercentage) external onlyOwner {
        require(_liquidityPercentage >= 0 && _liquidityPercentage <= 100, "Liquidity percentage must be between 0% and 100%");
        liquidityPercentage = _liquidityPercentage;
        emit LiquidityPercentageUpdated(_liquidityPercentage);
    }


    /**
    * @notice Updates the percentage of certain funds allocated to the beneficiary.
    * @dev Sets a new beneficiary percentage, ensuring it falls within the valid range of 0% to 100%. Only callable by the contract owner.
    * @param _beneficiaryPercentage The new percentage of funds to be allocated to the beneficiary.
    * Requires that the new beneficiary percentage is between 0% and 100%.
    * Emits a `BeneficiaryPercentageUpdated` event upon successfully updating the beneficiary percentage.
    */
    function setBeneficiaryPercentage(uint256 _beneficiaryPercentage) external onlyOwner {
        require(_beneficiaryPercentage >= 0 && _beneficiaryPercentage <= 100, "Beneficiary Percentage must be between 0% and 100%");
        beneficiaryPercentage = _beneficiaryPercentage;
        emit BeneficiaryPercentageUpdated(_beneficiaryPercentage);
    }




    /**
    * @notice Allows a user to stake a specified amount of tokens into the contract, updating both the regular and detailed stake records.
    * @dev Transfers the specified amount of tokens from the caller to the contract. This updates the caller's regular stake record and creates a detailed stake record with a unique ID for the action. It sets the stake's start block number for new stakes, increments the total number of stakers if it's a new staker, and updates the total staked amount. The function emits a `Staked` event upon successful staking. It ensures detailed tracking of each staking action for enhanced functionality such as snapshot-based airdrops.
    * @param _amount The amount of tokens to be staked by the caller.
    * Requires that the staking amount is greater than 0 and that the stake is not made from the zero address.
    * For the caller's initial stake, sets the `stakeBlockNumber` to the current block number for the regular stake and increments `totalStakersCount`.
    * Adds the staked amount to the caller's current stake and creates/updates detailed stake records.
    * Emits a `Staked` event with the caller's address and the amount staked.
    */
    function stake(uint256 _amount) public nonReentrant {
        require(_amount > 0, "Amount must be greater than 0");
        require(msg.sender != address(0), "Stake from the zero address");

        // Check that the total staked plus the new amount does not exceed the total supply
        require(totalStaked + _amount <= PulseCoin_TOTAL_SUPPLY, "Staking exceeds total supply");
    

        PulseCoinToken.safeTransferFrom(msg.sender, address(this), _amount);

        // Regular stake logic
        if (stakes[msg.sender].amount == 0 && _amount > 0) {
            stakes[msg.sender].stakeBlockNumber = block.number;
            totalStakersCount++; // Update totalStakersCount if this is a new staker
        }
        stakes[msg.sender].amount += _amount;

        // Create and record a new StakeDetail
        uint256 newStakeID = ++stakeIDCounter;
        stakeDetails[newStakeID] = StakeDetail({
            stakeID: newStakeID,
            staker: msg.sender,
            amount: _amount,
            stakeBlockNumber: block.number,
            isActive: true
        });
        userStakeIDs[msg.sender].push(newStakeID);

        totalStaked += _amount;
        emit Staked(msg.sender, _amount, newStakeID);
    }


    /**
     * This function has been edited after audit to correctly calculate the vesting completion block number.
     * Audited code uses the userStake.StakeBlockNumber, while the code below uses airdropBlockNumber + vestingDuration.
     * which is the intended behavior.
     * @notice Checks if the vesting period for a user's stake has been completed for a specific airdrop.
     * @dev Compares the current block number against the calculated vesting completion block number, derived from the airdrop's block number plus the vesting duration, to determine if the vesting is complete. Requires that the airdrop ID is valid.
     * @param _user The address of the user whose vesting completion status is being checked.
     * @param _airdropID The ID of the airdrop for which the vesting completion is being checked.
     * @return complete Boolean indicating if the vesting period is complete.
     * @return vestingCompletionBlock The block number at which the user's vesting period for the specified airdrop is complete.
     */
    function isVestingComplete(address _user, uint256 _airdropID) public view returns (bool, uint256) {
        require(_airdropID < airdrops.length, "Invalid airdrop ID");

        Stake memory userStake = stakes[_user];
        Airdrop storage airdrop = airdrops[_airdropID];

        uint256 vestingDuration = calculateVestingDuration(userStake.amount);
        uint256 vestingCompletionBlock = airdrop.airdropBlockNumber + vestingDuration;
        
        return (block.number >= vestingCompletionBlock, vestingCompletionBlock);
    }

    /**
    * @notice Calculates the vesting duration for a given stake amount.
    * @dev Determines the vesting duration based on the size of the stake. Stakes up to 1000 ether have no vesting period, stakes between 1000 ether and 1 million ether have a vesting period that scales linearly up to 90 days, and stakes larger than 1 million ether have a fixed 90-day vesting period.
    * @param _stakeAmount The amount of the stake for which to calculate the vesting duration.
    * @return The vesting duration in blocks. For stakes up to 1000 ether, returns 0. For stakes between 1000 ether and 1 million ether, returns a scaled duration up to the equivalent of 90 days in blocks. For stakes over 1 million ether, returns the equivalent of 90 days in blocks.
    */
    function calculateVestingDuration(uint256 _stakeAmount) public pure returns (uint256) {
        if (_stakeAmount <= 1000 ether) {
            return 0;
        } else if (_stakeAmount <= 1e6 ether) {
            uint256 daysCalc = (_stakeAmount - 1000 ether) * 90 / (1e6 ether - 1000 ether);
            return daysCalc * 24 * 60 * 60 / 10; // Convert days to blocks, assuming an average block time
        } else {
            return 90 * 24 * 60 * 60 / 10; // 90 days in blocks, assuming an average block time
        }
    }



    /**
    * @notice Calculates the fee required to skip the vesting period for a user's staked tokens.
    * @dev Determines the skip fee based on the user's staked duration relative to their total vesting duration. The initial fee is set at 3.69%, and decreases linearly based on how much of the vesting period has passed. If the entire vesting period has elapsed, no fee is applied. This method encourages users to fulfill their vesting period but offers flexibility for early withdrawal at a cost.
    * @param _user The address of the user for whom the skip fee is being calculated.
    * @return The calculated fee amount in tokens that the user must pay to skip the remainder of their vesting period. Returns 0 if the vesting period has already concluded.
    * The skip fee is initially set at 3.69% of the staked amount and decreases linearly with time, proportionate to the duration staked versus the total vesting duration.
    * If the user has already met or exceeded the vesting duration, the function returns 0, indicating no skip fee is necessary.
    */
    function calculateSkipFee(address _user) public view returns (uint256) {
        Stake memory userStake = stakes[_user];
        uint256 initialFeePercentage = 369; // 3.69%
        uint256 vestingDuration = calculateVestingDuration(userStake.amount);
        uint256 stakedDuration = block.number - userStake.stakeBlockNumber;

        if (stakedDuration >= vestingDuration) {
            return 0; // No fee if vesting period is over
        }

        // Calculate discounted fee based on staked duration
        uint256 discount = stakedDuration * initialFeePercentage / vestingDuration;
        uint256 feePercentage = initialFeePercentage - discount;
        return userStake.amount * feePercentage / 10000;
    }


    /**
    * @notice Allows a user to unstake their staked tokens, applying an unstake fee penalty.
    * @dev Unstakes the caller's entire token stake, subtracting an unstake fee defined by `unstakeFee` and transferring the remaining balance back to the caller. Also sets all associated StakeDetail entries as inactive. The unstake fee is burned, effectively removing it from circulation. This action reduces the total staked amount and decrements the count of total stakers. It emits an `Unstaked` event upon successful completion.
    * Requires that the caller has an existing stake with a non-zero amount.
    * Calculates the unstake penalty based on the `unstakeFee` percentage of the staked amount.
    * Burns the penalty amount and transfers the remaining staked amount back to the caller.
    * Sets all StakeDetail entries for the caller as inactive, ensuring they're not considered for future rewards.
    * Resets the caller's stake amount to 0 and decrements the total stakers count.
    * Emits an `Unstaked` event with the caller's address and the amount returned after applying the unstake penalty.
    */
    function unstake() public nonReentrant {
        Stake storage userStake = stakes[msg.sender];
        require(userStake.amount > 0, "No stake found");
        require(msg.sender != address(0), "Unstake from the zero address");

        uint256 penalty = userStake.amount * unstakeFee / 10000; // Calculate unstake penalty
        uint256 returnAmount = userStake.amount - penalty;
        burn(penalty);

        // Iterate over all stakeIDs for the caller and set them as inactive
        for (uint256 i = 0; i < userStakeIDs[msg.sender].length; i++) {
            uint256 stakeID = userStakeIDs[msg.sender][i];
            StakeDetail storage detail = stakeDetails[stakeID];
            detail.isActive = false;
        }

        totalStaked -= userStake.amount;
        userStake.amount = 0;
        if (userStake.amount == 0) {
            totalStakersCount -= 1;
        }
        PulseCoinToken.safeTransfer(msg.sender, returnAmount);

        emit Unstaked(msg.sender, returnAmount);
    }



    /**
    * @notice Searches for the first airdrop that occurred on or after a specified block number.
    * @dev Iterates through the list of airdrops recorded in the contract to find the first airdrop whose block number is greater than or equal to the given block number. This function is useful for identifying airdrops within a specific timeframe. If no airdrop is found that meets the criteria, the function returns the total number of airdrops, effectively indicating an out-of-bounds index.
    * @param blockNumber The block number from which to start the search for subsequent airdrops.
    * @return The index of the first airdrop occurring on or after the specified block number. If no such airdrop is found, returns the length of the airdrops array.
    */
    function findFirstAirdropAfterBlock(uint256 blockNumber) public view returns (uint256) {
        for (uint256 i = 0; i < airdrops.length; i++) {
            if (airdrops[i].airdropBlockNumber >= blockNumber) {
                return i;
            }
        }
        return airdrops.length; // Indicate no airdrop found after the specified block by returning the array length
    }


    // Function to return the total number of airdrops
    function getTotalAirdrops() public view returns (uint256) {
        return airdrops.length;
    }

    function numberOfStakers() public view returns (uint256) {
        return totalStakersCount;
    }

    /**
    * @notice Receives tokens for an internal airdrop, with an option to automatically create a liquidity pair using a percentage of the airdropped tokens.
    * @dev Accepts a token and an amount for airdrop, with the option to use a portion of the airdropped tokens to create a liquidity pair with PLS. Validates the token is not the staking token, checks for sufficient PLS if LP creation is requested, and ensures the LP percentage is within valid bounds. It then records the airdrop details, including whether it's external and the address of any created LP pair. Emits an `AirdropTokenReceived` event upon completion.
    * @param _token The address of the token being airdropped.
    * @param _amount The amount of the token being airdropped.
    * @param createLP A boolean indicating whether part of the airdropped tokens should be used to create a liquidity pair with PLS.
    * @param lpPercentage The percentage of the received airdrop amount to be used for liquidity provision, if `createLP` is true.
    * Requires the airdropped token to not be the staking token.
    * Requires that if `createLP` is true, sufficient PLS is sent with the call to cover the liquidity provision.
    * The `lpPercentage` must be between 1 and 99, inclusive.
    * Calculates the actual received amount of airdropped tokens, accounting for any potential transfer fees or taxes.
    * Optionally creates a liquidity pair with the specified percentage of the airdropped tokens and PLS sent with the transaction, adjusting the liquidity provision balance based on the maximum allowed.
    * Records the airdrop as internal, with details of the received amount, total staked at snapshot, block number, and LP pair address if created.
    * Emits `AirdropTokenReceived` with the token address, received amount, and airdrop ID for tracking and verification.
    */
    function receiveAirdropTokens(
        address _token, 
        uint256 _amount, 
        bool createLP,
        uint8 lpPercentage, //Parameter for liquidity provision percentage
        bool useSnapshot // Use snapshot or flat rate
    ) public payable onlyFactoryContracts { 
        require(_token != address(PulseCoinToken), "Staking token cannot be airdropped");
        require(!createLP || msg.value > 0, "Insufficient PLS for LP creation");
        require(lpPercentage >= 1 && lpPercentage <= 99, "LP percentage must be between 1% and 99%");

        IERC20 airdropToken = IERC20(_token);

        // Store the initial balance of the airdrop token
        uint256 initialBalance = airdropToken.balanceOf(address(this));

        airdropToken.safeTransferFrom(msg.sender, address(this), _amount);

        // Calculate the actual received amount, considering potential token tax
        uint256 receivedAmount = airdropToken.balanceOf(address(this)) - initialBalance;

        address lpPairAddress; // Variable to store LP pair address
        uint256 lpTokenAmount = (receivedAmount * lpPercentage) / 100; // Calculate LP token amount based on percentage

        // Use the burntSupplyPercentage variable in the calculation
        //uint256 maxLiquidityProvision = (receivedAmount * burntSupplyPercentage) / 100;

        if (createLP && lpTokenAmount > 0) {
            lpPairAddress = _createLiquidityPair(_token, lpTokenAmount);
            // Update liquidityProvisionBalance considering the maxLiquidityProvision
            //liquidityProvisionBalance[_token] += lpTokenAmount > maxLiquidityProvision ? maxLiquidityProvision : lpTokenAmount;
        }

        uint256 transferAmount = 0;
        if (!useSnapshot) {
            transferAmount = (receivedAmount * burntSupplyPercentage) / 100;
            airdropToken.safeTransfer(liquidityContractAddress, transferAmount);
        }

        uint256 remainingBalance = receivedAmount - lpTokenAmount - transferAmount;

        Airdrop storage newAirdrop = airdrops.push();
        newAirdrop.airdropToken = airdropToken;
        newAirdrop.airdropAmount = receivedAmount;
        newAirdrop.snapshotTotalStaked = totalStaked;
        newAirdrop.airdropBlockNumber = block.number;
        newAirdrop.pCCreatedLPAddress = lpPairAddress;
        newAirdrop.isExternal = false;
        newAirdrop.msgSender = msg.sender;
        newAirdrop.useSnapshot = useSnapshot;
        newAirdrop.remainingBalance = remainingBalance;

        uint256 airdropID = airdrops.length - 1;
        emit AirdropTokenReceived(_token, receivedAmount, airdropID);
    }

    /**
    * @notice Receives tokens for an external airdrop, records the airdrop details, and requires that the token is whitelisted.
    * @dev This function allows the contract to accept tokens intended for an external airdrop, recording the relevant details. It ensures the token is not the staking token itself and checks that the token is on a whitelist, adding an additional layer of security by allowing only approved tokens for airdrops. Upon successful receipt, the function records the airdrop as external without creating an LP pair address, and emits an `AirdropTokenReceived` event.
    * @param _token The address of the token being airdropped. Must be a whitelisted token.
    * @param _amount The amount of tokens being airdropped.
    * @param useSnapshot A boolean indicating whether to use a snapshot for distribution calculations. This parameter allows the contract to flexibly handle different types of airdrop distributions.
    * Requires that the airdropped token is not the staking token to prevent self-airdropping.
    * Requires that the airdropped token is whitelisted, ensuring only approved tokens can be airdropped, adding a layer of control and security.
    * Calculates the actual amount received to account for any potential transfer fees or taxes imposed by the token's contract, ensuring accurate recording of the airdropped amount.
    * Records the airdrop details, including whether it's based on a snapshot of staked amounts at the time of the airdrop, and marks it as external. The absence of an LP pair address in the record indicates that this airdrop does not directly interact with liquidity pool mechanisms.
    * Emits an `AirdropTokenReceived` event with the token address, the amount received, and the unique ID of the airdrop for tracking and verification purposes.
    */
    function receiveExternalAirdropTokens(
        address _token, 
        uint256 _amount,
        bool useSnapshot
    ) public nonReentrant {
        require(_token != address(PulseCoinToken), "Staking token cannot be airdropped");
        require(whitelistedTokens[_token], "Token not whitelisted"); // Check if the token is whitelisted

        IERC20 airdropToken = IERC20(_token);
        uint256 initialBalance = airdropToken.balanceOf(address(this));
        airdropToken.safeTransferFrom(msg.sender, address(this), _amount);
        uint256 receivedAmount = airdropToken.balanceOf(address(this)) - initialBalance;

        Airdrop storage newAirdrop = airdrops.push();
        newAirdrop.airdropToken = airdropToken;
        newAirdrop.airdropAmount = receivedAmount;
        newAirdrop.snapshotTotalStaked = totalStaked;
        newAirdrop.airdropBlockNumber = block.number;
        newAirdrop.pCCreatedLPAddress = address(0); // No LP pair address
        newAirdrop.isExternal = true; // Mark as external
        newAirdrop.msgSender = msg.sender;
        newAirdrop.useSnapshot = useSnapshot;
        newAirdrop.remainingBalance = receivedAmount;

        if (!useSnapshot) {
            uint256 transferAmount = (receivedAmount * burntSupplyPercentage) / 100;
            airdropToken.safeTransfer(liquidityContractAddress, transferAmount);
        }

        uint256 airdropID = airdrops.length - 1;
        emit AirdropTokenReceived(_token, receivedAmount, airdropID);
    }


    /**
    * @notice Creates a liquidity pair for the specified token and PLS, and then adds liquidity to it with a specified token amount and PLS amount sent in the transaction.
    * @dev Approves the PulseX Router to spend the specified amount of the given token, then adds liquidity with a 5% slippage tolerance on both the token and PLS amounts. The liquidity tokens received are then burned by sending them to a predefined burn address, effectively removing them from circulation. This function emits a `LiquidityAdded` event upon successful addition of liquidity. The LP pair address is returned for reference.
    * @param _token The address of the token for which liquidity is being added alongside PLS.
    * @param _tokenAmount The amount of the specified token to add as liquidity.
    * @return lpPairAddress The address of the liquidity pool (LP) pair created between the specified token and PLS.
    * Emits a `LiquidityAdded` event indicating the amounts of the token and PLS added to liquidity, along with the liquidity amount.
    * Requires that the transaction's msg.value is the PLS amount intended for liquidity addition.
    * The function calculates minimum amounts for the token and PLS based on a 5% slippage tolerance and uses these in the liquidity addition call.
    * After adding liquidity, the function retrieves the LP pair address and burns the received liquidity tokens by transferring them to the burn address.
    */
    function _createLiquidityPair(address _token, uint256 _tokenAmount) private returns (address) {
        IERC20(_token).approve(pulseXRouterAddress, _tokenAmount);

        // Calculate minimum amounts with a 5% slippage tolerance
        uint256 amountTokenMin = _tokenAmount * 95 / 100; // 5% less than the desired amount
        uint256 amountETHMin = msg.value * 95 / 100; // 5% less than the provided ETH (PLS) amount

        // Add liquidity using PLS and the airdropped token
        (uint amountToken, uint amountETH, uint liquidity) = pulseXRouter.addLiquidityETH{value: msg.value}(
            _token,
            _tokenAmount,
            amountTokenMin,
            amountETHMin,
            address(this),
            block.timestamp
        );

        emit LiquidityAdded(amountToken, amountETH, liquidity);

        // Retrieve LP pair address using the factory and the getPair method
        address lpPairAddress = IPulseXFactory(pulseXRouter.factory()).getPair(_token, pulseXRouter.WPLS());

        // Burn the LP tokens by safely transferring them to the burn address
        IERC20(lpPairAddress).safeTransfer(burnAddress, liquidity);
        emit LPTokensBurned(lpPairAddress, liquidity, burnAddress);

        return lpPairAddress; // Return the LP pair address
    }



    /**
    * @notice Claims the specified airdrop amount for the caller, with options to skip vesting for a fee and to direct the airdrop to a different receiver address.
    * @dev Allows a user with an active stake and who is eligible for the airdrop to claim their share. The claim calculation differs based on whether the airdrop uses snapshot data (`useSnapshot` flag). If `skipVesting` is true, a fee is charged and immediately burned to allow immediate access to the airdrop tokens without waiting for vesting. Emits a `Claimed` event upon successful claim.
    * @param _airdropID The ID of the airdrop being claimed.
    * @param skipVesting A boolean indicating whether the caller wishes to skip the vesting period for an additional fee.
    * @param _receiver The address that will receive the airdropped tokens. If set to the zero address, the tokens are sent to the caller.
    * Requires:
    * - `_airdropID` must be valid and correspond to an existing airdrop.
    * - The caller must have an active stake at the time of the airdrop distribution if not using a snapshot, or at the airdrop block number if using a snapshot.
    * - The claim must be made within the claim period defined by `CLAIM_PERIOD_IN_BLOCKS` from the airdrop's block number.
    * - The airdrop must not have been previously claimed by the caller.
    * - If `skipVesting` is true, the fee transfer must be successful, and the fee is burned.
    * - If `skipVesting` is false, the caller's vesting period must be complete.
    * 
    * The function calculates the user's share of the airdrop in two ways:
    * - If `useSnapshot` is false, it uses the user's current stake relative to the total PulseCoin token supply.
    * - If `useSnapshot` is true, it calculates the share based on the user's stake at the airdrop's block number relative to the snapshot total staked.
    * 
    * The calculated share must be non-zero. Marks the airdrop as claimed for the caller to prevent duplicate claims and transfers the calculated share to the specified receiver address, or to the caller's address if no receiver is specified.
    */
    function claimAirdrop(uint256 _airdropID, bool skipVesting, address _receiver) public nonReentrant {
        require(_airdropID < airdrops.length, "Invalid airdrop ID");
        require(msg.sender != address(0), "Claim from the zero address");
        Airdrop storage airdrop = airdrops[_airdropID];
        Stake storage userStake = stakes[msg.sender];

        require(block.number <= airdrop.airdropBlockNumber + CLAIM_PERIOD_IN_BLOCKS, "Claim period has ended");
        require(userStake.amount > 0, "No active stake");
        require(!airdrop.claimed[msg.sender], "Airdrop already claimed");
        require(airdrop.airdropAmount > 0, "Invalid airdrop amount");

        if (skipVesting) {
            uint256 fee = calculateSkipFee(msg.sender);
            require(PulseCoinToken.transferFrom(msg.sender, address(this), fee), "Fee transfer failed");
            burn(fee);
        } else {
            (bool vestingComplete, ) = isVestingComplete(msg.sender, _airdropID);
            require(vestingComplete, "Vesting not complete");
        }

        uint256 userShare;
        if (airdrop.useSnapshot) {
            // Calculate share based on the snapshot
            uint256 userStakeAtSnapshot = getUserStakeAtBlock(msg.sender, airdrop.airdropBlockNumber);
            require(userStakeAtSnapshot > 0, "No stake at snapshot");
            userShare = (airdrop.airdropAmount * userStakeAtSnapshot) / airdrop.snapshotTotalStaked;
        } else {
            // Use existing logic for share calculation
            userShare = (airdrop.airdropAmount * userStake.amount) / PulseCoin_TOTAL_SUPPLY;
        }

        require(userShare > 0, "User share is zero");
        airdrop.claimed[msg.sender] = true;
        airdrop.remainingBalance -= userShare; // Updates remainingBalance

        address receiver = _receiver == address(0) ? msg.sender : _receiver;
        SafeERC20.safeTransfer(airdrop.airdropToken, receiver, userShare);

        emit Claimed(msg.sender, _airdropID);
    }

    /**
    * @dev Calculates the total amount staked by a user up to a specific block number,
    * based on the detailed stake records. This function iterates through all stake
    * actions recorded in `StakeDetail` for the given user, summing up the amounts of
    * those that were active (not yet unstaked) at or before the specified block number.
    * It ensures that the sum of detailed stake records does not exceed the total stake
    * amount recorded in the aggregated `Stake` struct for the user, maintaining data
    * consistency within the contract.
    *
    * @notice This function is used internally to determine a user's staked amount at a
    * specific block, primarily for snapshot-based calculations such as airdrop distributions.
    *
    * @param user The address of the user whose stake is being queried.
    * @param blockNumber The block number at which to calculate the user's total stake.
    * The calculation includes all stakes active at or before this block.
    *
    * @return stakeAmountFromDetails The total amount staked by the user at the specified
    * block number, according to detailed `StakeDetail` records. If no stakes are active
    * or if the user has no stakes, this will be 0.
    *
    * Requirements:
    * - The function only includes stakes that were active (not unstaked) at or before
    *   the specified block number.
    * - The sum of detailed stakes must not exceed the user's total stake amount as
    *   recorded in the master `Stake` struct, ensuring consistency between detailed
    *   records and aggregated stake data.
    */
    function getUserStakeAtBlock(address user, uint256 blockNumber) private view returns (uint256) {
        uint256 stakeAmountFromDetails = 0;
        for (uint256 i = 0; i < userStakeIDs[user].length; i++) {
            StakeDetail storage detail = stakeDetails[userStakeIDs[user][i]];
            if (detail.stakeBlockNumber <= blockNumber && detail.isActive) {
                stakeAmountFromDetails += detail.amount;
            }
        }

        // Ensure the calculated amount does not exceed the "master" stake amount.
        require(stakes[user].amount >= stakeAmountFromDetails, "Stake details exceed total stake");

        return stakeAmountFromDetails;
    }




    /**
    * @notice Checks whether a specific airdrop has been claimed by a given user address.
    * @dev Retrieves the airdrop identified by `_airdropID` and checks the `claimed` mapping for the given `_user` address. This function ensures that only valid airdrop IDs are queried by requiring that the `_airdropID` is less than the total number of airdrops.
    * @param _user The address of the user to check for airdrop claim status.
    * @param _airdropID The ID of the airdrop to check for claim status.
    * @return claimedStatus True if the airdrop has been claimed by the given user, false otherwise.
    * Requires that the provided `_airdropID` corresponds to an existing airdrop.
    */
    function isAirdropClaimed(address _user, uint256 _airdropID) public view returns (bool claimedStatus) {
        require(_airdropID < airdrops.length, "Invalid airdrop ID");
        
        Airdrop storage airdrop = airdrops[_airdropID];
        return airdrop.claimed[_user];
    }


    /**
    * @notice Redistributes unclaimed tokens from a specified airdrop after the claim period has ended.
    * @dev After the claim period for an airdrop has ended, this function is called to redistribute unclaimed tokens. It rewards the caller for triggering the redistribution, supports designated beneficiaries, enhances liquidity by sending a portion to a liquidity contract, and burns the remaining tokens.
    * @param _airdropID The ID of the airdrop whose unclaimed tokens are to be redistributed.
    * Requires:
    * - The claim period for the specified airdrop must have concluded.
    * - The airdrop must not have been previously redistributed.
    * 
    * The function executes the following steps:
    * 1. Calculates and caps the caller's reward based on the average stake.
    * 2. Transfers the calculated reward to the caller.
    * 3. Allocates and transfers a specified percentage of the remaining unclaimed amount to the beneficiary address.
    * 4. Allocates and transfers another portion for liquidity purposes to the liquidity contract address.
    * 5. Burns any tokens still remaining after these distributions by transferring them to the burn address.
    * 
    * Marks the airdrop as redistributed to prevent duplicate redistribution actions.
    */
    function redistributeAirdrop(uint256 _airdropID) public nonReentrant {
        Airdrop storage airdrop = airdrops[_airdropID];
        uint256 claimPeriodEndBlock = airdrop.airdropBlockNumber + CLAIM_PERIOD_IN_BLOCKS;
        require(block.number >= claimPeriodEndBlock, "Claim period not over");
        require(!airdrop.redistributed, "Airdrop already redistributed");

        uint256 unclaimedAmount = calculateUnclaimedAmount(_airdropID);
        if (unclaimedAmount == 0) {
            airdrop.redistributed = true;
            return; // Early exit if no tokens are available for redistribution
        }

        // Calculate reward for the caller based on the average stake
        uint256 totalStakers = numberOfStakers(); // Implementation required
        uint256 averageStake = totalStaked / totalStakers;
        uint256 callerReward = (unclaimedAmount * averageStake) / PulseCoin_TOTAL_SUPPLY;
        callerReward = callerReward > unclaimedAmount ? unclaimedAmount : callerReward; // Cap caller reward

        // Transfer caller reward
        if (callerReward > 0) {
            SafeERC20.safeTransfer(airdrop.airdropToken, msg.sender, callerReward);
            unclaimedAmount -= callerReward;
        }

        // Deduct and transfer beneficiary amount
        uint256 beneficiaryAmount = (unclaimedAmount * beneficiaryPercentage) / 10000;
        if (beneficiaryAmount > 0) {
            SafeERC20.safeTransfer(airdrop.airdropToken, beneficiaryAddress, beneficiaryAmount);
            unclaimedAmount -= beneficiaryAmount;
        }

        // Deduct and account for liquidity amount
        uint256 liquidityAmount = (unclaimedAmount * liquidityPercentage) / 100;
        if (liquidityAmount > 0) {
            SafeERC20.safeTransfer(airdrop.airdropToken, liquidityContractAddress, liquidityAmount);
            unclaimedAmount -= liquidityAmount;
        }

        // Burn the remaining unclaimed amount
        if (unclaimedAmount > 0) {
            SafeERC20.safeTransfer(airdrop.airdropToken, burnAddress, unclaimedAmount);
        }

        airdrop.redistributed = true;
    }


    /**
    * @notice Calculates the unclaimed amount of tokens for a specific airdrop, accounting for external adjustments like tax tokens.
    * @dev Retrieves the airdrop details using the provided _airdropID and calculates the unclaimed amount based on the lower of the recorded remainingBalance and the actual token balance in the contract. This accounts for scenarios where external factors like tax tokens may affect the balance.
    * @param _airdropID The ID of the airdrop for which to calculate the unclaimed amount.
    * @return The amount of tokens from the specified airdrop that have not been claimed, adjusted for actual token balances.
    */
    function calculateUnclaimedAmount(uint256 _airdropID) public view returns (uint256) {
        require(_airdropID < airdrops.length, "Invalid airdrop ID"); // Ensures valid airdrop ID

        Airdrop storage airdrop = airdrops[_airdropID];

        // Get the actual current balance of the airdrop token in the contract
        uint256 actualBalance = airdrop.airdropToken.balanceOf(address(this));

        // Use the lesser of the stored remainingBalance or the actual balance to account for discrepancies
        uint256 unclaimedAmount = airdrop.remainingBalance < actualBalance ? airdrop.remainingBalance : actualBalance;

        return unclaimedAmount;
    }


    /**
    * @notice Retrieves the IDs of all airdrops associated with a given token address.
    * @dev Iterates through all airdrops to find those matching the specified token address and compiles their IDs into an array.
    * @param _token The address of the token for which to find associated airdrop IDs.
    * @return airdropIDs An array of airdrop IDs for the given token.
    */
    function getAirdropsForToken(address _token) public view returns (uint256[] memory) {
        uint256 count = 0;
        for (uint256 i = 0; i < airdrops.length; i++) {
            if (address(airdrops[i].airdropToken) == _token) {
                count++;
            }
        }

        uint256[] memory airdropIDs = new uint256[](count);
        uint256 index = 0;
        for (uint256 i = 0; i < airdrops.length; i++) {
            if (address(airdrops[i].airdropToken) == _token) {
                airdropIDs[index] = i;
                index++;
            }
        }
        return airdropIDs;
    }

    // Function to get all stake IDs for a given user address
    function getUserStakeIDs(address _user) public view returns (uint256[] memory) {
        return userStakeIDs[_user];
    }


    /**
    * @notice Burns a specified amount of PulseCoinToken by sending it to a burn address.
    * @dev Transfers the specified amount of PulseCoinToken to a predefined burn address. Used to permanently remove tokens from circulation.
    * @param _amount The amount of PulseCoinToken to burn.
    * Requires the transfer to the burn address to succeed.
    */
    function burn(uint256 _amount) private {
        require(PulseCoinToken.transfer(burnAddress, _amount), "Burn transfer failed");
    }

}