Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract Owned
•    - function setOwner1(address _address)
•    - function setOwner2(address _address)
•  contract RequiringAuthorization is ...
•    - function authorize(address _address)
•    - function deauthorize(address _address ...
•    - function authorizeCasino()
•    - function deauthorizeCasino()
•    - function setCasino(address _casino)
•  contract WalletController is Requi ...
•    - function setDestination(address _dest ...
•    - function createWallet()
•    - function createWallets(uint count)
•    - function addSweeper(address _token, a ...
•    - function halt()
•    - function start()
•    - function sweeperOf(address _token)
•    - function logEthDeposit(address _from, ...
•    - function logSweep(address _from, addr ...
•  contract UserWallet *
•    - function ()
•    - function tokenFallback(address _from, ...
•    - function sweep(address _token, uint _ ...
•  contract AbstractSweeper
•    - function ()
•    - function sweep(address token, uint am ...
•  contract DefaultSweeper is Abstrac ...
•    - function sweep(address _token, uint _ ...
•  contract Token
•    - function balanceOf(address a)
•    - function transfer(address a, uint val ...
•  contract Casino

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-10-04
*/

/**
 * verified by 3esmit
*/

/**
 * Allows to create contracts which would be able to receive ETH and tokens.
 * Contract will help to detect ETH deposits faster.
 * Contract idea was borrowed from Bittrex.
 * Version: 2
 * */

pragma solidity 0.4.25;


contract Owned {
    address public owner1;
    address public owner2;

    modifier onlyOwner {
        require(msg.sender != address(0));
        require(msg.sender == owner1 || msg.sender == owner2, "Only owner.");
        _;
    }

    constructor() internal {
        owner1 = msg.sender;
    }

    function setOwner1(address _address) public onlyOwner {
        require(_address != address(0));
        owner1 = _address;
    }

    function setOwner2(address _address) public onlyOwner {
        require(_address != address(0));
        owner2 = _address;
    }
}


contract RequiringAuthorization is Owned {
    Casino public casino;
    bool public casinoAuthorized;
    mapping(address => bool) public authorized;

    modifier onlyAuthorized {
        require(authorized[msg.sender] || casinoAuthorized && casino.authorized(msg.sender), "Caller is not authorized.");
        _;
    }

    constructor(address _casino) internal {
        authorized[msg.sender] = true;
        casino = Casino(_casino);
        casinoAuthorized = true;
    }

    function authorize(address _address) public onlyOwner {
        authorized[_address] = true;
    }

    function deauthorize(address _address) public onlyOwner {
        authorized[_address] = false;
    }

    function authorizeCasino() public onlyOwner {
        casinoAuthorized = true;
    }

    function deauthorizeCasino() public onlyOwner {
        casinoAuthorized = false;
    }

    function setCasino(address _casino) public onlyOwner {
        casino = Casino(_casino);
    }
}


contract WalletController is RequiringAuthorization {
    address public destination;
    address public defaultSweeper = address(new DefaultSweeper(address(this)));
    bool public halted = false;

    mapping(address => address) public sweepers;
    mapping(address => bool) public wallets;

    event EthDeposit(address _from, address _to, uint _amount);
    event WalletCreated(address _address);
    event Sweeped(address _from, address _to, address _token, uint _amount);

    modifier onlyWallet {
        require(wallets[msg.sender], "Caller must be user wallet.");
        _;
    }

    constructor(address _casino) public RequiringAuthorization(_casino) {
        destination = msg.sender;
    }

    function setDestination(address _destination) public onlyOwner {
        destination = _destination;
    }

    function createWallet() public {
        address wallet = address(new UserWallet(this));
        wallets[wallet] = true;
        emit WalletCreated(wallet);
    }

    function createWallets(uint count) public {
        for (uint i = 0; i < count; i++) {
            createWallet();
        }
    }

    function addSweeper(address _token, address _sweeper) public onlyOwner {
        sweepers[_token] = _sweeper;
    }

    function halt() public onlyAuthorized {
        halted = true;
    }

    function start() public onlyOwner {
        halted = false;
    }

    function sweeperOf(address _token) public view returns (address) {
        address sweeper = sweepers[_token];
        if (sweeper == 0) sweeper = defaultSweeper;
        return sweeper;
    }

    function logEthDeposit(address _from, address _to, uint _amount) public onlyWallet {
        emit EthDeposit(_from, _to, _amount);
    }

    function logSweep(address _from, address _to, address _token, uint _amount) public {
        emit Sweeped(_from, _to, _token, _amount);
    }
}


contract UserWallet {
    WalletController private controller;

    constructor (address _controller) public {
        controller = WalletController(_controller);
    }

    function () public payable {
        controller.logEthDeposit(msg.sender, address(this), msg.value);
    }

    function tokenFallback(address _from, uint _value, bytes _data) public pure {
        (_from);
        (_value);
        (_data);
    }

    function sweep(address _token, uint _amount) public returns (bool) {
        (_amount);
        return controller.sweeperOf(_token).delegatecall(msg.data);
    }
}


contract AbstractSweeper {
    WalletController public controller;

    constructor (address _controller) public {
        controller = WalletController(_controller);
    }

    function () public { revert("Contract does not accept ETH."); }

    function sweep(address token, uint amount) public returns (bool);

    modifier canSweep() {
        if (!(controller.authorized(msg.sender) || controller.casinoAuthorized() && controller.casino().authorized(msg.sender))) revert("Caller is not authorized to sweep.");
        if (controller.halted()) revert("Contract is halted.");
        _;
    }
}


contract DefaultSweeper is AbstractSweeper {

    constructor (address controller) public AbstractSweeper(controller) {}

    function sweep(address _token, uint _amount) public canSweep returns (bool) {
        bool success = false;
        address destination = controller.destination();

        if (_token != address(0)) {
            Token token = Token(_token);
            uint amount = _amount;
            if (amount > token.balanceOf(this)) {
                return false;
            }

            success = token.transfer(destination, amount);
        } else {
            uint amountInWei = _amount;
            if (amountInWei > address(this).balance) {
                return false;
            }
            success = destination.send(amountInWei);
        }

        if (success) {
            controller.logSweep(this, destination, _token, _amount);
        }
        return success;
    }
}


contract Token {
    function balanceOf(address a) public pure returns (uint) {
        (a);
        return 0;
    }

    function transfer(address a, uint val) public pure returns (bool) {
        (a);
        (val);
        return false;
    }
}


contract Casino {
    mapping(address => bool) public authorized;
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":false,"inputs":[{"name":"_token","type":"address"},{"name":"_amount","type":"uint256"}],"name":"sweep","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_from","type":"address"},{"name":"_value","type":"uint256"},{"name":"_data","type":"bytes"}],"name":"tokenFallback","outputs":[],"payable":false,"stateMutability":"pure","type":"function"},{"inputs":[{"name":"_controller","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"}]

0x60806040526004361061004b5763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416636ea056a981146100de578063c0ee0b8a14610123575b60008054604080517f3128012a000000000000000000000000000000000000000000000000000000008152336004820152306024820152346044820152905173ffffffffffffffffffffffffffffffffffffffff90921692633128012a9260648084019382900301818387803b1580156100c457600080fd5b505af11580156100d8573d6000803e3d6000fd5b50505050005b3480156100ea57600080fd5b5061010f73ffffffffffffffffffffffffffffffffffffffff6004351660243561019b565b604080519115158252519081900360200190f35b34801561012f57600080fd5b50604080516020600460443581810135601f810184900484028501840190955284845261019994823573ffffffffffffffffffffffffffffffffffffffff169460248035953695946064949201919081908401838280828437509497506102829650505050505050565b005b60008054604080517f3c18d31800000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff868116600483015291519190921691633c18d31891602480830192602092919082900301818787803b15801561021057600080fd5b505af1158015610224573d6000803e3d6000fd5b505050506040513d602081101561023a57600080fd5b505160405173ffffffffffffffffffffffffffffffffffffffff90911690600090369080838380828437820191505092505050600060405180830381855af495945050505050565b5050505600a165627a7a72305820670b3401d94aec68ef3bdcca24e917d0bcb5bf05491f1d1c1d0f59cf6c11fae60029

3828:611:0:-;;;;;;;;;;;;;;;;;;;;;;;;;4047:10;;;:62;;;;;;4072:10;4047:62;;;;4092:4;4047:62;;;;4099:9;4047:62;;;;;;:10;;;;;:24;;:62;;;;;;;;;;:10;;:62;;;5:2:-1;;;;30:1;27;20:12;5:2;4047:62:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;4047:62:0;;;;3828:611;4272:164;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;4272:164:0;;;;;;;;;;;;;;;;;;;;;;;;;;;4125:139;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;4125:139:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4125:139:0;;-1:-1:-1;4125:139:0;;-1:-1:-1;;;;;;;4125:139:0;;;4272:164;4333:4;4377:10;;:28;;;;;;:10;:28;;;;;;;;;:10;;;;;:20;;:28;;;;;;;;;;;;;;4333:4;4377:10;:28;;;5:2:-1;;;;30:1;27;20:12;5:2;4377:28:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;4377:28:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;4377:28:0;:51;;:41;;;;;4419:8;;;;4377:51;4419:8;;;;4377:51;;;;;;;;;;;;;;;;;;;;;;4272:164;-1:-1:-1;;;;;4272:164:0:o;4125:139::-;;;;:::o

bzzr://670b3401d94aec68ef3bdcca24e917d0bcb5bf05491f1d1c1d0f59cf6c11fae6