Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract Ownable
•    - function setOwner(address _owner)
• library AddressMinHeap
•    - function initialize(Heap storage _hea ...
•    - function encode(address _addr, uint25 ...
•    - function decode(uint256 _entry)
•    - function decodeAddress(uint256 _entry ...
•    - function top(Heap storage _heap)
•    - function has(Heap storage _heap, addr ...
•    - function size(Heap storage _heap)
•    - function entry(Heap storage _heap, ui ...
•    - function popTop(Heap storage _heap)
•    - function insert(Heap storage _heap, a ...
•    - function update(Heap storage _heap, a ...
•    - function bubbleUp(Heap storage _heap, ...
•    - function bubbleDown(Heap storage _hea ...
•  contract StorageUnit
•    - function write(bytes32 _key, bytes32 ...
•    - function read(bytes32 _key)
• library IsContract
•    - function isContract(address _addr)
• library DistributedStorage
•    - function contractSlot(bytes32 _key)
•    - function deploy(bytes32 _key)
•    - function write(
•    - function read(
• library SafeMath
•    - function add(uint256 x, uint256 y)
•    - function sub(uint256 x, uint256 y)
•    - function mult(uint256 x, uint256 y)
•    - function div(uint256 x, uint256 y)
•    - function divRound(uint256 x, uint256 ...
• library Math
•    - function orderOfMagnitude(uint256 inp ...
•    - function min(uint256 _a, uint256 _b)
•  contract GasPump
• interface IERC20
•    - function transfer(address _to, uint _ ...
•    - function transferFrom(address _from, ...
•    - function allowance(address _owner, ad ...
•    - function approve(address _spender, ui ...
•    - function balanceOf(address _owner)
•  contract ShuffleToken is Ownable, ...
•    - function init(
•    - function _toKey(address a)
•    - function _balanceOf(address _addr)
•    - function _allowance(address _addr, ad ...
•    - function _nonce(address _addr, uint25 ...
•    - function _setAllowance(address _addr, ...
•    - function _setNonce(address _addr, uin ...
•    - function _setBalance(address _addr, u ...
•    - function getNonce(address _addr, uint ...
•    - function _isWhitelisted(address _from ...
•    - function _random(address _s1, uint256 ...
•    - function _pickWinner(address _from, u ...
•    - function _transferFrom(address _opera ...
•    - function _computeHeap(address _addr, ...
•    - function setWhitelistedTo(address _ad ...
•    - function setWhitelistedFrom(address _ ...
•    - function setName(string calldata _nam ...
•    - function setExtraGas(uint256 _gas)
•    - function heapSize()
•    - function heapEntry(uint256 _i)
•    - function heapTop()
•    - function heapIndex(address _addr)
•    - function balanceOf(address _addr)
•    - function allowance(address _addr, add ...
•    - function approve(address _spender, ui ...
•    - function transfer(address _to, uint25 ...
•    - function transferWithFee(address _to, ...
•    - function transferFrom(address _from, ...
• library SigUtils
•    - function ecrecover2(
•  contract Airdrop is Ownable *
•    - function setMaxClaimedBy(uint64 _max)
•    - function setSigner(address _signer, b ...
•    - function setSigners(address[] calldat ...
•    - function supportsFallback(address _to ...
•    - function _selfBalance()
•    - function checkFallback(address _to)
•    - function claim(
•    - function migrate(address _addr, uint2 ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2019-08-05
*/

/**
 *Submitted for verification at Etherscan.io on 2019-07-21
*/

// File: contracts/commons/Ownable.sol

pragma solidity ^0.5.10;


contract Ownable {
    address public owner;

    event TransferOwnership(address _from, address _to);

    constructor() public {
        owner = msg.sender;
        emit TransferOwnership(address(0), msg.sender);
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "only owner");
        _;
    }

    function setOwner(address _owner) external onlyOwner {
        emit TransferOwnership(owner, _owner);
        owner = _owner;
    }
}

// File: contracts/commons/AddressMinHeap.sol

pragma solidity ^0.5.10;

/*
    @author Agustin Aguilar <[email protected]>
*/


library AddressMinHeap {
    using AddressMinHeap for AddressMinHeap.Heap;

    struct Heap {
        uint256[] entries;
        mapping(address => uint256) index;
    }

    function initialize(Heap storage _heap) internal {
        require(_heap.entries.length == 0, "already initialized");
        _heap.entries.push(0);
    }

    function encode(address _addr, uint256 _value) internal pure returns (uint256 _entry) {
        /* solium-disable-next-line */
        assembly {
            _entry := not(or(and(0xffffffffffffffffffffffffffffffffffffffff, _addr), shl(160, _value)))
        }
    }

    function decode(uint256 _entry) internal pure returns (address _addr, uint256 _value) {
        /* solium-disable-next-line */
        assembly {
            let entry := not(_entry)
            _addr := and(entry, 0xffffffffffffffffffffffffffffffffffffffff)
            _value := shr(160, entry)
        }
    }

    function decodeAddress(uint256 _entry) internal pure returns (address _addr) {
        /* solium-disable-next-line */
        assembly {
            _addr := and(not(_entry), 0xffffffffffffffffffffffffffffffffffffffff)
        }
    }

    function top(Heap storage _heap) internal view returns(address, uint256) {
        if (_heap.entries.length < 2) {
            return (address(0), 0);
        }

        return decode(_heap.entries[1]);
    }

    function has(Heap storage _heap, address _addr) internal view returns (bool) {
        return _heap.index[_addr] != 0;
    }

    function size(Heap storage _heap) internal view returns (uint256) {
        return _heap.entries.length - 1;
    }

    function entry(Heap storage _heap, uint256 _i) internal view returns (address, uint256) {
        return decode(_heap.entries[_i + 1]);
    }

    // RemoveMax pops off the root element of the heap (the highest value here) and rebalances the heap
    function popTop(Heap storage _heap) internal returns(address _addr, uint256 _value) {
        // Ensure the heap exists
        uint256 heapLength = _heap.entries.length;
        require(heapLength > 1, "The heap does not exists");

        // take the root value of the heap
        (_addr, _value) = decode(_heap.entries[1]);
        _heap.index[_addr] = 0;

        if (heapLength == 2) {
            _heap.entries.length = 1;
        } else {
            // Takes the last element of the array and put it at the root
            uint256 val = _heap.entries[heapLength - 1];
            _heap.entries[1] = val;

            // Delete the last element from the array
            _heap.entries.length = heapLength - 1;

            // Start at the top
            uint256 ind = 1;

            // Bubble down
            ind = _heap.bubbleDown(ind, val);

            // Update index
            _heap.index[decodeAddress(val)] = ind;
        }
    }

    // Inserts adds in a value to our heap.
    function insert(Heap storage _heap, address _addr, uint256 _value) internal {
        require(_heap.index[_addr] == 0, "The entry already exists");

        // Add the value to the end of our array
        uint256 encoded = encode(_addr, _value);
        _heap.entries.push(encoded);

        // Start at the end of the array
        uint256 currentIndex = _heap.entries.length - 1;

        // Bubble Up
        currentIndex = _heap.bubbleUp(currentIndex, encoded);

        // Update index
        _heap.index[_addr] = currentIndex;
    }

    function update(Heap storage _heap, address _addr, uint256 _value) internal {
        uint256 ind = _heap.index[_addr];
        require(ind != 0, "The entry does not exists");

        uint256 can = encode(_addr, _value);
        uint256 val = _heap.entries[ind];
        uint256 newInd;

        if (can < val) {
            // Bubble down
            newInd = _heap.bubbleDown(ind, can);
        } else if (can > val) {
            // Bubble up
            newInd = _heap.bubbleUp(ind, can);
        } else {
            // no changes needed
            return;
        }

        // Update entry
        _heap.entries[newInd] = can;

        // Update index
        if (newInd != ind) {
            _heap.index[_addr] = newInd;
        }
    }

    function bubbleUp(Heap storage _heap, uint256 _ind, uint256 _val) internal returns (uint256 ind) {
        // Bubble up
        ind = _ind;
        if (ind != 1) {
            uint256 parent = _heap.entries[ind / 2];
            while (parent < _val) {
                // If the parent value is lower than our current value, we swap them
                (_heap.entries[ind / 2], _heap.entries[ind]) = (_val, parent);

                // Update moved Index
                _heap.index[decodeAddress(parent)] = ind;

                // change our current Index to go up to the parent
                ind = ind / 2;
                if (ind == 1) {
                    break;
                }

                // Update parent
                parent = _heap.entries[ind / 2];
            }
        }
    }

    function bubbleDown(Heap storage _heap, uint256 _ind, uint256 _val) internal returns (uint256 ind) {
        // Bubble down
        ind = _ind;

        uint256 lenght = _heap.entries.length;
        uint256 target = lenght - 1;

        while (ind * 2 < lenght) {
            // get the current index of the children
            uint256 j = ind * 2;

            // left child value
            uint256 leftChild = _heap.entries[j];

            // Store the value of the child
            uint256 childValue;

            if (target > j) {
                // The parent has two childs 👨‍👧‍👦

                // Load right child value
                uint256 rightChild = _heap.entries[j + 1];

                // Compare the left and right child.
                // if the rightChild is greater, then point j to it's index
                // and save the value
                if (leftChild < rightChild) {
                    childValue = rightChild;
                    j = j + 1;
                } else {
                    // The left child is greater
                    childValue = leftChild;
                }
            } else {
                // The parent has a single child 👨‍👦
                childValue = leftChild;
            }

            // Check if the child has a lower value
            if (_val > childValue) {
                break;
            }

            // else swap the value
            (_heap.entries[ind], _heap.entries[j]) = (childValue, _val);

            // Update moved Index
            _heap.index[decodeAddress(childValue)] = ind;

            // and let's keep going down the heap
            ind = j;
        }
    }
}

// File: contracts/commons/StorageUnit.sol

pragma solidity ^0.5.10;


contract StorageUnit {
    address private owner;
    mapping(bytes32 => bytes32) private store;

    constructor() public {
        owner = msg.sender;
    }

    function write(bytes32 _key, bytes32 _value) external {
        /* solium-disable-next-line */
        require(msg.sender == owner);
        store[_key] = _value;
    }

    function read(bytes32 _key) external view returns (bytes32) {
        return store[_key];
    }
}

// File: contracts/utils/IsContract.sol

pragma solidity ^0.5.10;


library IsContract {
    function isContract(address _addr) internal view returns (bool) {
        bytes32 codehash;
        /* solium-disable-next-line */
        assembly { codehash := extcodehash(_addr) }
        return codehash != bytes32(0) && codehash != bytes32(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470);
    }
}

// File: contracts/utils/DistributedStorage.sol

pragma solidity ^0.5.10;




library DistributedStorage {
    function contractSlot(bytes32 _key) private view returns (address) {
        return address(
            uint256(
                keccak256(
                    abi.encodePacked(
                        byte(0xff),
                        address(this),
                        _key,
                        keccak256(type(StorageUnit).creationCode)
                    )
                )
            )
        );
    }

    function deploy(bytes32 _key) private {
        bytes memory slotcode = type(StorageUnit).creationCode;
        /* solium-disable-next-line */
        assembly{ pop(create2(0, add(slotcode, 0x20), mload(slotcode), _key)) }
    }

    function write(
        bytes32 _struct,
        bytes32 _key,
        bytes32 _value
    ) internal {
        StorageUnit store = StorageUnit(contractSlot(_struct));
        if (!IsContract.isContract(address(store))) {
            deploy(_struct);
        }

        /* solium-disable-next-line */
        (bool success, ) = address(store).call(
            abi.encodeWithSelector(
                store.write.selector,
                _key,
                _value
            )
        );

        require(success, "error writing storage");
    }

    function read(
        bytes32 _struct,
        bytes32 _key
    ) internal view returns (bytes32) {
        StorageUnit store = StorageUnit(contractSlot(_struct));
        if (!IsContract.isContract(address(store))) {
            return bytes32(0);
        }

        /* solium-disable-next-line */
        (bool success, bytes memory data) = address(store).staticcall(
            abi.encodeWithSelector(
                store.read.selector,
                _key
            )
        );

        require(success, "error reading storage");
        return abi.decode(data, (bytes32));
    }
}

// File: contracts/utils/SafeMath.sol

pragma solidity ^0.5.10;


library SafeMath {
    function add(uint256 x, uint256 y) internal pure returns (uint256) {
        uint256 z = x + y;
        require(z >= x, "Add overflow");
        return z;
    }

    function sub(uint256 x, uint256 y) internal pure returns (uint256) {
        require(x >= y, "Sub underflow");
        return x - y;
    }

    function mult(uint256 x, uint256 y) internal pure returns (uint256) {
        if (x == 0) {
            return 0;
        }

        uint256 z = x * y;
        require(z / x == y, "Mult overflow");
        return z;
    }

    function div(uint256 x, uint256 y) internal pure returns (uint256) {
        require(y != 0, "Div by zero");
        return x / y;
    }

    function divRound(uint256 x, uint256 y) internal pure returns (uint256) {
        require(y != 0, "Div by zero");
        uint256 r = x / y;
        if (x % y != 0) {
            r = r + 1;
        }

        return r;
    }
}

// File: contracts/utils/Math.sol

pragma solidity ^0.5.10;


library Math {
    function orderOfMagnitude(uint256 input) internal pure returns (uint256){
        uint256 counter = uint(-1);
        uint256 temp = input;

        do {
            temp /= 10;
            counter++;
        } while (temp != 0);

        return counter;
    }

    function min(uint256 _a, uint256 _b) internal pure returns (uint256) {
        if (_a < _b) {
            return _a;
        } else {
            return _b;
        }
    }
}

// File: contracts/utils/GasPump.sol

pragma solidity ^0.5.10;


contract GasPump {
    bytes32 private stub;

    modifier requestGas(uint256 _factor) {
        if (tx.gasprice == 0) {
            uint256 startgas = gasleft();
            _;
            uint256 delta = startgas - gasleft();
            uint256 target = (delta * _factor) / 100;
            startgas = gasleft();
            while (startgas - gasleft() < target) {
                // Burn gas
                stub = keccak256(abi.encodePacked(stub));
            }
        } else {
            _;
        }
    }
}

// File: contracts/interfaces/IERC20.sol

pragma solidity ^0.5.10;


interface IERC20 {
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    function transfer(address _to, uint _value) external returns (bool success);
    function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
    function allowance(address _owner, address _spender) external view returns (uint256 remaining);
    function approve(address _spender, uint256 _value) external returns (bool success);
    function balanceOf(address _owner) external view returns (uint256 balance);
}

// File: contracts/ShuffleToken.sol

pragma solidity ^0.5.10;









contract ShuffleToken is Ownable, GasPump, IERC20 {
    using AddressMinHeap for AddressMinHeap.Heap;
    using DistributedStorage for bytes32;
    using SafeMath for uint256;

    // Shuffle events
    event Winner(address indexed _addr, uint256 _value);

    // Heap events
    event JoinHeap(address indexed _address, uint256 _balance, uint256 _prevSize);
    event LeaveHeap(address indexed _address, uint256 _balance, uint256 _prevSize);

    // Managment events
    event SetName(string _prev, string _new);
    event SetExtraGas(uint256 _prev, uint256 _new);
    event WhitelistFrom(address _addr, bool _whitelisted);
    event WhitelistTo(address _addr, bool _whitelisted);

    uint256 public totalSupply;

    bytes32 private constant BALANCE_KEY = keccak256("balance");
    bytes32 private constant NONCE_KEY = keccak256("nonce");

    // game
    uint256 public constant FEE = 100;
    uint256 public constant TOP_SIZE = 512;

    // heap
    AddressMinHeap.Heap private heap;

    // metadata
    string public name = "shuffle.monster token V2";
    string public constant symbol = "SHUF";
    uint8 public constant decimals = 18;

    // fee whitelist
    mapping(address => bool) public whitelistFrom;
    mapping(address => bool) public whitelistTo;

    // internal
    uint256 public extraGas;
    bool inited;

    function init(
        address _to,
        uint256 _amount
    ) external {
        require(!inited);
        inited = true;
        heap.initialize();
        extraGas = 15;
        emit SetExtraGas(0, extraGas);
        emit Transfer(address(0), _to, _amount);
        _setBalance(_to, _amount);
        totalSupply = _amount;
    }

    ///
    // Storage access functions
    ///

    function _toKey(address a) internal pure returns (bytes32) {
        return bytes32(uint256(a));
    }

    function _balanceOf(address _addr) internal view returns (uint256) {
        return uint256(_toKey(_addr).read(BALANCE_KEY));
    }

    function _allowance(address _addr, address _spender) internal view returns (uint256) {
        return uint256(_toKey(_addr).read(keccak256(abi.encodePacked("allowance", _spender))));
    }

    function _nonce(address _addr, uint256 _cat) internal view returns (uint256) {
        return uint256(_toKey(_addr).read(keccak256(abi.encodePacked("nonce", _cat))));
    }

    function _setAllowance(address _addr, address _spender, uint256 _value) internal {
        _toKey(_addr).write(keccak256(abi.encodePacked("allowance", _spender)), bytes32(_value));
    }

    function _setNonce(address _addr, uint256 _cat, uint256 _value) internal {
        _toKey(_addr).write(keccak256(abi.encodePacked("nonce", _cat)), bytes32(_value));
    }

    function _setBalance(address _addr, uint256 _balance) internal {
        _toKey(_addr).write(BALANCE_KEY, bytes32(_balance));
        _computeHeap(_addr, _balance);
    }

    function getNonce(address _addr, uint256 _cat) external view returns (uint256) {
        return _nonce(_addr, _cat);
    }

    ///
    // Internal methods
    ///

    function _isWhitelisted(address _from, address _to) internal view returns (bool) {
        return whitelistFrom[_from]||whitelistTo[_to];
    }

    function _random(address _s1, uint256 _s2, uint256 _s3, uint256 _max) internal pure returns (uint256) {
        uint256 rand = uint256(keccak256(abi.encodePacked(_s1, _s2, _s3)));
        return rand % (_max + 1);
    }

    function _pickWinner(address _from, uint256 _value) internal returns (address winner) {
        // Get order of magnitude of the tx
        uint256 magnitude = Math.orderOfMagnitude(_value);
        // Pull nonce for a given order of magnitude
        uint256 nonce = _nonce(_from, magnitude);
        _setNonce(_from, magnitude, nonce + 1);
        // pick entry from heap
        (winner,) = heap.entry(_random(_from, nonce, magnitude, heap.size() - 1));
    }

    function _transferFrom(address _operator, address _from, address _to, uint256 _value, bool _skipWhitelist) internal {
        if (_value == 0) {
            emit Transfer(_from, _to, 0);
            return;
        }

        uint256 balanceFrom = _balanceOf(_from);
        require(balanceFrom >= _value, "balance not enough");

        if (_from != _operator) {
            uint256 allowanceFrom = _allowance(_from, _operator);
            if (allowanceFrom != uint(-1)) {
                require(allowanceFrom >= _value, "allowance not enough");
                _setAllowance(_from, _operator, allowanceFrom.sub(_value));
            }
        }

        uint256 receive = _value;
        _setBalance(_from, balanceFrom.sub(_value));

        if (_skipWhitelist || !_isWhitelisted(_from, _to)) {
            uint256 burn = _value.divRound(FEE);
            uint256 shuf = _value == 1 ? 0 : burn;
            receive = receive.sub(burn.add(shuf));

            // Burn tokens
            totalSupply = totalSupply.sub(burn);
            emit Transfer(_from, address(0), burn);

            // Shuffle tokens
            // Pick winner pseudo-randomly
            address winner = _pickWinner(_from, _value);
            // Transfer balance to winner
            _setBalance(winner, _balanceOf(winner).add(shuf));
            emit Winner(winner, shuf);
            emit Transfer(_from, winner, shuf);
        }

        // Transfer tokens
        _setBalance(_to, _balanceOf(_to).add(receive));
        emit Transfer(_from, _to, receive);
    }

    function _computeHeap(address _addr, uint256 _new) internal {
        uint256 size = heap.size();
        if (size == 0) {
            emit JoinHeap(_addr, _new, 0);
            heap.insert(_addr, _new);
            return;
        }

        (, uint256 lastBal) = heap.top();

        if (heap.has(_addr)) {
            heap.update(_addr, _new);
            if (_new == 0) {
                heap.popTop();
                emit LeaveHeap(_addr, 0, size);
            }
        } else {
            // IF heap is full or new bal is better than pop heap
            if (_new != 0 && (size < TOP_SIZE || lastBal < _new)) {
                // If heap is full pop heap
                if (size >= TOP_SIZE) {
                    (address _poped, uint256 _balance) = heap.popTop();
                    emit LeaveHeap(_poped, _balance, size);
                }

                // Insert new value
                heap.insert(_addr, _new);
                emit JoinHeap(_addr, _new, size);
            }
        }
    }

    ///
    // Managment
    ///

    function setWhitelistedTo(address _addr, bool _whitelisted) external onlyOwner {
        emit WhitelistTo(_addr, _whitelisted);
        whitelistTo[_addr] = _whitelisted;
    }

    function setWhitelistedFrom(address _addr, bool _whitelisted) external onlyOwner {
        emit WhitelistFrom(_addr, _whitelisted);
        whitelistFrom[_addr] = _whitelisted;
    }

    function setName(string calldata _name) external onlyOwner {
        emit SetName(name, _name);
        name = _name;
    }

    function setExtraGas(uint256 _gas) external onlyOwner {
        emit SetExtraGas(extraGas, _gas);
        extraGas = _gas;
    }

    /////
    // Heap methods
    /////

    function heapSize() external view returns (uint256) {
        return heap.size();
    }

    function heapEntry(uint256 _i) external view returns (address, uint256) {
        return heap.entry(_i);
    }

    function heapTop() external view returns (address, uint256) {
        return heap.top();
    }

    function heapIndex(address _addr) external view returns (uint256) {
        return heap.index[_addr];
    }

    /////
    // ERC20
    /////

    function balanceOf(address _addr) external view returns (uint256) {
        return _balanceOf(_addr);
    }

    function allowance(address _addr, address _spender) external view returns (uint256) {
        return _allowance(_addr, _spender);
    }

    function approve(address _spender, uint256 _value) external returns (bool) {
        emit Approval(msg.sender, _spender, _value);
        _setAllowance(msg.sender, _spender, _value);
        return true;
    }

    function transfer(address _to, uint256 _value) external requestGas(extraGas) returns (bool) {
        _transferFrom(msg.sender, msg.sender, _to, _value, false);
        return true;
    }

    function transferWithFee(address _to, uint256 _value) external requestGas(extraGas) returns (bool) {
        _transferFrom(msg.sender, msg.sender, _to, _value, true);
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) external requestGas(extraGas) returns (bool) {
        _transferFrom(msg.sender, _from, _to, _value, false);
        return true;
    }
}

library SigUtils {
    /**
      @dev Recovers address who signed the message
      @param _hash operation ethereum signed message hash
      @param _signature message `hash` signature
    */
    function ecrecover2(
        bytes32 _hash,
        bytes memory _signature
    ) internal pure returns (address) {
        bytes32 r;
        bytes32 s;
        uint8 v;

        /* solium-disable-next-line */
        assembly {
            r := mload(add(_signature, 32))
            s := mload(add(_signature, 64))
            v := and(mload(add(_signature, 65)), 255)
        }

        if (v < 27) {
            v += 27;
        }

        return ecrecover(
            _hash,
            v,
            r,
            s
        );
    }
}


pragma solidity ^0.5.10;






contract Airdrop is Ownable {
    using IsContract for address payable;

    ShuffleToken public shuffleToken;

    // Managment
    uint64 public maxClaimedBy = 100;

    event SetMaxClaimedBy(uint256 _max);
    event SetSigner(address _signer, bool _active);
    event Claimed(address _by, address _to, address _signer, uint256 _value, uint256 _claimed);
    event ClaimedOwner(address _owner, uint256 _tokens);

    uint256 public constant MINT_AMOUNT = 1010101010101010101010101;
    uint256 public constant CREATOR_AMOUNT = (MINT_AMOUNT * 6) / 100;
    uint256 public constant SHUFLE_BY_ETH = 150;
    uint256 public constant MAX_CLAIM_ETH = 10 ether;

    mapping(address => bool) public isSigner;

    mapping(address => uint256) public claimed;
    mapping(address => uint256) public numberClaimedBy;
    bool public creatorClaimed;
    Airdrop public prevAirdrop;

    constructor(ShuffleToken _token, Airdrop _prev) public {
        shuffleToken = _token;
        shuffleToken.init(address(this), MINT_AMOUNT);
        emit SetMaxClaimedBy(maxClaimedBy);
        prevAirdrop = _prev;
    }

    // ///
    // Managment
    // ///

    function setMaxClaimedBy(uint64 _max) external onlyOwner {
        maxClaimedBy = _max;
        emit SetMaxClaimedBy(_max);
    }

    function setSigner(address _signer, bool _active) external onlyOwner {
        isSigner[_signer] = _active;
        emit SetSigner(_signer, _active);
    }

    function setSigners(address[] calldata _signers, bool _active) external onlyOwner {
        for (uint256 i = 0; i < _signers.length; i++) {
            address signer = _signers[i];
            isSigner[signer] = _active;
            emit SetSigner(signer, _active);
        }
    }

    // ///
    // View
    // ///

    mapping(address => bool) private cvf;

    event CallCVF(address _from, address _to);

    function supportsFallback(address _to) external returns (bool) {
        emit CallCVF(msg.sender, _to);
        require(!cvf[msg.sender], "cfv");
        cvf[msg.sender] = true;
        return checkFallback(_to);
    }

    // ///
    // Airdrop
    // ///

    function _selfBalance() internal view returns (uint256) {
        return shuffleToken.balanceOf(address(this));
    }

    function checkFallback(address _to) private returns (bool success) {
        /* solium-disable-next-line */
        (success, ) = _to.call.value(1)("");
    }

    function claim(
        address _to,
        uint256 _val,
        bytes calldata _sig
    ) external {
        bytes32 _hash = keccak256(abi.encodePacked(_to, uint96(_val)));
        address signer = SigUtils.ecrecover2(_hash, _sig);

        require(isSigner[signer], "signature not valid");
        require(prevAirdrop.claimed(_to) == 0, "already claimed in prev airdrop");

        uint256 balance = _selfBalance();
        uint256 claimVal = Math.min(
            balance,
            Math.min(
                _val,
                MAX_CLAIM_ETH
            ) * SHUFLE_BY_ETH
        );

        require(claimed[_to] == 0, "already claimed");
        claimed[_to] = claimVal;

        if (msg.sender != _to) {
            uint256 _numberClaimedBy = numberClaimedBy[msg.sender];
            require(_numberClaimedBy <= maxClaimedBy, "max claim reached");
            numberClaimedBy[msg.sender] = _numberClaimedBy + 1;
            require(checkFallback(_to), "_to address can't receive tokens");
        }

        shuffleToken.transferWithFee(_to, claimVal);

        emit Claimed(msg.sender, _to, signer, _val, claimVal);

        if (balance == claimVal && _selfBalance() == 0) {
            selfdestruct(address(uint256(owner)));
        }
    }
    
    event Migrated(address _addr, uint256 _balance);
    mapping(address => uint256) public migrated;
    
    function migrate(address _addr, uint256 _balance, uint256 _require) external {
        require(isSigner[msg.sender]);
        require(migrated[_addr] == _require);
        migrated[_addr] = migrated[_addr] + _balance;
        shuffleToken.transfer(_addr, _balance);
        emit Migrated(_addr, _balance);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"shuffleToken","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_signers","type":"address[]"},{"name":"_active","type":"bool"}],"name":"setSigners","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_owner","type":"address"}],"name":"setOwner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"}],"name":"supportsFallback","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_max","type":"uint64"}],"name":"setMaxClaimedBy","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_signer","type":"address"},{"name":"_active","type":"bool"}],"name":"setSigner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"maxClaimedBy","outputs":[{"name":"","type":"uint64"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"migrated","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"MINT_AMOUNT","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"MAX_CLAIM_ETH","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"CREATOR_AMOUNT","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"isSigner","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"numberClaimedBy","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_val","type":"uint256"},{"name":"_sig","type":"bytes"}],"name":"claim","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"prevAirdrop","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"SHUFLE_BY_ETH","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"claimed","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"creatorClaimed","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_addr","type":"address"},{"name":"_balance","type":"uint256"},{"name":"_require","type":"uint256"}],"name":"migrate","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"_token","type":"address"},{"name":"_prev","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_max","type":"uint256"}],"name":"SetMaxClaimedBy","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_signer","type":"address"},{"indexed":false,"name":"_active","type":"bool"}],"name":"SetSigner","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_by","type":"address"},{"indexed":false,"name":"_to","type":"address"},{"indexed":false,"name":"_signer","type":"address"},{"indexed":false,"name":"_value","type":"uint256"},{"indexed":false,"name":"_claimed","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_owner","type":"address"},{"indexed":false,"name":"_tokens","type":"uint256"}],"name":"ClaimedOwner","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_from","type":"address"},{"indexed":false,"name":"_to","type":"address"}],"name":"CallCVF","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_addr","type":"address"},{"indexed":false,"name":"_balance","type":"uint256"}],"name":"Migrated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_from","type":"address"},{"indexed":false,"name":"_to","type":"address"}],"name":"TransferOwnership","type":"event"}]

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

000000000000000000000000d9db58c0cd8b93906ec87e353d6b1dbe19f3bfed0000000000000000000000002c54036c505b762b6ca2873dfcfecb632f83fe27

-----Decoded View---------------
Arg [0] : _token (address): 0xd9DB58c0cD8b93906eC87e353d6B1dbe19f3bFed
Arg [1] : _prev (address): 0x2C54036c505B762B6cA2873dfcfEcB632f83fE27

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000d9db58c0cd8b93906ec87e353d6b1dbe19f3bfed
Arg [1] : 0000000000000000000000002c54036c505b762b6ca2873dfcfecb632f83fe27

23390:4219:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23390:4219:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23470:32;;;:::i;:::-;;;;-1:-1:-1;;;;;23470:32:0;;;;;;;;;;;;;;24877:288;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;24877:288:0;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;24877:288:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;24877:288:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;24877:288:0;;-1:-1:-1;24877:288:0;-1:-1:-1;24877:288:0;;;;:::i;:::-;;481:134;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;481:134:0;-1:-1:-1;;;;;481:134:0;;:::i;25307:223::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;25307:223:0;-1:-1:-1;;;;;25307:223:0;;:::i;:::-;;;;;;;;;;;;;;;;;;24571:132;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;24571:132:0;;;;:::i;24711:158::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;24711:158:0;;;;;;;;;;:::i;23529:32::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;27233:43;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;27233:43:0;-1:-1:-1;;;;;27233:43:0;;:::i;:::-;;;;;;;;;;;;;;;;23822:63;;;:::i;24013:48::-;;;:::i;23892:64::-;;;:::i;24070:40::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;24070:40:0;-1:-1:-1;;;;;24070:40:0;;:::i;24168:50::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;24168:50:0;-1:-1:-1;;;;;24168:50:0;;:::i;167:20::-;;;:::i;25876:1291::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;25876:1291:0;;;;;;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;25876:1291:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;25876:1291:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;-1:-1;25876:1291:0;;-1:-1:-1;25876:1291:0;-1:-1:-1;25876:1291:0;:::i;24258:26::-;;;:::i;23963:43::-;;;:::i;24119:42::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;24119:42:0;-1:-1:-1;;;;;24119:42:0;;:::i;24225:26::-;;;:::i;27289:317::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;27289:317:0;;;;;;;;;;;;;:::i;23470:32::-;;;-1:-1:-1;;;;;23470:32:0;;:::o;24877:288::-;433:5;;-1:-1:-1;;;;;433:5:0;419:10;:19;411:42;;;;;-1:-1:-1;;;411:42:0;;;;;;;;;;;;-1:-1:-1;;;411:42:0;;;;;;;;;;;;;;;24975:9;24970:188;24990:19;;;24970:188;;;25031:14;25048:8;;25057:1;25048:11;;;;;;;;;;;;;;;;-1:-1:-1;;;;;25048:11:0;25074:16;;;;:8;:16;;;;;;;:26;;-1:-1:-1;;25074:26:0;;;;;;;;;;25120;;;;;;;;;;;25048:11;;-1:-1:-1;25120:26:0;;;;;;;-1:-1:-1;25120:26:0;-1:-1:-1;25011:3:0;;24970:188;;;;24877:288;;;:::o;481:134::-;433:5;;-1:-1:-1;;;;;433:5:0;419:10;:19;411:42;;;;;-1:-1:-1;;;411:42:0;;;;;;;;;;;;-1:-1:-1;;;411:42:0;;;;;;;;;;;;;;;568:5;;550:32;;;-1:-1:-1;;;;;568:5:0;;;550:32;;;;;;;;;;;;;;;;;;;;;593:5;:14;;-1:-1:-1;;;;;;593:14:0;-1:-1:-1;;;;;593:14:0;;;;;;;;;;481:134::o;25307:223::-;25386:24;;;25394:10;25386:24;;-1:-1:-1;;;;;25386:24:0;;;;;;;;25364:4;;25386:24;;;;;;;;25434:10;25430:15;;;;:3;:15;;;;;;;;25429:16;25421:32;;;;;-1:-1:-1;;;25421:32:0;;;;;;;;;;;;-1:-1:-1;;;25421:32:0;;;;;;;;;;;;;;;25468:10;25464:15;;;;:3;:15;;;;;:22;;-1:-1:-1;;25464:22:0;25482:4;25464:22;;;25504:18;25518:3;25504:13;:18::i;:::-;25497:25;25307:223;-1:-1:-1;;25307:223:0:o;24571:132::-;433:5;;-1:-1:-1;;;;;433:5:0;419:10;:19;411:42;;;;;-1:-1:-1;;;411:42:0;;;;;;;;;;;;-1:-1:-1;;;411:42:0;;;;;;;;;;;;;;;24639:12;:19;;;;;-1:-1:-1;;;24639:19:0;;-1:-1:-1;;;;24639:19:0;;;;;;;;;;24674:21;;;;;;;;;;;;;;;;24571:132;:::o;24711:158::-;433:5;;-1:-1:-1;;;;;433:5:0;419:10;:19;411:42;;;;;-1:-1:-1;;;411:42:0;;;;;;;;;;;;-1:-1:-1;;;411:42:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;24791:17:0;;;;;;:8;:17;;;;;;;;;:27;;-1:-1:-1;;24791:27:0;;;;;;;;;;24834;;;;;;;;;;;;;;;;;;;;;24711:158;;:::o;23529:32::-;;;-1:-1:-1;;;23529:32:0;;;;;:::o;27233:43::-;;;;;;;;;;;;;:::o;23822:63::-;23860:25;23822:63;:::o;24013:48::-;24053:8;24013:48;:::o;23892:64::-;23933:23;23892:64;:::o;24070:40::-;;;;;;;;;;;;;;;:::o;24168:50::-;;;;;;;;;;;;;:::o;167:20::-;;;-1:-1:-1;;;;;167:20:0;;:::o;25876:1291::-;25993:13;26036:3;26048:4;26019:35;;;;;;-1:-1:-1;;;;;26019:35:0;-1:-1:-1;;;;;26019:35:0;;;;;;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;26019:35:0;;;26009:46;;;;;;25993:62;;26066:14;26083:32;26103:5;26110:4;;26083:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;26083:19:0;;-1:-1:-1;;;26083:32:0:i;:::-;-1:-1:-1;;;;;26136:16:0;;;;;;:8;:16;;;;;;26066:49;;-1:-1:-1;26136:16:0;;26128:48;;;;;-1:-1:-1;;;26128:48:0;;;;;;;;;;;;-1:-1:-1;;;26128:48:0;;;;;;;;;;;;;;;26195:11;;:24;;;-1:-1:-1;;;26195:24:0;;-1:-1:-1;;;;;26195:24:0;;;;;;;;;:11;;;;;;;;:19;;:24;;;;;;;;;;;;;;;:11;:24;;;5:2:-1;;;;30:1;27;20:12;5:2;26195:24:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;26195:24:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;26195:24:0;:29;26187:73;;;;;-1:-1:-1;;;26187:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;26273:15;26291:14;:12;:14::i;:::-;26273:32;;26316:16;26335:150;26358:7;24003:3;26380:78;26407:4;24053:8;26380;:78::i;:::-;:94;26335:8;:150::i;:::-;-1:-1:-1;;;;;26506:12:0;;;;;;:7;:12;;;;;;26316:169;;-1:-1:-1;26506:17:0;26498:45;;;;;-1:-1:-1;;;26498:45:0;;;;;;;;;;;;-1:-1:-1;;;26498:45:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;26554:12:0;;;;;;:7;:12;;;;;:23;;;26594:10;:17;26590:324;;26671:10;26628:24;26655:27;;;:15;:27;;;;;;26725:12;;-1:-1:-1;;;26725:12:0;;;;26705:32;;;26697:62;;;;;-1:-1:-1;;;26697:62:0;;;;;;;;;;;;-1:-1:-1;;;26697:62:0;;;;;;;;;;;;;;;26790:10;26774:27;;;;:15;:27;;;;;26823:1;26804:20;;26774:50;;26847:18;26861:3;26847:13;:18::i;:::-;26839:63;;;;;-1:-1:-1;;;26839:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26590:324;;26926:12;;:43;;;-1:-1:-1;;;26926:43:0;;-1:-1:-1;;;;;26926:43:0;;;;;;;;;;;;;;;:12;;;;;:28;;:43;;;;;;;;;;;;;;:12;;:43;;;5:2:-1;;;;30:1;27;20:12;5:2;26926:43:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;26926:43:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;26987:48:0;;;26995:10;26987:48;;-1:-1:-1;;;;;26987:48:0;;;26926:43;26987:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27063:8;27052:7;:19;:42;;;;;27075:14;:12;:14::i;:::-;:19;27052:42;27048:112;;;27140:5;;-1:-1:-1;;;;;27140:5:0;27111:37;27048:112;25876:1291;;;;;;;;:::o;24258:26::-;;;;;;-1:-1:-1;;;;;24258:26:0;;:::o;23963:43::-;24003:3;23963:43;:::o;24119:42::-;;;;;;;;;;;;;:::o;24225:26::-;;;;;;:::o;27289:317::-;27394:10;27385:20;;;;:8;:20;;;;;;;;27377:29;;;;;;-1:-1:-1;;;;;27425:15:0;;;;;;:8;:15;;;;;;:27;;27417:36;;;;;;-1:-1:-1;;;;;27482:15:0;;;;;;;:8;:15;;;;;;;;;;:26;;27464:44;;-1:-1:-1;27519:12:0;:38;;-1:-1:-1;;;27519:38:0;;;;;;;;;;;;;;;;;:12;;;:21;;:38;;;;;;;;;;;;;:12;:38;;;5:2:-1;;;;30:1;27;20:12;5:2;27519:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;27519:38:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;27573:25:0;;;-1:-1:-1;;;;;27573:25:0;;;;27519:38;27573:25;;;;;;;;;;;;;;;;;;27289:317;;;:::o;25707:161::-;25839:21;;25760:12;;-1:-1:-1;;;;;25839:8:0;;;25854:1;;25760:12;25839:21;25760:12;25839:21;25854:1;25839:8;:21;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;-1:-1;25825:35:0;;25707:161;-1:-1:-1;;;25707:161:0:o;22776:567::-;23055:2;23039:19;;23033:26;23100:2;23084:19;;23078:26;23149:2;23133:19;;23127:26;22884:7;;23033:26;23078;23155:3;23123:36;23190:2;23186:6;;23182:46;;;23214:2;23209:7;23182:46;23247:88;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;23247:88:0;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;23247:88:0;;-1:-1:-1;;23247:88:0;;;22776:567;-1:-1:-1;;;;;;;22776:567:0:o;25580:119::-;25654:12;;:37;;;-1:-1:-1;;;25654:37:0;;25685:4;25654:37;;;;;;25627:7;;-1:-1:-1;;;;;25654:12:0;;:22;;:37;;;;;;;;;;;;;;:12;:37;;;5:2:-1;;;;30:1;27;20:12;5:2;25654:37:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;25654:37:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;25654:37:0;;-1:-1:-1;25580:119:0;:::o;12008:178::-;12068:7;12097:2;12092;:7;12088:91;;;-1:-1:-1;12123:2:0;12116:9;;12088:91;-1:-1:-1;12165:2:0;12158:9;

bzzr://e8f3a90d50094a7f6b547f7c9e6bb94e202568f3bd4ee311fc421b9d091bb1f6