WORD Token

// SPDX-License-Identifier: MIT
/*     
*  ©©©©            ©©©©        ©©©©©©©©©©©©©©    
*  ©©©©            ©©©©        ©©©©©©©©©©©©©©    
*  ©©©©            ©©©©    ©©©©              ©©©©
*  ©©©©    ©©©©    ©©©©    ©©©©              ©©©©
*  ©©©©    ©©©©    ©©©©    ©©©©              ©©©©
*  ©©©©©©©©    ©©©©©©©©    ©©©©              ©©©©
*  ©©©©©©©©    ©©©©©©©©    ©©©©              ©©©©
*  ©©©©            ©©©©        ©©©©©©©©©©©©©©
*  ©©©©            ©©©©        ©©©©©©©©©©©©©©
*
*  ©©©©©©©©©©©©©©©©        ©©©©©©©©©©©©©©©©©©
*  ©©©©©©©©©©©©©©©©        ©©©©©©©©©©©©©©©©©©
*  ©©©©            ©©©©    ©©©©              ©©©©
*  ©©©©            ©©©©    ©©©©              ©©©©
*  ©©©©©©©©©©©©©©©©        ©©©©              ©©©©
*  ©©©©©©©©©©©©©©©©        ©©©©              ©©©©
*  ©©©©            ©©©©    ©©©©              ©©©©
*  ©©©©            ©©©©    ©©©©©©©©©©©©©©©©©©
*  ©©©©            ©©©©    ©©©©©©©©©©©©©©©©©©
*/

pragma solidity ^0.8.20;

/**
* @title Netword
* @dev The Netword AI Ecosystem Token.
* @custom:dev-run-script file_path
*/
contract Netword {
    string public constant name = "Netword";
    string public constant symbol = "WORD";
    uint8 public constant decimals = 4;
    uint256 public constant totalSupply = 21 * 10**9 * 10**uint256(decimals);

    // mapping area
    mapping(address => uint256) public lockTimestamp;
    mapping(address => uint256) public lockAmount;
    mapping(address => uint256) public stakingAmount;
    mapping(address => mapping(address => uint256)) private _allowances; 
    mapping(address => uint256) private _balances;   
    mapping(address => bool) private _isOwner;

    // event area
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);


    address[] private _owners;
    modifier onlyOwner() {
        require(_isOwner[msg.sender], "Netword: Caller is not an owner");
        _;
    }

    // constructor
    constructor() {
        _balances[msg.sender] = totalSupply;
        _owners = [msg.sender];
        _isOwner[msg.sender] = true;
        emit Transfer(address(0), msg.sender, totalSupply);
    }

    // functions area

    /**
     * @dev Returns the amount of tokens owned by `account` (Include stacked amount).
     */
    function balanceOf(address account) public view returns (uint256) {
        uint256 stacked = stakingAmount[account];
        uint256 balance = _balances[account];
        return balance + stacked;
    }

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

    /**
    * @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) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    /*
    * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
    * Returns a boolean value indicating whether the operation succeeded.
    * Emits an {Approval} event.
    */
    function approve(address _spender, uint256 _value) public returns (bool success) {
        require(_spender != address(0), "Netword: Cannot approve zero address");
        _allowances[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }

    /**
    * @dev Moves `amount` tokens from `sender` to `recipient` 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 _sender, address _recipient, uint256 _value) public returns (bool success) {
        require(_sender != address(0), "Netword: Cannot transfer from zero address");
        require(_recipient != address(0), "Netword: Cannot transfer to zero address");
        require(_balances[_sender] - _value >= stakingAmount[_sender], "Deposited tokens");
        require(_allowances[_sender][msg.sender] >= _value, "Insufficient allowance");

        _balances[_sender] -= _value;
        _balances[_recipient] += _value;
        _allowances[_sender][msg.sender] -= _value;

        emit Transfer(_sender, _recipient, _value);
        return true;
    }
     /**
     * @dev getOwners.
     */    
    function getOweners() public view returns (address[] memory) {
        return _owners;
    }

     /**
     * @dev addOwner.
     */  
    function addOwner(address newOwner) public onlyOwner {
        require(!_isOwner[newOwner], "Network: This address is already an owner");
        _isOwner[newOwner] = true;
        _owners.push(newOwner);
    }

     /**
     * @dev removeOwner.
     */  
    function removeOwner(address ownerToRemove) public onlyOwner {
        require(_owners.length > 1, "Network: Cannot remove the last owner");
        require(_isOwner[ownerToRemove], "Network: This address is not an owner");

        // Remove the owner from the owners array
        for (uint i = 1; i < _owners.length - 1; i++) {
            if (_owners[i] == ownerToRemove) {
                _owners[i] = _owners[_owners.length - 1];
                break;
            }
        }
        _owners.pop();
        _isOwner[ownerToRemove] = false;
    }

    /**
     * @dev Using staking feature on dApp.
     */
    function stake(uint256 amount) public returns (bool) { 
        require(msg.sender != address(0), "Netword: Cannot stake from zero address");
        _stake(msg.sender, address(0), amount);
        return true;
    }
    
    function unstake(uint256 amount) public returns (bool) {
        require(msg.sender != address(0), "Netword: Cannot unstake from zero address");
        _unstake(address(0), msg.sender, amount);
        return true;
    }

    /**
     * @dev Use timestamp lock to control circulating tokens.
     * Attention: Be cautious when entering the timestamp. Any owner
     * cannot change it until the time passed.
     */

     // Owner can lock `amount` tokens for `timestamp` seconds.
    function lockTokens(address account, uint256 amount, uint256 timestamp) public onlyOwner {
        require(account != address(0), "Netword: Invalid account address");
        require(amount > 0, "Netword: Amount must be greater than zero");
        require(timestamp > block.timestamp, "Netword: Timestamp must be in the future");
        
        lockAmount[account] = lockAmount[account] + amount;
        lockTimestamp[account] = timestamp;

        _transfer(account, address(this), amount);
    }

    // Owner can unlock tokens if the unlock timestamp has passed.
    function unlockTokens(address account) public onlyOwner {
        require(lockTimestamp[account] <= block.timestamp, "Netword: Tokens are still locked");

        uint256 amountToUnlock = lockAmount[account];
        lockAmount[account] = 0;
        lockTimestamp[account] = 0;

        _transfer(address(this), account, amountToUnlock);
    }

    /**
     * Contract's internal functions.
     */
    function _stake(address _sender, address _recipient, uint256 _amount) internal {
        _balances[_sender] -= _amount;
        stakingAmount[_sender] =  stakingAmount[_sender] + _amount;
        emit Transfer(_sender, _recipient,  _amount);
      
    }

    function _unstake(address _sender, address _recipient, uint256 _amount) internal {
        _balances[_recipient] += _amount;
        stakingAmount[_recipient] =  stakingAmount[_recipient] - _amount;
        emit Transfer(_sender, _recipient, _amount);
        
    }
   
   function _transfer(address _sender, address _recipient, uint256 _amount) internal {
        require( _balances[_sender]>=_amount, "Netword: The staked amount is not transferable, Unstake your tokens first");
        _balances[_sender] -= _amount;
        _balances[_recipient] += _amount;
        emit Transfer(_sender, _recipient, _amount);
    }
}

	

Note: We will pay cost for the approved proposal