AFTToken Contract

Here you can find all information about the AFT ERC20 Token contract.

AFT.sol

This contract is deployed on Polygon at the following address:

0x32f3Dff5c06D7e0d83F8dd88De9D33E959C5a1e1

This token contract includes the ERC20 standard

AFT.sol

/**
 *Submitted for verification at polygonscan.com on 2022-11-15
*/
//SPDX-License-Identifier:MIT

pragma solidity ^0.8.13;

//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// LIBRARIES
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// SAFEMATH its a Openzeppelin Lib. Check out for more info @ https://docs.openzeppelin.com/contracts/2.x/api/math
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // 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 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// INTERFACES
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// IAFTCONTROLLER
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
interface IAFTController {
    function _checkWLSC(address root, address client)
        external
        view
        returns (bool);

    function _getDaoExchange() external view returns (address);

    function _getDaoYield() external view returns (address);

    function _getDaoReserveERC20() external view returns (address);
}

//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// IDAOYIELD
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
interface IDaoYield {
    function _trackingBlocker() external view returns (uint256);
}

//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
/// @title AFT.sol
/// @author Fernando Viktor Seidl E-mail: [e-mail]
/// @notice ERC20 Token Standard Contract with special extensions in the "_transfer" functionality for the Governance *** AFT ERC20 TOKEN ***
/// @dev This ERC20 contract includes all functionalities of an ERC20 standard. The only difference to the standard are the built-in
///            extensions in the _transfer function.
///            TOKEN DETAILS:
///            -    Inicial total supply 0 AFT
///            -    Final total supply 1,000,000 AFT
///            -    Token Decimals 0
///            -    Token uniqueness _NumOnToken
///            -    Token Name: Arthena
///            -    Token Symbol: AFT
///
///            TOKEN USE CASE:
///            -    The principal application of the AFT token is the creation of value and Governance.
///            -    The token can be viewed as an auto-generating yield token with a Governance voting implementation, the AFT receives a share
///                 of the overall projects income and has a 60% voting power on Governance.
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
contract AFT {
    //include SafeMath
    using SafeMath for uint256;
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    STANDARD ERC20 MAPPINGS:
    _balances(owner address, aft amount) ONLY 1 AFT ALLOWED ON ADDRESS
    _allowances(owner address, spender address, AFT amount)
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    mapping(address => uint256) public _balances;
    mapping(address => mapping(address => uint256)) public _allowances;
    mapping(address => uint256) private _BonusTracker;
    mapping(address => uint256) public _CoinIndex;
    mapping(uint256 => uint256) public _OTMap;
    mapping(address => mapping(uint256 => uint256)) public _NumOnToken;
    mapping(uint256 => address[]) public AFTTracker;
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    CONTRACT EVENTS
    STANDARD ERC20 EVENTS:
    Transfer(sender, receiver, amount);
    Approval(owner, spender, amount);
    SPECIAL EVENT:
    Mint(sender, receiver, BurningFee, Timestamp
    );
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    ERC20 STANDARD ATTRIBUTES
    _TokenName           => Name of the Token (Nftismus)
    _TokenSymbol         => Symbol of the Token (NFM)
    _TokenDecimals      =>  Precision of the Token (18 Decimals)
    _TotalSupply            =>  Total Amount of Tokens (Inicial 400 Million NFM)
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    string private _TokenName;
    string private _TokenSymbol;
    uint256 private _TokenDecimals;
    uint256 private _TotalSupply;
    uint256 private _TIndexer;
    uint256 public _OTRefCounter;
    /*
    CONTROLLER
    OWNER = MSG.SENDER ownership will be handed over to dao
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    address private _Owner;
    IAFTController public _Controller;
    address private _SController;

    constructor(
        string memory TokenName,
        string memory TokenSymbol,
        address Controller
    ) {
        _TokenName = TokenName;
        _TokenSymbol = TokenSymbol;
        _TokenDecimals = 0;
        _TotalSupply = 0;
        _balances[address(this)] = 0;
        _TIndexer = 0;
        _Owner = msg.sender;
        _SController = Controller;
        IAFTController Cont = IAFTController(address(Controller));
        _Controller = Cont;
        emit Transfer(address(0), address(this), 0);
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @name() returns (string);
    Strandard ERC20 Function
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function name() public view returns (string memory) {
        return _TokenName;
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @symbol() returns (string);
    Strandard ERC20 Function
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function symbol() public view returns (string memory) {
        return _TokenSymbol;
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @decimals() returns (uint256);
    Strandard ERC20 Function
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function decimals() public view returns (uint256) {
        return _TokenDecimals;
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @totalSupply() returns (uint256);
    Strandard ERC20 Function
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function totalSupply() public view returns (uint256) {
        return _TotalSupply;
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @balanceOf(address account) returns (uint256);
    Strandard ERC20 Function
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    function correctOTFCounterRef(
        bool plusmin,
        uint256 index,
        uint256 refId
    ) public returns (bool) {
        require(
            _Controller._checkWLSC(_SController, msg.sender) == true ||
                msg.sender == _Owner,
            "oO"
        );
        if (plusmin == true) {
            _OTRefCounter++;
        } else {
            _OTRefCounter--;
        }
        _OTMap[index] = refId;
        return true;
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @bonusCheck(address account) returns (uint256);
    Special Function for Bonus Extension
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function bonusCheck(address account) public view returns (uint256) {
        return _BonusTracker[account];
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @_returnTokenReference(address account) returns (uint256, uint256);
    Special Function for Bonus Extension
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function _returnTokenReference(address account)
        public
        view
        returns (uint256, uint256)
    {
        return (_CoinIndex[account], _NumOnToken[account][_CoinIndex[account]]);
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @allowance(address owner, address spender) returns (uint256);
    Strandard ERC20 Function
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function allowance(address owner, address spender)
        public
        view
        returns (uint256)
    {
        return _allowances[owner][spender];
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @transfer(address to, uint256 amount)  returns (bool);
    Strandard ERC20 Function 
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function transfer(address to, uint256 amount) public returns (bool) {
        address owner = msg.sender;
        _transfer(owner, to, amount);
        return true;
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @transferFrom(address from, address to, uint256 amount)   returns (bool);
    Strandard ERC20 Function
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public returns (bool) {
        address spender = msg.sender;
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @_transfer(address from, address to, uint256 amount)  returns (bool);
    Strandard ERC20 Function with implemented Extensions and ReentrancyGuard as safety mechanism
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "0A");
        require(to != address(0), "0A");
        uint256 fromBalance = _balances[from];
        require(fromBalance > 0, "<B");
        //Check if Receiver is Contract
        if (to == address(_Controller._getDaoReserveERC20())) {
            uint256 CInd = _CoinIndex[from];
            uint256 RNum = _NumOnToken[from][CInd];
            unchecked {
                _balances[from] = SafeMath.sub(fromBalance, amount);
                _NumOnToken[from][CInd] = 0;
                _CoinIndex[from] = 0;
            }
            if (
                block.timestamp <
                IDaoYield(address(_Controller._getDaoYield()))
                    ._trackingBlocker()
            ) {
                _BonusTracker[to] = _balances[to] + amount;
                _BonusTracker[from] = _balances[from];
            }
            _balances[to] += amount;
            _OTRefCounter++;
            _OTMap[_OTRefCounter] = RNum;
            AFTTracker[RNum].push(to);
            emit Transfer(from, to, amount);
            //Check if Sender is Contract
        } else if (from == address(_Controller._getDaoReserveERC20())) {
            _TIndexer++;
            uint256 CInd = _TIndexer;
            uint256 RNum = _OTMap[_OTRefCounter];
            require(_balances[to] == 0, "EE");
            unchecked {
                _balances[from] = SafeMath.sub(fromBalance, amount);
            }
            if (
                block.timestamp <
                IDaoYield(address(_Controller._getDaoYield()))
                    ._trackingBlocker()
            ) {
                _BonusTracker[to] = _balances[to] + amount;
                _BonusTracker[from] = _balances[from];
            }
            _balances[to] += amount;
            _CoinIndex[to] = CInd;
            _NumOnToken[to][CInd] = RNum;
            AFTTracker[RNum].push(to);
            _OTRefCounter--;
            emit Transfer(from, to, amount);
            //If NO Contract in Addresses, then handle as Transfer between Wallets
        } else {
            uint256 CInd = _CoinIndex[from];
            uint256 RNum = _NumOnToken[from][CInd];
            require(_balances[to] == 0, "EE");
            unchecked {
                _balances[from] = SafeMath.sub(fromBalance, amount);
                _NumOnToken[from][CInd] = 0;
                _CoinIndex[from] = 0;
            }
            if (
                block.timestamp <
                IDaoYield(address(_Controller._getDaoYield()))
                    ._trackingBlocker()
            ) {
                _BonusTracker[to] = _balances[to] + amount;
                _BonusTracker[from] = _balances[from];
            }

            _balances[to] += amount;
            _CoinIndex[to] = CInd;
            _NumOnToken[to][CInd] = RNum;
            AFTTracker[RNum].push(to);
            emit Transfer(from, to, amount);
        }
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @_spendAllowance(address owner, address spender, uint256 amount);
    Strandard ERC20 Function
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "<A");
            unchecked {
                _approve(
                    owner,
                    spender,
                    SafeMath.sub(currentAllowance, amount)
                );
            }
        }
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @_approve(address owner, address spender, uint256 amount);
    Strandard ERC20 Function
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "0A");
        require(spender != address(0), "0A");
        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @approve(address spender, uint256 amount) return (bool);
    Strandard ERC20 Function
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function approve(address spender, uint256 amount) public returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @increaseAllowance(address spender, uint256 amount) return (bool);
    Strandard ERC20 Function
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function increaseAllowance(address spender, uint256 addedValue)
        public
        virtual
        returns (bool)
    {
        address owner = msg.sender;
        _approve(
            owner,
            spender,
            SafeMath.add(allowance(owner, spender), addedValue)
        );
        return true;
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @decreaseAllowance(address spender, uint256 amount) return (bool);
    Strandard ERC20 Function
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function decreaseAllowance(address spender, uint256 subtractedValue)
        public
        virtual
        returns (bool)
    {
        address owner = msg.sender;
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "_D");
        unchecked {
            _approve(
                owner,
                spender,
                SafeMath.sub(currentAllowance, subtractedValue)
            );
        }
        return true;
    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    /*
    @_mint(address to, uint256 amount);
    Strandard ERC20 Function has been modified for the protocol
     */
    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function _mint(address to) public returns (bool) {
        require(msg.sender != address(0), "0A");
        require(to != address(0), "0A");
        require(msg.sender == address(_Controller._getDaoExchange()), "oO");
        require(_TotalSupply + 1 <= 1000000, "TSL");
        require(_balances[to] == 0, "EE");
        _TotalSupply += 1;
        _balances[to] += 1;
        _TIndexer += 1;
        _CoinIndex[to] = _TIndexer;
        _NumOnToken[to][_CoinIndex[to]] = block.timestamp;
        AFTTracker[_NumOnToken[to][_CoinIndex[to]]].push(address(0));
        AFTTracker[_NumOnToken[to][_CoinIndex[to]]].push(to);
        _BonusTracker[to] = _balances[to];
        emit Transfer(address(0), to, 1);
        return true;
    }
}