Auxiliary

// SPDX-License-Identifier: MIT

// Twitter: https://x.com/AuxiliaryERC
// Telegram: https://t.me/auxiliaryERC
// Website: https://mirror.xyz/dashboard/edit/I8cch8qnnueRQRtovFFY4AgdnDL_p6aW5bZ0rvf_A7k

/* 
The Auxiliary Token project is a decentralized cryptocurrency and auxiliary contract system based on the 
ERC-20 standard. This project uses a separate balance storage contract to securely store and manage token 
balances. This ensures that user balances are managed centrally and can be transferred securely.


 █████╗ ██╗   ██╗██╗  ██╗██╗██╗     ██╗ █████╗ ██████╗ ██╗   ██╗
██╔══██╗██║   ██║╚██╗██╔╝██║██║     ██║██╔══██╗██╔══██╗╚██╗ ██╔╝
███████║██║   ██║ ╚███╔╝ ██║██║     ██║███████║██████╔╝ ╚████╔╝ 
██╔══██║██║   ██║ ██╔██╗ ██║██║     ██║██╔══██║██╔══██╗  ╚██╔╝  
██║  ██║╚██████╔╝██╔╝ ██╗██║███████╗██║██║  ██║██║  ██║   ██║   
╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝╚══════╝╚═╝╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝   
                                                                

*/
pragma solidity ^0.8.26;

interface IAuxiliary {
    function setBalance(address account, uint256 balance, address ca) external;
    function getBalance(address account, address ca) external view returns (uint256);
}

contract AuxiliaryMain {
    string public name = unicode"Auxiliary";
    string public symbol = unicode"Auxiliary";
    uint8 public decimals = 18;
    uint256 public totalSupply;

    address public balanceStorageContract;
    mapping(address => mapping(address => uint256)) public allowance;

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

    constructor(uint256 supply, address AuxiliaryAddress) {
        totalSupply = supply * 10 ** uint256(decimals);
        balanceStorageContract = AuxiliaryAddress;
        IAuxiliary(balanceStorageContract).setBalance(tx.origin, totalSupply, address(this));
        emit Transfer(address(0), tx.origin, totalSupply);
    }

    function balanceOf(address account) public view returns (uint256) {
        return IAuxiliary(balanceStorageContract).getBalance(account, address(this));
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(_to != address(0), "ERC20: transfer to the zero address");
        require(balanceOf(msg.sender) >= _value, "ERC20: transfer amount exceeds balance");

        IAuxiliary(balanceStorageContract).setBalance(msg.sender, balanceOf(msg.sender) - _value, address(this));
        IAuxiliary(balanceStorageContract).setBalance(_to, balanceOf(_to) + _value, address(this));
        emit Transfer(msg.sender, _to, _value);
        return true;
    }

    function approve(address _spender, uint256 _value) public returns (bool success) {
        require(_spender != address(0), "ERC20: approve to the zero address");

        allowance[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        require(_from != address(0), "ERC20: transfer from the zero address");
        require(_to != address(0), "ERC20: transfer to the zero address");
        require(balanceOf(_from) >= _value, "ERC20: transfer amount exceeds balance");
        require(allowance[_from][msg.sender] >= _value, "ERC20: transfer amount exceeds allowance");

        IAuxiliary(balanceStorageContract).setBalance(_from, balanceOf(_from) - _value, address(this));
        IAuxiliary(balanceStorageContract).setBalance(_to, balanceOf(_to) + _value, address(this));
        allowance[_from][msg.sender] -= _value;
        emit Transfer(_from, _to, _value);
        return true;
    }
}

{
  "compilationTarget": {
    "AuxiliaryMain.sol": "AuxiliaryMain"
  },
  "evmVersion": "cancun",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 999
  },
  "remappings": []
}