Token Koji

NFT  
 

Overview [ERC-20]

Price
$0.00 @ 0.000000 Eth (-7.28%)
Fully Diluted Market Cap
Max Total Supply:
1,000,000,000,000 KOJI

Holders:
3,930 (0.00%)

Transfers:
-

Loading
[ Download CSV Export  ] 
Loading
[ Download CSV Export  ] 
Loading

OVERVIEW

Koji.earth is a charity project designed around Koji, an alien superhero from another planet who rids the world of corruption. Aims to become the first to produce a full length comic NFT.

Market

Volume (24H):$1,824.24
Market Capitalization:$0.00
Circulating Supply:0.00 KOJI
Market Data Source: Coinmarketcap

# Exchange Pair Price  24H Volume % Volume
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
KojiToken

Compiler Version
v0.7.4+commit.3f05b770

Optimization Enabled:
Yes with 200 runs

Other Settings:
byzantium EvmVersion
File 1 of 6 : Kojitoken.sol
/*////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                        
                                                         `` `````                                   
                                                      ```..-:://-`                                  
                                                ````..-://+++++/.`                                  
                                             ```.-://+++++++++/-`                                   
                                           ``.-:+++oo++++++++o/.`                                   
                                        ``.:/+++++++++++++++++/``                                   
                                     ``.:/+++++++++++++++++++o/.`                                   
                               `   ``-:+++++++++++++++++++++++/-`                                   
                                 `.-:++++++++++++++++++++++++++/.`                                  
                              ``.-/++++++++++++++++++++++++++oo+-`                                  
                             `.-/++++oo+++++++++++++++++++++++o+/.`                                 
                      `    ``.:+++++o++++++++++++++++++++++++++++/.```                              
                          `.:/++++++++++++++++++++++++++++++++++++/.`                               
                         `.:++++o++++o+++++++++++++++++++++++++++++/.```                            
                         .:+++++++++++++++++++++++++++++++++++++++++:.`    `   ``.`                 
                        `:++++++++++++++++++++++++++++++++++++++++++/:.   `    `-:.`                
                       `-/+++++++++++++++++++++++++++++++++++++++++++/-`       ./+:.`               
                      `.:+++++++++++++++++++++++++++++++++++++++++++++/-`  `  `-/+/:.`              
                `     `./o+++++++++++++++++++o+++++++++++++++++++++++++:.  `  .:++++:.`             
               `.`    `./o++++++++++++++++/::/+++++++++++++++++++++++++:.``  `-/+o++/-`             
              `-:-`   `./o++++++++++++++++/:----::/++++++++++++++++++++/-`  `.:++++++/.`            
             `./+:.`   .:+++++++++++++++oo+:--------::/++++++++++++++++/-`  `:/+++++++:`            
             `:++/-`   `-++++++++++++++++++:---.--------:/+++++++++++++/-```-/++++++++/.            
             .++++/-`  `.+o+++++++++++++o+/:--------------:/++oo+++++++/.``./++++++o+++-``          
            `-+o+++/-` ``:+++++++++++++++/:-----------------:/+o+++o+++:.`./+o+++++++++:`           
            `:++++++/-```./++++++++++++++:--------------------:/+o++++/:../+o+++++++++o/.           
            `/+++o++++:```-+++++++++++++:-----------------.----:/+++++/--/o++o+++++++++/.`          
            `++++++++++/-`.:++++/+++o++:-------------------------/++++/:/++++++++++++++/.`          
            `++++++++++++/--/+/::/++o+/--------------------------:/+++++oo+++++++++++++/.           
            `++++++++++++o+///:--/+o+/----------------------------/+++++o++++++++++++++/.           
            `++++++++++++++++/---:+++/----------------------------/+++//+++++++++++++++/.           
            `/+++++++++++++++:----:::--:::------------------------/++/::/o+++++++++++++/.           
            `:++++++++++++++/------:--:---------.------------------:::--/oo+++oo++++o++:`           
            `-++++++++++++o+:-----------:-:/+ossyhddhysso+/:------------:++++++++++++++:`           
             ./++++++++++++/:---------:/syhmmdhyyyyyyyhhddmhso/----------:++o++++++++++-`           
             `:++++++++++/:---------:oyy+:+ddyooossssssssddo:ohs+:--------:/++++++++o+/.            
              ./++o+++++/:---------/sh/`` .odhsososssooshms. `.oho:---------/+o+++++++:`            
              `-+++++++/-------::::+m+`  `-smdssosssoosshmy-`` `sh/-----:----:+++++++/.`            
               .:+++o+:-------::::/om. ` `/hmyossoosssosydd/  ``+h+-::--------:+++oo/-`             
               `.:+++/-------::::::sm` `` `+ddsosoossosshdo` ` `/d+:--:--------:++++:.              
                `./+/-------::::::/sd`  `` -sdhososoossydy- `  `-do:-:::::-----:/++:.`              
                 `.::------:::::::/yh      `:ydyssoosssdh/`     -do:::::::------:/:.`               
                 ``.-------:::::::/yy    `` `/hdssososhd+`      .ds::::::::-------.`                
                 ``.------::::::::+hy     ```.omhsssshds.  `    `hs/::::::-------.`                 
                  `.------::::::::+hs   `  ```-ymysoydh:       ``yy/::::::-------.`                 
                  `.------::::::::+d+`/:-`  ```:mdssdd/` `  `-//.yy+:::::::------.`                 
                  `.------::::::::+d/`hmdyo:.``.hmsomd: `.:oydNh.sh+:::::::------.`                 
                  `.-------:::::::od: smddddhs++mdosddo+oyhddmms.oho:::::::------.`                 
                   `-------:::::::+do.-/syddddddmyosydddddddhs/-:yh+::::::-------``                 
                   `.------::::-:::+sy+...:oyddhyssosyhddyo/-`-sys+:::::::------.`                  
                   ``.-------::--::-:+hs:` `./hmssssosdh+.```/hy/:::::::-------.``                  
                    `.--------:--::::-/yy/.``.+mhsosohmo.``.+ds::::::::--------.`                   
                     `..-------:::::---:sy+.  -hmsossdh:``.oho:/:::::::-------.`                    
                      `.--------:-::-:--:oy+``./Nhsohmo. .oh+-:::::::--------.`                     
                       ``.-------------:-/sy/``-hNsomh:`.+ys:::::::--------.``                      
                         `.------------::-+yy/..+Nhhmo-./yy/-:::----------.`                        
                          ``.----------::-:/sysoommNmyssyo/-::-:-------...`                         
                            ``..-------:--:--:/+oooso++/:--:----------.``                           
                              ```.---------------------------------..``                             
                                ````..-------------------------...``                                
                                     ````...-----------......````                                   
                                           ````````````````                                         
                                                                                                    
                                                                                                    
              _____                   _______                   _____                    _____          
             /\    \                 /::\    \                 /\    \                  /\    \         
            /::\____\               /::::\    \               /::\    \                /::\    \        
           /:::/    /              /::::::\    \              \:::\    \               \:::\    \       
          /:::/    /              /::::::::\    \              \:::\    \               \:::\    \      
         /:::/    /              /:::/~~\:::\    \              \:::\    \               \:::\    \     
        /:::/____/              /:::/    \:::\    \              \:::\    \               \:::\    \    
       /::::\    \             /:::/    / \:::\    \             /::::\    \              /::::\    \   
      /::::::\____\________   /:::/____/   \:::\____\   _____   /::::::\    \    ____    /::::::\    \  
     /:::/\:::::::::::\    \ |:::|    |     |:::|    | /\    \ /:::/\:::\    \  /\   \  /:::/\:::\    \ 
    /:::/  |:::::::::::\____\|:::|____|     |:::|    |/::\    /:::/  \:::\____\/::\   \/:::/  \:::\____\
    \::/   |::|~~~|~~~~~      \:::\    \   /:::/    / \:::\  /:::/    \::/    /\:::\  /:::/    \::/    /
     \/____|::|   |            \:::\    \ /:::/    /   \:::\/:::/    / \/____/  \:::\/:::/    / \/____/ 
           |::|   |             \:::\    /:::/    /     \::::::/    /            \::::::/    /          
           |::|   |              \:::\__/:::/    /       \::::/    /              \::::/____/           
           |::|   |               \::::::::/    /         \::/    /                \:::\    \           
           |::|   |                \::::::/    /           \/____/                  \:::\    \          
           |::|   |                 \::::/    /                                      \:::\    \         
           \::|   |                  \::/____/                                        \:::\____\        
            \:|   |                   ~~                                               \::/    /        
             \|___|                                                                     \/____/         
                                                                                      
*////////////////////////////////////////////////////////////////////////////////////////////////////////////

// SPDX-License-Identifier: MIT

pragma solidity 0.7.4;

import "@openzeppelin/contracts/GSN/Context.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract KojiToken is Context, IERC20, Ownable {
    using SafeMath for uint256;
    using Address for address;

    string private constant NAME = "Koji";
    string private constant SYMBOL = "KOJI";
    uint8 private constant DECIMALS = 18;

    mapping(address => uint256) private rewards;
    mapping(address => uint256) private actual;
    mapping(address => mapping(address => uint256)) private allowances;

    mapping(address => bool) private excludedFromFees;
    mapping(address => bool) private excludedFromRewards;
    address[] private rewardExcluded;

    uint256 private constant MAX = ~uint256(0);
    uint256 private constant ACTUAL_TOTAL = 1000000 * 10**6 * 10**18;  //1 Trillion
    uint256 private rewardsTotal = (MAX - (MAX % ACTUAL_TOTAL));
    uint256 private holderFeeTotal;
    uint256 private charityFeeTotal;
    uint256 private burnFeeTotal;
    uint256 private adminFeeTotal;

    uint256 public taxPercentage = 3;     
    uint256 public holderTaxAlloc = 10;   
    uint256 public charityTaxAlloc = 10;  
    uint256 public burnTaxAlloc = 5;      
    uint256 public adminTaxAlloc = 5;     
    uint256 public totalTaxAlloc = charityTaxAlloc.add(holderTaxAlloc).add(burnTaxAlloc).add(adminTaxAlloc);

    address public charityAddress;
    address public burnAddress;
    address public adminAddress;

    constructor(address _charityAddress) {
        rewards[_charityAddress] = rewardsTotal;
        emit Transfer(address(0), _charityAddress, ACTUAL_TOTAL);

        charityAddress = _charityAddress;

        excludeFromRewards(_msgSender());
        excludeFromFees(_charityAddress);

        if (_charityAddress != _msgSender()) {
            excludeFromRewards(_charityAddress);
            excludeFromFees(_msgSender());
        }

        excludeFromFees(address(0x000000000000000000000000000000000000dEaD));
    }

    function name() external pure returns (string memory) {
        return NAME;
    }

    function symbol() external pure returns (string memory) {
        return SYMBOL;
    }

    function decimals() external pure returns (uint8) {
        return DECIMALS;
    }

    function totalSupply() external pure override returns (uint256) {
        return ACTUAL_TOTAL;
    }

    function balanceOf(address _account) public view override returns (uint256) {
        if (excludedFromRewards[_account]) {
            return actual[_account];
        }
        return tokenWithRewards(rewards[_account]);
    }

    function transfer(address _recipient, uint256 _amount) public override returns (bool) {
        _transfer(_msgSender(), _recipient, _amount);
        return true;
    }

    function allowance(address _owner, address _spender) public view override returns (uint256) {
        return allowances[_owner][_spender];
    }

    function approve(address _spender, uint256 _amount) public override returns (bool) {
        _approve(_msgSender(), _spender, _amount);
        return true;
    }

    function transferFrom(
        address _sender,
        address _recipient,
        uint256 _amount
    ) public override returns (bool) {
        _transfer(_sender, _recipient, _amount);

        _approve(
        _sender,
            _msgSender(),
            allowances[_sender][_msgSender()].sub(_amount, "ERC20: transfer amount exceeds allowance")
        );

        return true;
    }

    function increaseAllowance(address _spender, uint256 _addedValue) public virtual returns (bool) {
        _approve(_msgSender(), _spender, allowances[_msgSender()][_spender].add(_addedValue));
        return true;
    }

    function decreaseAllowance(address _spender, uint256 _subtractedValue) public virtual returns (bool) {
        _approve(
            _msgSender(),
            _spender,
            allowances[_msgSender()][_spender].sub(_subtractedValue, "ERC20: decreased allowance below zero")
        );
        return true;
    }

    function isExcludedFromRewards(address _account) external view returns (bool) {
        return excludedFromRewards[_account];
    }

    function isExcludedFromFees(address _account) external view returns (bool) {
        return excludedFromFees[_account];
    }

    function totalFees() external view returns (uint256) {
        return holderFeeTotal.add(charityFeeTotal).add(burnFeeTotal).add(adminFeeTotal);
    }

    function totalHolderFees() external view returns (uint256) {
        return holderFeeTotal;
    }

    function totalCharityFees() external view returns (uint256) {
        return charityFeeTotal;
    }

    function totalBurnFees() external view returns (uint256) {
        return burnFeeTotal;
    }

    function totalAdminFees() external view returns (uint256) {
        return adminFeeTotal;
    }

    function distribute(uint256 _actualAmount) public {
        address sender = _msgSender();
        require(!excludedFromRewards[sender], "Excluded addresses cannot call this function");

        (uint256 rewardAmount, , , , ) = _getValues(_actualAmount);
        rewards[sender] = rewards[sender].sub(rewardAmount);
        rewardsTotal = rewardsTotal.sub(rewardAmount);
        holderFeeTotal = holderFeeTotal.add(_actualAmount);
    }

    function excludeFromFees(address _account) public onlyOwner() {
        require(!excludedFromFees[_account], "Account is already excluded from fee");
        excludedFromFees[_account] = true;
    }

    function includeInFees(address _account) public onlyOwner() {
        require(excludedFromFees[_account], "Account is already included in fee");
        excludedFromFees[_account] = false;
    }

    function excludeFromRewards(address _account) public onlyOwner() {
        require(!excludedFromRewards[_account], "Account is already excluded from reward");

        if (rewards[_account] > 0) {
            actual[_account] = tokenWithRewards(rewards[_account]);
        }

        excludedFromRewards[_account] = true;
        rewardExcluded.push(_account);
    }

    function includeInRewards(address _account) public onlyOwner() {
        require(excludedFromRewards[_account], "Account is already included in rewards");

        for (uint256 i = 0; i < rewardExcluded.length; i++) {
            if (rewardExcluded[i] == _account) {
                rewardExcluded[i] = rewardExcluded[rewardExcluded.length - 1];
                actual[_account] = 0;
                excludedFromRewards[_account] = false;
                rewardExcluded.pop();
                break;
            }
        }
    }

    function _approve(
        address _owner,
        address _spender,
        uint256 _amount
    ) private {
        require(_owner != address(0), "ERC20: approve from the zero address");
        require(_spender != address(0), "ERC20: approve to the zero address");

        allowances[_owner][_spender] = _amount;
        emit Approval(_owner, _spender, _amount);
    }

    function _transfer(
        address _sender,
        address _recipient,
        uint256 _amount
    ) private {
        require(_sender != address(0), "ERC20: transfer from the zero address");
        require(_recipient != address(0), "ERC20: transfer to the zero address");
        require(_amount > 0, "Transfer amount must be greater than zero");

        uint256 currentTaxPercentage = taxPercentage;
        if (excludedFromFees[_sender] || excludedFromFees[_recipient]) {
            taxPercentage = 0;
        } else {
            uint256 fee = _getFee(_amount);
            uint256 charityFee = _getCharityFee(fee);
            uint256 burnFee = _getBurnFee(fee);
            uint256 adminFee = _getAdminFee(fee);

            _updateCharityFee(charityFee);
            _updateBurnFee(burnFee);
            _updateAdminFee(adminFee);
        }

        if (excludedFromRewards[_sender] && !excludedFromRewards[_recipient]) {
            _transferWithoutSenderRewards(_sender, _recipient, _amount);
        } else if (!excludedFromRewards[_sender] && excludedFromRewards[_recipient]) {
            _transferWithRecipientRewards(_sender, _recipient, _amount);
        } else if (!excludedFromRewards[_sender] && !excludedFromRewards[_recipient]) {
            _transferWithRewards(_sender, _recipient, _amount);
        } else if (excludedFromRewards[_sender] && excludedFromRewards[_recipient]) {
            _transferWithoutRewards(_sender, _recipient, _amount);
        } else {
            _transferWithRewards(_sender, _recipient, _amount);
        }

        if (currentTaxPercentage != taxPercentage) {
            taxPercentage = currentTaxPercentage;
        }
    }

    function _transferWithRewards(
        address _sender,
        address _recipient,
        uint256 _actualAmount
    ) private {
        (
            uint256 rewardAmount,
            uint256 rewardTransferAmount,
            uint256 rewardFee,
            uint256 actualTransferAmount,
            uint256 actualFee
        ) = _getValues(_actualAmount);

        rewards[_sender] = rewards[_sender].sub(rewardAmount);
        rewards[_recipient] = rewards[_recipient].add(rewardTransferAmount);
        _updateHolderFee(rewardFee, actualFee);
        emit Transfer(_sender, _recipient, actualTransferAmount);
    }

    function _transferWithRecipientRewards(
        address _sender,
        address _recipient,
        uint256 _actualAmount
    ) private {
        (
            uint256 rewardAmount,
            uint256 rewardTransferAmount,
            uint256 rewardFee,
            uint256 actualTransferAmount,
            uint256 actualFee
        ) = _getValues(_actualAmount);

        rewards[_sender] = rewards[_sender].sub(rewardAmount);
        actual[_recipient] = actual[_recipient].add(actualTransferAmount);
        rewards[_recipient] = rewards[_recipient].add(rewardTransferAmount);
        _updateHolderFee(rewardFee, actualFee);
        emit Transfer(_sender, _recipient, actualTransferAmount);
    }

    function _transferWithoutSenderRewards(
        address _sender,
        address _recipient,
        uint256 _actualAmount
    ) private {
        (
            uint256 rewardAmount,
            uint256 rewardTransferAmount,
            uint256 rewardFee,
            uint256 actualTransferAmount,
            uint256 actualFee
        ) = _getValues(_actualAmount);

        actual[_sender] = actual[_sender].sub(_actualAmount);
        rewards[_sender] = rewards[_sender].sub(rewardAmount);
        rewards[_recipient] = rewards[_recipient].add(rewardTransferAmount);
        _updateHolderFee(rewardFee, actualFee);
        emit Transfer(_sender, _recipient, actualTransferAmount);
    }

    function _transferWithoutRewards(
        address _sender,
        address _recipient,
        uint256 _actualAmount
    ) private {
        (
            uint256 rewardAmount,
            uint256 rewardTransferAmount,
            uint256 rewardFee,
            uint256 actualTransferAmount,
            uint256 actualFee
        ) = _getValues(_actualAmount);

        actual[_sender] = actual[_sender].sub(_actualAmount);
        rewards[_sender] = rewards[_sender].sub(rewardAmount);
        actual[_recipient] = actual[_recipient].add(actualTransferAmount);
        rewards[_recipient] = rewards[_recipient].add(rewardTransferAmount);
        _updateHolderFee(rewardFee, actualFee);
        emit Transfer(_sender, _recipient, actualTransferAmount);
    }

    function _updateHolderFee(uint256 _rewardFee, uint256 _actualFee) private {
        rewardsTotal = rewardsTotal.sub(_rewardFee);
        holderFeeTotal = holderFeeTotal.add(_actualFee);
    }

    function _updateCharityFee(uint256 _charityFee) private {
        if (charityAddress == address(0)) {
            return;
        }

        uint256 rewardsRate = _getRewardsRate();
        uint256 rewardCharityFee = _charityFee.mul(rewardsRate);
        charityFeeTotal = charityFeeTotal.add(_charityFee);

        rewards[charityAddress] = rewards[charityAddress].add(rewardCharityFee);
        if (excludedFromRewards[charityAddress]) {
            actual[charityAddress] = actual[charityAddress].add(_charityFee);
        }
    }

    function _updateBurnFee(uint256 _burnFee) private {
        if (burnAddress == address(0)) {
            return;
        }

        uint256 rewardsRate = _getRewardsRate();
        uint256 rewardBurnFee = _burnFee.mul(rewardsRate);
        burnFeeTotal = burnFeeTotal.add(_burnFee);

        rewards[burnAddress] = rewards[burnAddress].add(rewardBurnFee);
        if (excludedFromRewards[burnAddress]) {
            actual[burnAddress] = actual[burnAddress].add(_burnFee);
        }
    }

    function _updateAdminFee(uint256 _adminFee) private {
        if (adminAddress == address(0)) {
            return;
        }

        uint256 rewardsRate = _getRewardsRate();
        uint256 rewardAdminFee = _adminFee.mul(rewardsRate);
        adminFeeTotal = adminFeeTotal.add(_adminFee);

        rewards[adminAddress] = rewards[adminAddress].add(rewardAdminFee);
        if (excludedFromRewards[adminAddress]) {
            actual[adminAddress] = actual[adminAddress].add(_adminFee);
        }
    }

    function rewardsFromToken(uint256 _actualAmount, bool _deductTransferFee) public view returns (uint256) {
        require(_actualAmount <= ACTUAL_TOTAL, "Amount must be less than supply");
        if (!_deductTransferFee) {
            (uint256 rewardAmount, , , , ) = _getValues(_actualAmount);
            return rewardAmount;
        } else {
            (, uint256 rewardTransferAmount, , , ) = _getValues(_actualAmount);
            return rewardTransferAmount;
        }
    }

    function tokenWithRewards(uint256 _rewardAmount) public view returns (uint256) {
        require(_rewardAmount <= rewardsTotal, "Amount must be less than total rewards");
        uint256 rewardsRate = _getRewardsRate();
        return _rewardAmount.div(rewardsRate);
    }

    function _getValues(uint256 _actualAmount)
        private
        view
        returns (
            uint256,
            uint256,
            uint256,
            uint256,
            uint256
        )
    {
        (uint256 actualTransferAmount, uint256 actualFee) = _getActualValues(_actualAmount);
        uint256 rewardsRate = _getRewardsRate();
        (
            uint256 rewardAmount,
            uint256 rewardTransferAmount,
            uint256 rewardFee
        ) = _getRewardValues(_actualAmount, actualFee, rewardsRate);

        return (rewardAmount, rewardTransferAmount, rewardFee, actualTransferAmount, actualFee);
    }

    function _getActualValues(uint256 _actualAmount) private view returns (uint256, uint256) {
        uint256 actualFee = _getFee(_actualAmount);
        uint256 actualHolderFee = _getHolderFee(actualFee);
        uint256 actualTransferAmount = _actualAmount.sub(actualFee);
        return (actualTransferAmount, actualHolderFee);
    }

    function _getRewardValues(
        uint256 _actualAmount,
        uint256 _actualHolderFee,
        uint256 _rewardsRate
    )
        private
        view
        returns (
            uint256,
            uint256,
            uint256
        )
    {
        uint256 actualFee = _getFee(_actualAmount).mul(_rewardsRate);
        uint256 rewardAmount = _actualAmount.mul(_rewardsRate);
        uint256 rewardTransferAmount = rewardAmount.sub(actualFee);
        uint256 rewardFee = _actualHolderFee.mul(_rewardsRate);
        return (rewardAmount, rewardTransferAmount, rewardFee);
    }

    function _getRewardsRate() private view returns (uint256) {
        (uint256 rewardsSupply, uint256 actualSupply) = _getCurrentSupply();
        return rewardsSupply.div(actualSupply);
    }

    function _getCurrentSupply() private view returns (uint256, uint256) {
        uint256 rewardsSupply = rewardsTotal;
        uint256 actualSupply = ACTUAL_TOTAL;

        for (uint256 i = 0; i < rewardExcluded.length; i++) {
            if (rewards[rewardExcluded[i]] > rewardsSupply || actual[rewardExcluded[i]] > actualSupply) {
                return (rewardsTotal, ACTUAL_TOTAL);
            }

            rewardsSupply = rewardsSupply.sub(rewards[rewardExcluded[i]]);
            actualSupply = actualSupply.sub(actual[rewardExcluded[i]]);
        }

        if (rewardsSupply < rewardsTotal.div(ACTUAL_TOTAL)) {
            return (rewardsTotal, ACTUAL_TOTAL);
        }

        return (rewardsSupply, actualSupply);
    }

    function _getFee(uint256 _amount) private view returns (uint256) {
        return _amount.mul(taxPercentage).div(100);
    }

    function _getHolderFee(uint256 _tax) private view returns (uint256) {
        return _tax.mul(holderTaxAlloc).div(totalTaxAlloc);
    }

    function _getCharityFee(uint256 _tax) private view returns (uint256) {
        return _tax.mul(charityTaxAlloc).div(totalTaxAlloc);
    }

    function _getBurnFee(uint256 _tax) private view returns (uint256) {
        return _tax.mul(burnTaxAlloc).div(totalTaxAlloc);
    }

    function _getAdminFee(uint256 _tax) private view returns (uint256) {
        return _tax.mul(adminTaxAlloc).div(totalTaxAlloc);
    }

    function setTaxPercentage(uint256 _taxPercentage) external onlyOwner {
        require(_taxPercentage >= 1 && _taxPercentage <= 10, "Value is outside of range 1-10");
        taxPercentage = _taxPercentage;
    }

    function setTaxAllocations(
        uint256 _holderTaxAlloc,
        uint256 _charityTaxAlloc,
        uint256 _burnTaxAlloc,
        uint256 _adminTaxAlloc
    ) external onlyOwner {
        totalTaxAlloc = _holderTaxAlloc.add(_charityTaxAlloc).add(_burnTaxAlloc).add(_adminTaxAlloc);

        holderTaxAlloc = _holderTaxAlloc;
        charityTaxAlloc = _charityTaxAlloc;
        burnTaxAlloc = _burnTaxAlloc;
        adminTaxAlloc = _adminTaxAlloc;
    }

    function setCharityAddress(address _charityAddress) external onlyOwner {
        charityAddress = _charityAddress;
    }

    function setBurnAddress(address _burnAddress) external onlyOwner {
        burnAddress = _burnAddress;
    }

    function setAdminAddress(address _adminAddress) external onlyOwner {
        adminAddress = _adminAddress;
    }

}

File 2 of 6 : Context.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

/*
 * @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 GSN 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 payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

File 3 of 6 : Ownable.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

import "../GSN/Context.sol";
/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

File 4 of 6 : SafeMath.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @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) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @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 sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @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) {
        // 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;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) {
        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;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts 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 mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

File 5 of 6 : IERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @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) 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 `amount` 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 amount) external returns (bool);

    /**
     * @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 amount) external returns (bool);

    /**
     * @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);
}

File 6 of 6 : Address.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

Settings
{
  "remappings": [],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "evmVersion": "byzantium",
  "libraries": {},
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_charityAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","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":"adminAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"adminTaxAlloc","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":"_amount","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":[],"name":"burnAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnTaxAlloc","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"charityAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"charityTaxAlloc","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_actualAmount","type":"uint256"}],"name":"distribute","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"excludeFromFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"excludeFromRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"holderTaxAlloc","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"includeInFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"includeInRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isExcludedFromFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isExcludedFromRewards","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_actualAmount","type":"uint256"},{"internalType":"bool","name":"_deductTransferFee","type":"bool"}],"name":"rewardsFromToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_adminAddress","type":"address"}],"name":"setAdminAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_burnAddress","type":"address"}],"name":"setBurnAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_charityAddress","type":"address"}],"name":"setCharityAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_holderTaxAlloc","type":"uint256"},{"internalType":"uint256","name":"_charityTaxAlloc","type":"uint256"},{"internalType":"uint256","name":"_burnTaxAlloc","type":"uint256"},{"internalType":"uint256","name":"_adminTaxAlloc","type":"uint256"}],"name":"setTaxAllocations","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_taxPercentage","type":"uint256"}],"name":"setTaxPercentage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"taxPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardAmount","type":"uint256"}],"name":"tokenWithRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAdminFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalBurnFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalCharityFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalHolderFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"totalTaxAlloc","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_sender","type":"address"},{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000b629fb3426877640c6fb6734360d81d719062bf6

-----Decoded View---------------
Arg [0] : _charityAddress (address): 0xb629fb3426877640c6fb6734360d81d719062bf6

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000b629fb3426877640c6fb6734360d81d719062bf6


A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.