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



// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (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() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

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



// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-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);
}

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



// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.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);
}

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



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

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/draft-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;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

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

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    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");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    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");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

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



// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.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
     * ====
     *
     * [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://diligence.consensys.net/posts/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.5.11/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 functionCall(target, data, "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");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason 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 {
            // 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);
            }
        }
    }
}

// File: @openzeppelin/contracts/utils/math/SafeMath.sol



// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: contracts/platform/access_controller/PlatformAccessController.sol



// SPDX-License-Identifier: MIT

pragma solidity 0.8.19;

import "../admin_panel/PlatformAdminPanel.sol";

/**
 * @title Abstract contract from which platform contracts with admin function are inherited
 * @dev Contains the platform admin panel
 * Contains modifier that checks whether sender is platform admin, use platform admin panel
 */
abstract contract PlatformAccessController {
    address public _panel;

    error CallerNotAdmin();
    error AlreadyInitialized();

    function _initiatePlatformAccessController(address adminPanel) internal {
        if(address(_panel) != address(0))
            revert AlreadyInitialized();

        _panel = adminPanel;
    }

    /**
     * @dev Modifier that makes function available for platform admins only
     */
    modifier onlyPlatformAdmin() {
        if(!PlatformAdminPanel(_panel).isAdmin(msgSender()))
            revert CallerNotAdmin();
        _;
    }

    function _isAdmin() internal view returns (bool) {
        return PlatformAdminPanel(_panel).isAdmin(msgSender());
    }

    function msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
}

// File: contracts/platform/admin_panel/Iplatform_admin_panel/IPlatformAdminPanel.sol



// SPDX-License-Identifier: MIT

pragma solidity 0.8.19;

interface IPlatformAdminPanel {
    function isAdmin(address wallet) external view returns (bool);
}

// File: contracts/platform/admin_panel/PlatformAdminPanel.sol



// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "./Iplatform_admin_panel/IPlatformAdminPanel.sol";

/**
 * @title Platform admins holder contract
 * @notice Used to check accessibility of senders to admin functions in platform contracts
 */
contract PlatformAdminPanel is IPlatformAdminPanel {
    /**
     * @notice Emit during root admin set and reset
     */
    event SetRootAdmin(address indexed wallet);

    event InsertAdminList(address[] adminList);

    event RemoveAdminList(address[] adminList);

    mapping(address => bool) private _adminMap;
    address private _rootAdmin;

    modifier onlyRootAdmin() {
        require(_rootAdmin == msg.sender, "sender is not root admin");
        _;
    }

    /**
     * @notice Specify the root admin, only he has the rights to add and remove admins
     */
    constructor(address rootAdminWallet) {
        _setRootAdmin(rootAdminWallet);
    }

    /**
     * @notice Needed to determine if the user has admin rights for platform contracts
     */
    function isAdmin(address wallet)
        external
        view
        virtual
        override
        returns (bool)
    {
        return wallet == _rootAdmin || _adminMap[wallet];
    }

    function rootAdmin() external view returns (address) {
        return _rootAdmin;
    }

    /**
     * @notice Only root admin can call
     */
    function insertAdminList(address[] calldata adminList)
        external
        onlyRootAdmin
    {
        require(0 < adminList.length, "empty admin list");

        uint256 index = adminList.length;
        while (0 < index) {
            --index;

            _adminMap[adminList[index]] = true;
        }

        emit InsertAdminList(adminList);
    }

    /**
     * @notice Only root admin can call
     */
    function removeAdminList(address[] calldata adminList)
        external
        onlyRootAdmin
    {
        require(0 < adminList.length, "empty admin list");

        uint256 index = adminList.length;
        while (0 < index) {
            --index;

            _adminMap[adminList[index]] = false;
        }

        emit RemoveAdminList(adminList);
    }

    /**
     * @notice Only root admin can call
     */
    function setRootAdmin(address rootAdminWallet) external onlyRootAdmin {
        _setRootAdmin(rootAdminWallet);
    }

    function _setRootAdmin(address wallet) private {
        require(wallet != address(0), "wallet is zero address");

        _rootAdmin = wallet;

        emit SetRootAdmin(wallet);
    }
}

// File: contracts/platform/token/IplatformToken/IPlatformToken.sol



// SPDX-License-Identifier: MIT

pragma solidity 0.8.19;

interface IPlatformToken {
    function specialTransferFrom(
        address from,
        uint256 value,
        uint256 validAfter,
        uint256 validBefore,
        bytes32 nonce,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
}

// File: contracts/platform/vesting/IPlatformVesting/IPlatformVesting.sol



// SPDX-License-Identifier: MIT

pragma solidity 0.8.19;

interface IPlatformVesting {
    function amountForClaim(address wallet, uint256 timestampInSeconds) external view returns (uint256 amount);
    function claim(address wallet) external;
}

// File: contracts/platform/vesting/PlatformVesting.sol



// SPDX-License-Identifier: MIT

pragma solidity 0.8.19;

import "../access_controller/PlatformAccessController.sol";
import "../token/IplatformToken/IPlatformToken.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import { SafeMath } from "@openzeppelin/contracts/utils/math/SafeMath.sol";
import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./IPlatformVesting/IPlatformVesting.sol";

/**
 * @notice Separate vesting pool, each with separate liquidity, whitelists and parameters
 */
contract PlatformVesting is PlatformAccessController, ReentrancyGuard, IPlatformVesting {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;


    event InsertVestingList(address indexed admin, uint256 vestingCount);

    /**
     * @notice Emit during vesting vesting liquidity increasing
     * Liquidity of the vesting decreases
     * @param admin Platform admin which do this action
     * @param vestingId The vesting id
     * @param amount The PROPC token amount which add to vesting free amount
     */
    event IncreaseLiquidity(
        address indexed admin,
        uint256 indexed vestingId,
        uint256 amount
    );

    /**
     * @notice Emit during vesting vesting liquidity decreasing process
     * Liquidity of the vesting increases
     * @param admin Platform admin which do this action
     * @param amount The PROPC token amount which rem from vesting free amount
     */
    event DecreaseLiquidity(
        address indexed admin,
        uint256 amount
    );

    event InsertWalletListToVesting(
        address indexed admin,
        uint256 indexed vestingId,
        address[] walletList
    );

    event RemoveWalletListFromVesting(
        address indexed admin,
        uint256 indexed vestingId,
        address[] walletList
    );

    event TGESet(
        uint256 tgeDate,
        uint256 timestamp
    );

    event UpdateTokenAddress(
        address _address,
        uint256 timestamp
    );

    event VestingRemoved(
        uint256 id,
        uint256 timestamp
    );

    event VestingAdded(
        uint256 amountForUser,
        uint256 tgeAmountForUser,
        uint256 startTime,
        uint256 tickCount,
        uint256 tickDuration,
        uint256 timestamp
    );

    /**
     * @notice Emit when user claim his PROPC from vesting
     * @param vestingId The vesting id
     * @param wallet The user wallet
     * @param amount The PROPC token amount which user save
     */
    event Claim(
        uint256 indexed vestingId,
        address indexed wallet,
        uint256 amount
    );

    struct VestingProperties {
        uint256 amountForUser;
        uint256 tgeAmountForUser;
        uint256 startTime;
        uint256 tickCount;
        uint256 tickDuration;
        uint256 unallocatedAmount;
        bool active;
    }

    struct UserProperties {
        bool isActive;
        uint256 spentAmount;
        uint256 vestingId;
        bool tgeClaimed;
    }

    error InsufficientBalance();
    error InvalidTimestamp();
    error ZeroAddress();
    error ZeroAmount();
    error OutOfBounds();
    error EmptyArray();
    error ArraySizeDoesNotMatch();
    error VestingDoesNotExist();
    error UserAlreadyActive();
    error UserNotActive();
    error NoClaimAvailable();
    error VestingAlreadyActive();
    error StartBeforeNow();
    error StartBeforeTGE();
    error TicksMissing();
    error FatalError(string message);

    struct VestingLink {
        address user;
        bool active;
    }

    uint256 private constant TOTAL_SHARE = 100_000;

    uint256 public tgeStartDate;
    address private _token;

    uint256 public _vestingCount;
    uint256 public totalRemainingAllocatedAmount;

    mapping(uint256 => VestingProperties) private _vestingMap;
    mapping(uint256 => VestingLink) private _vestingToUser;
    mapping(address => UserProperties) private _userMapping;

    modifier existingVesting(uint256 vestingId) {
        require(vestingId <= _vestingCount, "vesting does not exist");
        _;
    }

    constructor(address adminPanel) {
        if(adminPanel == address(0))
            revert ZeroAddress();
        _initiatePlatformAccessController(adminPanel);
    }

    function setTgeDate(uint256 timestamp) external onlyPlatformAdmin {
        if(timestamp < block.timestamp)
            revert InvalidTimestamp();
        tgeStartDate = timestamp;

        emit TGESet(timestamp, block.timestamp);
    }

    function updateTokenAddress(address token) external onlyPlatformAdmin {
        if(token == address(0))
            revert ZeroAddress();
        _token = token;

        emit UpdateTokenAddress(token, block.timestamp);
    }

    /**
     * @notice Get vesting pool properties list
     * vesting.amountForUser   Total PROPC amount which user can claim
     * vesting.tgeAmountForUser   PROPC amount which user can claim immediately after the `tgeStartDate`
     * vesting.startTime   The moment after that users can start claiming tick by tick
     * vesting.tickCount   The number of ticks that must pass to fully unlock funds
     * Each tick unlocks a proportional amount
     * vesting.tickDuration   Tick duration on seconds
     * vesting.unallocatedAmount PROPC that has not yet been assigned to any users
     * Grows when users are deleted and liquidity is increased by the admin
     * Falls when users are deleted and the liquidity is reduced by the admin
     */
    function vestingPropertiesList()
        external
        view
        returns (VestingProperties[] memory vestingList)
    {
        uint256 count = _vestingCount;

        vestingList = new VestingProperties[](count);

        while (0 < count) {
            --count;

            vestingList[count] = _vestingMap[count];
        }
    }

    /**
     * @notice Get properties list for the user
     * @param wallet User wallet
     * user.isActive   Indicates whether the user is on the whitelist or not
     * Admin can add or remove users.
     * user.spentAmount   Amount that was branded by the user or seized as staking fee
     */
    function userPropertiesList(address wallet)
        external
        view
        returns (UserProperties memory userProperties)
    {
        userProperties = _userMapping[wallet];
    }

    /**
     * @notice Get possible claim amount for user list for vesting pool
     * @param wallet User wallet
     * @param timestampInSeconds Time at which they plan to make claim
     */
    function amountForClaim(address wallet, uint256 timestampInSeconds)
        external
        view
        returns (uint256 amount)
    {
        UserProperties storage user = _userMapping[wallet];
        VestingProperties storage vesting = _vestingMap[user.vestingId];
        amount = _amountForClaim(
            vesting,
            user,
            timestampInSeconds
        );
    }

    /**
     * @notice Only platform admin can do
     * If 0 < vesting.unallocatedAmount amount will be transfer from sender wallet
     */
    function insertVestingList(
        VestingProperties[] calldata vestingList
    ) external onlyPlatformAdmin {
        uint256 count = _vestingCount;
        if(vestingList.length == 0)
            revert EmptyArray();

        uint256 liquidity;

        uint256 index = vestingList.length;

        while (0 < index) {
            --index;

            liquidity += _setVesting(count + index, vestingList[index]);
        }

        _vestingCount += vestingList.length;

        if (liquidity > 0) {
            totalRemainingAllocatedAmount += liquidity;
            emit InsertVestingList(msgSender(), vestingList.length);
        }
    }

    function removeVesting(uint256 vestingId) external onlyPlatformAdmin {
        if(vestingId >= _vestingCount)
            revert OutOfBounds();

        VestingProperties storage vp = _vestingMap[vestingId];
        VestingLink storage vl = _vestingToUser[vestingId];
        UserProperties storage up = _userMapping[vl.user];

        if(!vp.active)
            revert VestingDoesNotExist();

        if(vp.amountForUser < up.spentAmount)
            revert FatalError("user exceeded maximum spending amount");

        uint256 remainingPayoutAmount = vp.amountForUser - up.spentAmount;
        if(totalRemainingAllocatedAmount < remainingPayoutAmount)
            revert FatalError("less balance than allocated amount");
        totalRemainingAllocatedAmount -= remainingPayoutAmount;

        delete _userMapping[vl.user];
        delete _vestingMap[vestingId];
        delete _vestingToUser[vestingId];

        emit VestingRemoved(vestingId, block.timestamp);
    }

    /**
     * @notice Only platform admin can do
     * @param vestingId Target vesting pool id
     * @param amount Target additional liquidity amount
     * Amount will be transfer from sender wallet
     */
    function increaseLiquidity(
        uint256 vestingId,
        uint256 amount,
        uint256 validAfter,
        uint256 validBefore,
        bytes32 nonce,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external onlyPlatformAdmin existingVesting(vestingId) nonReentrant {
        if(amount == 0)
            revert ZeroAmount();

        VestingProperties storage vesting = _vestingMap[vestingId];

        address admin = msgSender();

        IPlatformToken(_token).specialTransferFrom(
            admin,
            amount,
            validAfter,
            validBefore,
            nonce,
            v,
            r,
            s
        );

        vesting.unallocatedAmount += amount;

        emit IncreaseLiquidity(admin, vestingId, amount);
    }

    /**
     * @notice Only platform admin can do
     * @param amount Target removal liquidity amount
     * Amount will be transfer to sender wallet
     */
    function decreaseLiquidity(uint256 amount)
        external
        onlyPlatformAdmin
    {
        if(amount == 0)
            revert ZeroAmount();
        uint256 availableSenderBalance = IERC20(_token).balanceOf(address(this));
        if(amount > availableSenderBalance)
            revert InsufficientBalance();

        if(totalRemainingAllocatedAmount > availableSenderBalance)
            revert FatalError("balance less than allocated amount");

        uint256 availableBalance = availableSenderBalance - totalRemainingAllocatedAmount;
        if(amount > availableBalance)
            revert InsufficientBalance();

        address admin = msgSender();
        IERC20(_token).safeTransfer(admin, amount);

        emit DecreaseLiquidity(admin, amount);
    }

    function insertWalletListToVesting(
        uint256[] calldata vestingIdList,
        address[] calldata walletList
    ) external onlyPlatformAdmin {
        if(walletList.length != vestingIdList.length)
            revert ArraySizeDoesNotMatch();
        if(walletList.length == 0)
            revert EmptyArray();

        uint256 decrease;

        uint256 index = walletList.length;
        while (0 < index) {
            --index;

            uint256 vestingId = vestingIdList[index];
            if(vestingId >= _vestingCount)
                revert VestingDoesNotExist();

            VestingProperties storage vesting = _vestingMap[vestingId];
            uint256 amountForUser = vesting.amountForUser;

            address wallet = walletList[index];
            UserProperties storage user = _userMapping[wallet];

            if(user.isActive)
                revert UserAlreadyActive();
            user.isActive = true;
            user.vestingId = vestingId;

            VestingLink storage vl = _vestingToUser[vestingId];
            if(vl.active)
                revert VestingAlreadyActive();
            vl.user = wallet;
            vl.active = true;

            decrease = amountForUser - user.spentAmount;

            uint256 oldUnallocatedAmount = vesting.unallocatedAmount;

            if(decrease > oldUnallocatedAmount)
                revert InsufficientBalance();
            vesting.unallocatedAmount = oldUnallocatedAmount - decrease;

            emit InsertWalletListToVesting(msgSender(), vestingId, walletList);
        }
    }

    function removeWalletListFromVesting(
        address[] calldata walletList
    ) external onlyPlatformAdmin {
        if(walletList.length == 0)
            revert EmptyArray();

        uint256 increasing;

        uint256 index = walletList.length;
        while (0 < index) {
            --index;

            address wallet = walletList[index];
            UserProperties storage user = _userMapping[wallet];

            uint256 vestingId = user.vestingId;
            VestingProperties storage vesting = _vestingMap[vestingId];
            uint256 amountForUser = vesting.amountForUser;

            if(!user.isActive)
                revert UserNotActive();
            user.isActive = false;
            VestingLink storage vl = _vestingToUser[vestingId];
            vl.user = address(0);
            vl.active = false;

            increasing = amountForUser - user.spentAmount;

            vesting.unallocatedAmount += increasing;
            emit RemoveWalletListFromVesting(msgSender(), vestingId, walletList);
        }
    }

    /**
     * @notice Claim possible for user amount from the pool
     * If possible amounts equal to zero will revert
     * @param wallet User wallet
     */
    function claim(address wallet) external {
        _claim(wallet);
    }

    function _claim(address wallet) private {
        UserProperties storage user = _userMapping[wallet];
        VestingProperties storage vesting = _vestingMap[user.vestingId];

        uint256 claimAmount = _amountForClaim(vesting, user, block.timestamp);
        if(claimAmount == 0)
            revert NoClaimAvailable();

        user.spentAmount += claimAmount;
        uint256 vestingId = user.vestingId;

        totalRemainingAllocatedAmount -= claimAmount;

        IERC20(_token).safeTransfer(wallet, claimAmount);

        emit Claim(vestingId, wallet, claimAmount);
    }

    /**
    * @notice allows to individually send the TGE amount to a participant
    */
    function distributeAmount(uint256 vestingId) private {
        if(vestingId >= _vestingCount)
            revert OutOfBounds();
        VestingLink memory vl = _vestingToUser[vestingId];

        if(vl.active)   {
            _claim(vl.user);
        }
    }

    /**
    * @notice allows to airdrop currently available amounts to all vesting wallets
    * @param batchSize the number of people being airdropped in this call
    * @param offset the offset to select the correct batch
    */
    function airdrop(uint256 batchSize, uint256 offset) external onlyPlatformAdmin {
        if(offset > _vestingCount)
            revert OutOfBounds();

        uint256 index = _vestingCount - offset;

        while (0 < index) {
            --index;
            if(batchSize == 0)
                return;

            distributeAmount(index);
            batchSize--;
        }
    }

    function _share(
        uint256 amount,
        uint256 share,
        uint256 total
    ) private pure returns (uint256) {
        return (amount * share) / total;
    }

    /**
     * @notice Returns the total amount claimable until the nowPoint point in time
     * @param vesting schedule to calculate amount for
     * @param user to retrieve the already spent amount
     * @param nowTime point in time to check for
     */
    function _amountForClaim(
        VestingProperties storage vesting,
        UserProperties storage user,
        uint256 nowTime
    ) private view returns (uint256) {
        uint256 startTime = vesting.startTime;

        if (!user.isActive) {
            return 0;
        }

        if (nowTime < tgeStartDate) {
            return 0;
        } else if (nowTime >= tgeStartDate && nowTime < startTime) {
            return vesting.tgeAmountForUser - user.spentAmount;
        }



        uint256 tickCount = vesting.tickCount;
        uint256 tick = (nowTime - startTime) / vesting.tickDuration + 1; // at start time, the first tick is available

        uint256 amount = vesting.tgeAmountForUser;
        uint256 rest = vesting.amountForUser - amount;
        if (tick < tickCount) {
            uint256 share = _share(TOTAL_SHARE, tick, tickCount);
            amount += _share(rest, share, TOTAL_SHARE);
        } else {
            amount += rest;
        }

        uint256 alreadyClaimed = user.spentAmount;
        if (amount <= alreadyClaimed) {
            return 0;
        }

        return amount - alreadyClaimed;
    }

    function _setVesting(uint256 vestingId, VestingProperties calldata setting)
        private
        returns (uint256 liquidity)
    {
        if(setting.tgeAmountForUser > setting.amountForUser)
            revert FatalError("tge amount greater than total amount");

        if(setting.startTime <= block.timestamp)
            revert StartBeforeNow();
        if(setting.startTime < tgeStartDate)
            revert StartBeforeTGE();

        if (setting.tgeAmountForUser < setting.amountForUser) {
            if(0 == setting.tickCount || setting.tickDuration == 0)
                revert TicksMissing();
        }

        _vestingMap[vestingId] = setting;

        liquidity = setting.unallocatedAmount;

        emit VestingAdded(
            setting.amountForUser,
            setting.tgeAmountForUser,
            setting.startTime,
            setting.tickCount,
            setting.tickDuration,
            block.timestamp
        );
    }
}