contract Wellness is ERC20, ERC20Burnable, Ownable, ERC20Pausable {

    uint256 public wellnessTreasuryTokens = 12_000_000;
    address public wellnessTreasuryAddress=0x115d31069df4A47330803e1895697a5972bf478d;
    uint256 decimalFactor;
    constructor(
        string memory name,
        string memory symbol,
        uint8 decimals,
        uint256 tokenSupply
    ) ERC20(name, symbol, decimals) {
        decimalFactor = 10**uint256(decimals);
        uint256 initialSupply = tokenSupply * decimalFactor;

        _setTotalSupply(initialSupply); // 68_000_000

        //  Staking Allocation
        uint256 stakingAllocationTokens = 28_000_000; 
        _initialTransfer(
            0x486ad2eC50FC3fb5187D92A02df11D80017DB81F,
            (stakingAllocationTokens * decimalFactor)
        );
        // Wellness Treasury
        _initialTransfer(
            address(this),
            (wellnessTreasuryTokens * decimalFactor)
        );
        // Public Allocation
        uint256 publicAllocationTokens = 28_000_000;
        _initialTransfer(
            0x8Db0910A2c10b3222930024b9Cb1CAC4958590C5,
            (publicAllocationTokens * decimalFactor)
        );
    }

    function claimWellnessTreasury() external{
        require(msg.sender==wellnessTreasuryAddress,"Only wellness treasury owner can claim");
        require(block.timestamp>1704067200);
        _transfer(address(this),wellnessTreasuryAddress,wellnessTreasuryTokens*decimalFactor);
    }

    /**
     * Pause/Unpause smart contract in case of emergency
     */
    function pause() public onlyOwner returns (bool) {
        _pause();
        return true;
    }

    function unpause() public onlyOwner returns (bool) {
        _unpause();
        return true;
    }

    /**
     * Only contract owner can burn tokens
     */

    function burn(uint256 amount) public override onlyOwner {
        _burn(_msgSender(), amount);
    }

    /**
     * Mint new tokens
     */
    function mint(address account, uint256 amount)
        public
        onlyOwner
        returns (bool)
    {
        _mint(account, amount);
        return true;
    }

    // hook to execute before every token transfer
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override(ERC20, ERC20Pausable) {
        super._beforeTokenTransfer(from, to, amount);
    }
}
function burn(uint256 amount) public override onlyOwner {
    _burn(_msgSender(), amount);
}

/**
 * Only contract owner can burn tokens
 */