Token

Overview

Netword tokens with a WORD symbol will mainly be created on the Binance Smart Chain (BEP20). For enhanced performance, some of them are offered on other networks. Their max supply is 21 billion. Tokens are initially locked and fully unlocked in 4 years.

The platform only accepts WORD tokens to do various tasks. It also employs staking mechanisms to ensure the stability and security of its token price in the market.

An attempt was made to explain all the connections of the token to the platform simply in the diagram below.

$WORD Token Network connections diagram

Use Cases

$WORD tokens have various uses in the Netword ecosystem. This token is designed to be a versatile utility token that can facilitate transactions, incentivize users, and finance the development of services. Netword's diverse applications aim to make it a reliable AI and NFT cryptocurrency.

Current items that accept the WORD token:

• Hiring for editing and proofreading by using Proofreader's pool.

• Get GPU sharing profit.

• Buy and sell Netword exclusive NFTs.

• AI translation products (Content translation, Document translation, API translation, CMS translation, Podcast translation, Meeting translation)

You may find more information in this link.

Token Allocation

The distribution of Netword tokens (21,000,000,000 WORD) is as follows:

Seed Invest	3% 630,000,000	252,000,000 (40%) will be unlocked at ICO, 378,000,000 (60%) will be unlocked next 2 months.
Advisors & Legal	5% 1,050,000,000	52,500,000(5%) will be unlocked every month after ICO.
Private Sale	7% 1,470,000,000	73,500,000(5%) will be unlocked every month after ICO.
Reserve	10% 2,100,000,000	Initial locked for 28 months after ICO 105,000,000(5%) will be unlocked monthly until 20 months.
Wrapped	10% 2,100,000,000	Initial locked for 12 months after ICO, Then 105,000,000(5%) will be unlocked every month until 20 months.
Marketing & Community	15% 3.150.000.000	78,750,000(2.5%) will be unlocked monthly until 40 months after ICO.
Operation Team	15% 3.150.000.000	Initial locked for 5 months, Then 126,000,000(4%) will be unlocked monthly until 25 months.
Ecosystem	35% 7.350.000.000	Initial locked for 8 months after ICO, Then 183,750,000(2.5%) will be unlocked monthly until 40 months.

To access the token allocation live chart, please follow this link. This allows you to switch the figures to display them in the mode for public sales.

Vesting

The chart below shows that tokens are vested over a four-year timeline. It's crucial to clarify that unlocking these tokens doesn't automatically inject them into the circulating supply. Instead, they are allocated as needed.

$WORD Token Vesting Over Time

To access the token vesting live chart, please follow this link. This allows you to switch the figures to display them in the mode for public sales.

Contract Capabilities

Transfer, TransferFrom, Approval & Allowance

These functions transfer tokens between different addresses, which are widely adopted standards for fungible tokens on the Ethereum network.

• Transfer: This function transfers tokens from one wallet to another. When this function is executed, the tokens are permanently moved from the sender's wallet to the recipient's wallet.

• Approval: This function grants permission to a third party to transfer tokens on behalf of the token holder. When executing this function, the token holder approves a specific address to transfer a certain amount of tokens.

• Allowance: This function checks the amount of tokens that a third-party address is approved to transfer on behalf of the token holder. It returns the remaining tokens that the approved address can still transfer.

• Transfer From: This function transfers tokens on the token holder's behalf. To use this function, the token holder must first approve a specific address to transfer a certain amount of tokens through the approve function. Once approved, the approved address can call transferFrom to transfer tokens from the token holder's address to another address.

Add, Remove & Modify Owner

Since a decentralized application (dApp) must have ownership access for authentication purposes, Netword products must be network owners to perform their tasks.

To achieve this, we need to enter the private key of the network owner into products. This means that if, for any security issue, one of the products is hacked, the hacker can become the network owner and cause many problems.

The solution to this problem is to create a temporary owner. By doing this, if someone gains access to the owner's information, they will only have a few minutes to do any damage before the owner is replaced. We have added these functions to the token to increase the network's security and dApp.

Stake and Unstake

Staking will be a crucial element of the ecosystem, and we encourage users to participate actively in the program and get profit through staking.

This structure incentivizes the holding of the word tokens. It ensures the sustainability of the Netword network while providing a fair and transparent system for accessing our platform infrastructure and services.

Staking in the Netword network means the number of WORD tokens left in your wallet during the past 24 hours (real-time calculation).

One-tenth of this number is an equal free amount of credit you can use for products or be zero-fee in the freelancing platform. Unused daily free credit cannot be accumulated for the following days. Also, you cannot withdraw this free credit as a WORD token.

Lock and Unlock

To control the circulation tokens, the ability to lock tokens with a timestamp has been implemented so that the tokens are released for use in the cycle over time.

This function is designed so that even the network owner cannot unlock the tokens before reaching the time lock. Additionally, through a public function, anyone can call the treasury wallet addresses and find out when the token lock period ends.

The tokens will not be automatically unlocked when the time lock period expires. The tokens will only become eligible for unlocking. If the network conditions at the time of unlocking do not require the introduction of new tokens into the cycle and releasing the locked tokens would have a negative impact, the tokens will remain locked even after the expiration of the time lock period.

Contract source code

The source code has been deployed on the BSC Testnet, and the netword platform is under development using it.

Until the token is not published on the Mainnet, You can suggest an improvement on this form: https://netword.ai/forms/suggest

Payment is made for accepted proposals.

netword.sol

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