Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";

contract XBrainToken is ERC20 {
    using SafeMath for uint256;
    using SafeERC20 for ERC20;

    // Constants for initial release percentages
    uint256 private constant FOUNDATION_INITIAL_RELEASE_PERCENT     = 5;
    uint256 private constant TECHNICAL_TEAM_INITIAL_RELEASE_PERCENT = 15;
    uint256 private constant EARLY_DONATION_INITIAL_RELEASE_PERCENT = 10;
    uint256 private constant INTERACTION_INITIAL_RELEASE_PERCENT    = 70;

    uint256 private constant FOUNDATION_FIRST_RELEASE_PERCENT        = 1;
    uint256 private constant TECHNICAL_FIRST_MONTHLY_RELEASE_PERCENT = 1;
    uint256 private constant EARLY_DONATION_FIRST_RELEASE_PERCENT    = 10;

    uint256 public constant MAX_SUPPLY = 10**10 * 10** 6; // 10 billion tokens
    
    uint256 private totalMintedTokens; //total minted tokens

    address private foundationAccount = 0x44e697d38f7F651A8Ee675Ba6d06160058353A87;
    address private technicalAccount = 0xE18B4AADe39E9fBc67BD42F133a5566E952fd789;
    address private earlyDonationAccount = 0x03d6Db0aC2df38Ca98CAA508559Cc0A53E139b45;
    address private interactionAccount = 0xAD6f57bB8636CC1A961D93Bf076639d49AEC1134;

    // Define the structure for vesting information
    struct VestingSchedule {
        uint256 totalAmount;
        uint256 initialAmount;
        uint256 amountReleased;
        uint256 releaseStart;
        uint256 releaseEnd;
        uint256 cycleRelease;
    }

    enum Role {
        Foundation,
        TechnicalTeam,
        EarlyDonator,
        InteractionTeam
    }

    mapping(address => VestingSchedule) public vestingSchedules;
    mapping(address => Role) public userRoles;

    event TokensVested(address indexed beneficiary, uint256 amount);

    constructor() ERC20("XBrain Coin", "XBrain") {

       _setupVestingBasedOnRole(Role.Foundation, foundationAccount);
       _setupVestingBasedOnRole(Role.TechnicalTeam, technicalAccount);
       _setupVestingBasedOnRole(Role.EarlyDonator, earlyDonationAccount);
       _setupVestingBasedOnRole(Role.InteractionTeam, interactionAccount);
    }

    function decimals() public view virtual override returns (uint8) {
        return 6;
    }

    function setupVesting(
        address beneficiary,
        uint256 totalAmount,
        uint256 initialAmount,
        uint256 releaseStart,
        uint256 releaseEnd,
        uint256 cycleRelease
    ) internal {
        require(
            vestingSchedules[beneficiary].totalAmount == 0,
            "Vesting already setup"
        );

        vestingSchedules[beneficiary] = VestingSchedule({
            totalAmount: totalAmount,
            initialAmount: initialAmount,
            amountReleased: 0,
            releaseStart: releaseStart,
            releaseEnd: releaseEnd,
            cycleRelease: cycleRelease
        });
    }

    function _setupVestingBasedOnRole(
        Role role,
        address beneficiary
    ) internal {
        uint256 releaseStart = block.timestamp; 
        uint256 releaseEnd;
        uint256 initialAmount;
        uint256 cycleRelease;
        uint256 totalAmount;

        if (role == Role.EarlyDonator) {
            releaseStart  = 1722441600;
            releaseEnd    = releaseStart + 18 * 30 days; 
            totalAmount   = MAX_SUPPLY.mul(EARLY_DONATION_INITIAL_RELEASE_PERCENT).div(100);
            initialAmount = totalAmount.mul(EARLY_DONATION_FIRST_RELEASE_PERCENT).div(100);
            cycleRelease  = totalAmount.sub(initialAmount).div(18);
            userRoles[beneficiary] = Role.EarlyDonator;

         } else if (role == Role.TechnicalTeam) {
            releaseStart  = 1767196800;
            releaseEnd    = releaseStart + 99 * 30 days; // 99 months for the remaining 99%
            totalAmount   = MAX_SUPPLY.mul(TECHNICAL_TEAM_INITIAL_RELEASE_PERCENT).div(100);
            initialAmount = totalAmount.mul(TECHNICAL_FIRST_MONTHLY_RELEASE_PERCENT).div(100);
            cycleRelease  = totalAmount.sub(initialAmount).div(99);
            userRoles[beneficiary] = Role.TechnicalTeam;

        } else if (role == Role.Foundation) {
            releaseStart  = 1767196800;
            releaseEnd    = releaseStart + 99 * 30 days;
            totalAmount   = MAX_SUPPLY.mul(FOUNDATION_INITIAL_RELEASE_PERCENT).div(100);
            initialAmount = totalAmount.mul(FOUNDATION_FIRST_RELEASE_PERCENT).div(100);
            cycleRelease  = totalAmount.sub(initialAmount).div(99);
            userRoles[beneficiary] = Role.Foundation;

        } else if (role == Role.InteractionTeam) {
            releaseStart  = 1714665600;
            releaseEnd    = releaseStart + 24 * 365 days;
            totalAmount   = MAX_SUPPLY.mul(INTERACTION_INITIAL_RELEASE_PERCENT).div(100);
            initialAmount = totalAmount.div(24*365);
            cycleRelease  = totalAmount.div(24*365);
            userRoles[beneficiary] = Role.InteractionTeam;

        } else {
            revert("Invalid role");
        }
        setupVesting(
                beneficiary,
                totalAmount,
                initialAmount,
                releaseStart,
                releaseEnd,
                cycleRelease
            );
    }

    function getClaimableTokens(address user, uint256 time) private view returns (uint256) { 
        VestingSchedule storage schedule = vestingSchedules[user]; 
        if (time < schedule.releaseStart) { 
            return 0; 
        } 
        if (time > schedule.releaseEnd) {  
            return schedule.totalAmount.sub(schedule.amountReleased); 
        } 
 
        uint256 timeElapsed = time - schedule.releaseStart; 
        Role role = userRoles[user]; 
        uint256 interval = timeElapsed / 30 days; 
        if (role == Role.InteractionTeam) { 
            interval = timeElapsed / 24 hours; 
        } 
         
        uint256 totalReleasable = (schedule.cycleRelease * interval).add(schedule.initialAmount).sub(schedule.amountReleased); 
        uint256 claimableAmount = schedule.totalAmount.sub(schedule.amountReleased); 
        if (totalReleasable > claimableAmount) { 
            totalReleasable = claimableAmount; 
        } 
        return totalReleasable; 
    }

    function claimVestedTokens(address beneficiary) public {
        require(
            vestingSchedules[beneficiary].totalAmount > 0,
            "No vesting schedule found"
        );
       
        uint256 claimableAmount = getClaimableTokens(beneficiary, block.timestamp);
        require(claimableAmount > 0, "No tokens available for claim");

        // Update the amount released in the vesting schedule
        vestingSchedules[beneficiary].amountReleased += claimableAmount;

        // Mint the claimable amount to the user
        mintTokens(beneficiary, claimableAmount);

        emit TokensVested(beneficiary, claimableAmount);
    }

    /**
     * @dev Internal function to calculate and update the total minted tokens.
     * Ensures the total minted tokens do not exceed the max supply.
     */
    function mintTokens(address account, uint256 amount) internal {
        require(
            totalMintedTokens.add(amount) <= MAX_SUPPLY,
            "Max supply exceeded"
        );
        _mint(account, amount);
        totalMintedTokens = totalMintedTokens.add(amount);
    }
}

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

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

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC-20 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 {
    /**
     * @dev An operation with an ERC-20 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 Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {
        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {
        return _callOptionalReturnBool(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.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    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.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    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.
     *
     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
     * only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
     * set here.
     */
    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 Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            safeTransfer(token, to, value);
        } else if (!token.transferAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferFromAndCallRelaxed(
        IERC1363 token,
        address from,
        address to,
        uint256 value,
        bytes memory data
    ) internal {
        if (to.code.length == 0) {
            safeTransferFrom(token, from, to, value);
        } else if (!token.transferFromAndCall(from, to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
     * once without retrying, and relies on the returned value to be true.
     *
     * Reverts if the returned value is other than `true`.
     */
    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            forceApprove(token, to, value);
        } else if (!token.approveAndCall(to, value, data)) {
            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 {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            // bubble errors
            if iszero(success) {
                let ptr := mload(0x40)
                returndatacopy(ptr, 0, returndatasize())
                revert(ptr, returndatasize())
            }
            returnSize := returndatasize()
            returnValue := mload(0)
        }

        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
            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 silently catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            returnSize := returndatasize()
            returnValue := mload(0)
        }
        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
    }
}

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

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC-20
 * applications.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * Both values are immutable: they can only be set once during construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /// @inheritdoc IERC20
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /// @inheritdoc IERC20
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /// @inheritdoc IERC20
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Skips emitting an {Approval} event indicating an allowance update. This is not
     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner`'s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     *
     * ```solidity
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner`'s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance < type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)

pragma solidity >=0.6.2;

import {IERC20} from "./IERC20.sol";
import {IERC165} from "./IERC165.sol";

/**
 * @title IERC1363
 * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
 *
 * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
 * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
 */
interface IERC1363 is IERC20, IERC165 {
    /*
     * Note: the ERC-165 identifier for this interface is 0xb0202a11.
     * 0xb0202a11 ===
     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
     */

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @param data Additional data with no specified format, sent in call to `spender`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)

pragma solidity >=0.4.16;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/draft-IERC6093.sol)
pragma solidity >=0.8.4;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity >=0.6.2;

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)

pragma solidity >=0.4.16;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)

pragma solidity >=0.4.16;

import {IERC20} from "../token/ERC20/IERC20.sol";

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

pragma solidity >=0.4.16;

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

{
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "remappings": []
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensVested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"}],"name":"claimVestedTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userRoles","outputs":[{"internalType":"enum XBrainToken.Role","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"vestingSchedules","outputs":[{"internalType":"uint256","name":"totalAmount","type":"uint256"},{"internalType":"uint256","name":"initialAmount","type":"uint256"},{"internalType":"uint256","name":"amountReleased","type":"uint256"},{"internalType":"uint256","name":"releaseStart","type":"uint256"},{"internalType":"uint256","name":"releaseEnd","type":"uint256"},{"internalType":"uint256","name":"cycleRelease","type":"uint256"}],"stateMutability":"view","type":"function"}]

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