Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract Context
•    - function _msgSender()
•    - function _msgData()
•  contract Ownable is Context
•    - function owner()
•    - function isOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• 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 ...
•  contract ERC20 is Context, IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(address sender, ad ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _burnFrom(address account, u ...
• library UintLibrary
•    - function toString(uint256 _i)
• library StringLibrary
•    - function append(string memory _a, str ...
•    - function append(string memory _a, str ...
•    - function recover(string memory messag ...
•    - function concat(bytes memory _ba, byt ...
• library AddressLibrary
•    - function toString(address _addr)
•  contract RareClaim is Ownable *
•    - function claim(Balance memory _balanc ...
•    - function doOverride(Balance memory _b ...
•    - function prepareMessage(Balance memor ...
•    - function toString(bytes32 value)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-02-19
*/

pragma solidity ^0.5.0;
pragma experimental ABIEncoderV2;


/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor () internal { }
    // solhint-disable-previous-line no-empty-blocks

    function _msgSender() internal view returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @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.
 *
 * 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.
 */
contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return _msgSender() == _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 onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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 onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     *
     * _Available since v2.4.0._
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    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;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        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;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20Mintable}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for `sender`'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: burn from the zero address");

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
    }
}

library UintLibrary {
    function toString(uint256 _i) internal pure returns (string memory) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len - 1;
        while (_i != 0) {
            bstr[k--] = byte(uint8(48 + _i % 10));
            _i /= 10;
        }
        return string(bstr);
    }
}

library StringLibrary {
    using UintLibrary for uint256;

    function append(string memory _a, string memory _b) internal pure returns (string memory) {
        bytes memory _ba = bytes(_a);
        bytes memory _bb = bytes(_b);
        bytes memory bab = new bytes(_ba.length + _bb.length);
        uint k = 0;
        for (uint i = 0; i < _ba.length; i++) bab[k++] = _ba[i];
        for (uint i = 0; i < _bb.length; i++) bab[k++] = _bb[i];
        return string(bab);
    }

    function append(string memory _a, string memory _b, string memory _c) internal pure returns (string memory) {
        bytes memory _ba = bytes(_a);
        bytes memory _bb = bytes(_b);
        bytes memory _bc = bytes(_c);
        bytes memory bbb = new bytes(_ba.length + _bb.length + _bc.length);
        uint k = 0;
        for (uint i = 0; i < _ba.length; i++) bbb[k++] = _ba[i];
        for (uint i = 0; i < _bb.length; i++) bbb[k++] = _bb[i];
        for (uint i = 0; i < _bc.length; i++) bbb[k++] = _bc[i];
        return string(bbb);
    }

    function recover(string memory message, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        bytes memory msgBytes = bytes(message);
        bytes memory fullMessage = concat(
            bytes("\x19Ethereum Signed Message:\n"),
            bytes(msgBytes.length.toString()),
            msgBytes,
            new bytes(0), new bytes(0), new bytes(0), new bytes(0)
        );
        return ecrecover(keccak256(fullMessage), v, r, s);
    }

    function concat(bytes memory _ba, bytes memory _bb, bytes memory _bc, bytes memory _bd, bytes memory _be, bytes memory _bf, bytes memory _bg) internal pure returns (bytes memory) {
        bytes memory resultBytes = new bytes(_ba.length + _bb.length + _bc.length + _bd.length + _be.length + _bf.length + _bg.length);
        uint k = 0;
        for (uint i = 0; i < _ba.length; i++) resultBytes[k++] = _ba[i];
        for (uint i = 0; i < _bb.length; i++) resultBytes[k++] = _bb[i];
        for (uint i = 0; i < _bc.length; i++) resultBytes[k++] = _bc[i];
        for (uint i = 0; i < _bd.length; i++) resultBytes[k++] = _bd[i];
        for (uint i = 0; i < _be.length; i++) resultBytes[k++] = _be[i];
        for (uint i = 0; i < _bf.length; i++) resultBytes[k++] = _bf[i];
        for (uint i = 0; i < _bg.length; i++) resultBytes[k++] = _bg[i];
        return resultBytes;
    }
}

library AddressLibrary {
    function toString(address _addr) internal pure returns (string memory) {
        bytes32 value = bytes32(uint256(_addr));
        bytes memory alphabet = "0123456789abcdef";
        bytes memory str = new bytes(42);
        str[0] = '0';
        str[1] = 'x';
        for (uint256 i = 0; i < 20; i++) {
            str[2+i*2] = alphabet[uint8(value[i + 12] >> 4)];
            str[3+i*2] = alphabet[uint8(value[i + 12] & 0x0f)];
        }
        return string(str);
    }
}

contract RareClaim is Ownable {
    using SafeMath for uint;
    using StringLibrary for string;
    using UintLibrary for uint;
    using AddressLibrary for address;

    event Claim(address indexed owner, uint value);
    event Value(address indexed owner, uint value);

    struct Balance {
        address recipient;
        uint256 value;
    }
    
    ERC20 public token;
    address public tokenOwner;
    mapping(address => uint) public claimed;

    constructor(ERC20 _token, address _tokenOwner) public {
        token = _token;
        tokenOwner = _tokenOwner;
    }

    function claim(Balance memory _balances, uint8 v, bytes32 r, bytes32 s) public {
        string memory messageSigned = prepareMessage(_balances);
        address ownerOf = StringLibrary.recover(messageSigned, v, r, s);
        require(ownerOf == owner(), "owner should sign balance");

        address recipient = _balances.recipient;
        
        if(msg.sender == recipient) {
            uint toClaim = _balances.value.sub(claimed[recipient]);
            require(toClaim > 0, "nothing to claim");
            claimed[recipient] = _balances.value;
            require(token.transferFrom(tokenOwner, msg.sender, toClaim), "transfer is not successful");
            emit Claim(recipient, toClaim);
            emit Value(recipient, _balances.value);
            return;
        }

        revert("msg.sender not found");
    }

    function doOverride(Balance memory _balances) public onlyOwner {
        claimed[_balances.recipient] = _balances.value;
        emit Value(_balances.recipient, _balances.value);
    }

    function prepareMessage(Balance memory _balances) internal pure returns (string memory) {
        return toString(keccak256(abi.encode(_balances)));
    }

    function toString(bytes32 value) internal pure returns (string memory) {
        bytes memory alphabet = "0123456789abcdef";
        bytes memory str = new bytes(64);
        for (uint256 i = 0; i < 32; i++) {
            str[i*2] = alphabet[uint8(value[i] >> 4)];
            str[1+i*2] = alphabet[uint8(value[i] & 0x0f)];
        }
        return string(str);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract ERC20","name":"_token","type":"address"},{"internalType":"address","name":"_tokenOwner","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Value","type":"event"},{"constant":false,"inputs":[{"components":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct RareClaim.Balance","name":"_balances","type":"tuple"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"claim","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"claimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"components":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct RareClaim.Balance","name":"_balances","type":"tuple"}],"name":"doOverride","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"token","outputs":[{"internalType":"contract ERC20","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tokenOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000093dfaf57d986b9ca77df9376c50878e013d9c7c80000000000000000000000005397fdd0ec9db88f3493f89c310a030493dc1d63

-----Decoded View---------------
Arg [0] : _token (address): 0x93dfaf57D986B9cA77Df9376c50878E013D9c7C8
Arg [1] : _tokenOwner (address): 0x5397FDD0EC9Db88f3493F89c310A030493DC1d63

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 00000000000000000000000093dfaf57d986b9ca77df9376c50878e013d9c7c8
Arg [1] : 0000000000000000000000005397fdd0ec9db88f3493f89c310a030493dc1d63

23499:2201:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23499:2201:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24107:848;;;;;;;;;:::i;:::-;;24963:187;;;;;;;;;:::i;2863:140::-;;;:::i;2052:79::-;;;:::i;:::-;;;;;;;;;;;;;;;;2418:94;;;:::i;:::-;;;;;;;;23897:25;;;:::i;23929:39::-;;;;;;;;;:::i;:::-;;;;;;;;3158:109;;;;;;;;;:::i;23872:18::-;;;:::i;:::-;;;;;;;;24107:848;24197:27;24227:25;24242:9;24227:14;:25::i;:::-;24197:55;;24263:15;24281:45;24303:13;24318:1;24321;24324;24281:21;:45::i;:::-;24263:63;;24356:7;:5;:7::i;:::-;-1:-1:-1;;;;;24345:18:0;:7;-1:-1:-1;;;;;24345:18:0;;24337:56;;;;-1:-1:-1;;;24337:56:0;;;;;;;;;;;;;;;;;24426:19;;24469:10;-1:-1:-1;;;;;24469:23:0;;;24466:439;;;-1:-1:-1;;;;;24544:18:0;;24509:12;24544:18;;;:7;:18;;;;;;;;24524:15;;;;:39;;;:19;:39;:::i;:::-;24509:54;;24596:1;24586:7;:11;24578:40;;;;-1:-1:-1;;;24578:40:0;;;;;;;;;24654:15;;;;;-1:-1:-1;;;;;24633:18:0;;;;;;;:7;:18;;;;;;;;:36;;;;24692:5;;24711:10;;24692:51;;-1:-1:-1;;;24692:51:0;;:5;;;;:18;;:51;;24711:10;;;24723;;24735:7;;24692:51;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;24692:51:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24692:51:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;24692:51:0;;;;;;;;;24684:90;;;;-1:-1:-1;;;24684:90:0;;;;;;;;;24800:9;-1:-1:-1;;;;;24794:25:0;;24811:7;24794:25;;;;;;;;;;;;;;;24845:9;-1:-1:-1;;;;;24839:33:0;;24856:9;:15;;;24839:33;;;;;;;;;;;;;;;24887:7;;;;;;24466:439;24917:30;;-1:-1:-1;;;24917:30:0;;;;;;;;24107:848;;;;;:::o;24963:187::-;2264:9;:7;:9::i;:::-;2256:54;;;;-1:-1:-1;;;2256:54:0;;;;;;;;;25068:15;;;;;;25045:19;;-1:-1:-1;;;;;25037:28:0;;;;;;;:7;:28;;;;;;;;:46;;;;25105:19;;25126:15;;25099:43;;;;;;;;;25126:15;25099:43;;;;;;;;;;24963:187;:::o;2863:140::-;2264:9;:7;:9::i;:::-;2256:54;;;;-1:-1:-1;;;2256:54:0;;;;;;;;;2962:1;2946:6;;2925:40;;-1:-1:-1;;;;;2946:6:0;;;;2925:40;;2962:1;;2925:40;2993:1;2976:19;;-1:-1:-1;;;;;;2976:19:0;;;2863:140::o;2052:79::-;2090:7;2117:6;-1:-1:-1;;;;;2117:6:0;2052:79;:::o;2418:94::-;2458:4;2498:6;;-1:-1:-1;;;;;2498:6:0;2482:12;:10;:12::i;:::-;-1:-1:-1;;;;;2482:22:0;;2475:29;;2418:94;:::o;23897:25::-;;;-1:-1:-1;;;;;23897:25:0;;:::o;23929:39::-;;;;;;;;;;;;;:::o;3158:109::-;2264:9;:7;:9::i;:::-;2256:54;;;;-1:-1:-1;;;2256:54:0;;;;;;;;;3231:28;3250:8;3231:18;:28::i;:::-;3158:109;:::o;23872:18::-;;;-1:-1:-1;;;;;23872:18:0;;:::o;25158:156::-;25231:13;25264:42;25294:9;25283:21;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;25283:21:0;;;25273:32;;;;;;25264:8;:42::i;:::-;25257:49;;25158:156;;;;:::o;21603:469::-;21697:7;21717:21;21747:7;21717:38;;21766:24;21793:211;21814:39;;;;;;;;;;;;;;;;;21874:26;:8;:15;:24;:26::i;:::-;21939:12;;;21949:1;21939:12;;;;;;21953;;;;;;21967;;;;;;21981;;;;;;;;;21916:8;;21939:12;;21793:6;:211::i;:::-;21766:238;;22022:42;22042:11;22032:22;;;;;;22056:1;22059;22062;22022:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;22022:42:0;;;;;;;;22015:49;;;;21603:469;;;;;;;:::o;7691:136::-;7749:7;7776:43;7780:1;7783;7776:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;7769:50;;7691:136;;;;;:::o;843:98::-;923:10;843:98;:::o;3373:229::-;-1:-1:-1;;;;;3447:22:0;;3439:73;;;;-1:-1:-1;;;3439:73:0;;;;;;;;;3549:6;;;3528:38;;-1:-1:-1;;;;;3528:38:0;;;;3549:6;;;3528:38;;;3577:6;:17;;-1:-1:-1;;;;;;3577:17:0;-1:-1:-1;;;;;3577:17:0;;;;;;;;;;3373:229::o;25322:375::-;25404:42;;;;;;;;;;;-1:-1:-1;;;25404:42:0;;;;25476:13;;;;;25378;25476;;;;;25378;;;25476;;;;21:6:-1;;104:10;25476:13:0;87:34:-1;135:17;;-1:-1;;25457:32:0;-1:-1:-1;25505:9:0;25500:161;25524:2;25520:1;:6;25500:161;;;25559:8;25586:1;25574:5;25580:1;25574:8;;;;;;;;;;-1:-1:-1;;;;;25574:13:0;;;;25568:20;;25559:30;;;;;;;;;;;;;;;;;;25548:3;25552:1;25554;25552:3;25548:8;;;;;;;;;;;:41;-1:-1:-1;;;;;25548:41:0;;;;;;;;;25617:8;25632:5;25638:1;25632:8;;;;;;;25617:32;;25632:8;;;25643:4;25626:22;;25617:32;;;;;;;;;;;;;;25604:3;25610:1;25612;25610:3;25608:1;:5;25604:10;;;;;;;;;;;:45;-1:-1:-1;;;;;25604:45:0;;;;;;;;-1:-1:-1;25528:3:0;;25500:161;;;-1:-1:-1;25685:3:0;25322:375;-1:-1:-1;;;25322:375:0:o;20062:471::-;20115:13;20145:7;20141:50;;-1:-1:-1;20169:10:0;;;;;;;;;;;;-1:-1:-1;;;20169:10:0;;;;;;20141:50;20210:2;20201:6;20242:69;20249:6;;20242:69;;20272:5;;20297:2;20292:7;;;;20242:69;;;20321:17;20351:3;20341:14;;;;;;;;;;;;;;;;;;;;;;;;;21:6:-1;;104:10;20341:14:0;87:34:-1;135:17;;-1:-1;20341:14:0;-1:-1:-1;20321:34:0;-1:-1:-1;;;20375:7:0;;20393:103;20400:7;;20393:103;;20457:2;20452;:7;20447:2;:12;20436:25;;20424:4;20429:3;;;;;;;20424:9;;;;;;;;;;;:37;-1:-1:-1;;;;;20424:37:0;;;;;;;;-1:-1:-1;20482:2:0;20476:8;;;;20393:103;;;-1:-1:-1;20520:4:0;20062:471;-1:-1:-1;;;;20062:471:0:o;22080:892::-;22245:12;22270:24;22385:3;:10;22372:3;:10;22359:3;:10;22346:3;:10;22333:3;:10;22320:3;:10;22307:3;:10;:23;:36;:49;:62;:75;:88;22297:99;;;;;;;;;;;;;;;;;;;;;;;;;21:6:-1;;104:10;22297:99:0;87:34:-1;135:17;;-1:-1;22297:99:0;-1:-1:-1;22270:126:0;-1:-1:-1;22407:6:0;;22428:63;22449:3;:10;22445:1;:14;22428:63;;;22485:3;22489:1;22485:6;;;;;;;;;;;;;;;;22466:11;22478:3;;;;;;22466:16;;;;;;;;;;;:25;-1:-1:-1;;;;;22466:25:0;;;;;;;;-1:-1:-1;22461:3:0;;22428:63;;;-1:-1:-1;22507:6:0;22502:63;22523:3;:10;22519:1;:14;22502:63;;;22559:3;22563:1;22559:6;;;;;;;;;;;;;;;;22540:11;22552:3;;;;;;22540:16;;;;;;;;;;;:25;-1:-1:-1;;;;;22540:25:0;;;;;;;;-1:-1:-1;22535:3:0;;22502:63;;;-1:-1:-1;22581:6:0;22576:63;22597:3;:10;22593:1;:14;22576:63;;;22633:3;22637:1;22633:6;;;;;;;;;;;;;;;;22614:11;22626:3;;;;;;22614:16;;;;;;;;;;;:25;-1:-1:-1;;;;;22614:25:0;;;;;;;;-1:-1:-1;22609:3:0;;22576:63;;;-1:-1:-1;22655:6:0;22650:63;22671:3;:10;22667:1;:14;22650:63;;;22707:3;22711:1;22707:6;;;;;;;;;;;;;;;;22688:11;22700:3;;;;;;22688:16;;;;;;;;;;;:25;-1:-1:-1;;;;;22688:25:0;;;;;;;;-1:-1:-1;22683:3:0;;22650:63;;;-1:-1:-1;22729:6:0;22724:63;22745:3;:10;22741:1;:14;22724:63;;;22781:3;22785:1;22781:6;;;;;;;;;;;;;;;;22762:11;22774:3;;;;;;22762:16;;;;;;;;;;;:25;-1:-1:-1;;;;;22762:25:0;;;;;;;;-1:-1:-1;22757:3:0;;22724:63;;;-1:-1:-1;22803:6:0;22798:63;22819:3;:10;22815:1;:14;22798:63;;;22855:3;22859:1;22855:6;;;;;;;;;;;;;;;;22836:11;22848:3;;;;;;22836:16;;;;;;;;;;;:25;-1:-1:-1;;;;;22836:25:0;;;;;;;;-1:-1:-1;22831:3:0;;22798:63;;;-1:-1:-1;22877:6:0;22872:63;22893:3;:10;22889:1;:14;22872:63;;;22929:3;22933:1;22929:6;;;;;;;;;;;;;;;;22910:11;22922:3;;;;;;22910:16;;;;;;;;;;;:25;-1:-1:-1;;;;;22910:25:0;;;;;;;;-1:-1:-1;22905:3:0;;22872:63;;;-1:-1:-1;22953:11:0;;22080:892;-1:-1:-1;;;;;;;;;22080:892:0:o;8164:192::-;8250:7;8286:12;8278:6;;;;8270:29;;;;-1:-1:-1;;;8270:29:0;;;;;;;;;;-1:-1:-1;;;8322:5:0;;;8164:192::o;5:130:-1:-;72:20;;97:33;72:20;97:33;;142:128;217:13;;235:30;217:13;235:30;;277:130;344:20;;369:33;344:20;369:33;;445:473;;559:4;547:9;542:3;538:19;534:30;531:2;;;577:1;574;567:12;531:2;595:20;610:4;595:20;;;586:29;-1:-1;670:1;702:49;747:3;727:9;702:49;;;677:75;;-1:-1;814:2;847:49;892:3;868:22;;;847:49;;;840:4;833:5;829:16;822:75;773:135;525:393;;;;;1062:126;1127:20;;1152:31;1127:20;1152:31;;1195:241;;1299:2;1287:9;1278:7;1274:23;1270:32;1267:2;;;1315:1;1312;1305:12;1267:2;1350:1;1367:53;1412:7;1392:9;1367:53;;1443:257;;1555:2;1543:9;1534:7;1530:23;1526:32;1523:2;;;1571:1;1568;1561:12;1523:2;1606:1;1623:61;1676:7;1656:9;1623:61;;1707:291;;1836:2;1824:9;1815:7;1811:23;1807:32;1804:2;;;1852:1;1849;1842:12;1804:2;1887:1;1904:78;1974:7;1954:9;1904:78;;2005:664;;;;;2183:3;2171:9;2162:7;2158:23;2154:33;2151:2;;;2200:1;2197;2190:12;2151:2;2235:1;2252:78;2322:7;2302:9;2252:78;;;2242:88;;2214:122;2367:2;2385:51;2428:7;2419:6;2408:9;2404:22;2385:51;;;2375:61;;2346:96;2473:2;2491:53;2536:7;2527:6;2516:9;2512:22;2491:53;;;2481:63;;2452:98;2581:3;2600:53;2645:7;2636:6;2625:9;2621:22;2600:53;;;2590:63;;2560:99;2145:524;;;;;;;;2676:142;2767:45;2806:5;2767:45;;;2762:3;2755:58;2749:69;;;2825:103;2898:24;2916:5;2898:24;;3055:104;3132:21;3147:5;3132:21;;3166:113;3249:24;3267:5;3249:24;;3286:152;3382:50;3426:5;3382:50;;3445:347;;3557:39;3590:5;3557:39;;;3608:71;3672:6;3667:3;3608:71;;;3601:78;;3684:52;3729:6;3724:3;3717:4;3710:5;3706:16;3684:52;;;3757:29;3779:6;3757:29;;;3748:39;;;;3537:255;-1:-1;;;3537:255;3800:375;;3960:67;4024:2;4019:3;3960:67;;;4060:34;4040:55;;-1:-1;;;4124:2;4115:12;;4108:30;4166:2;4157:12;;3946:229;-1:-1;;3946:229;4184:325;;4344:67;4408:2;4403:3;4344:67;;;4444:27;4424:48;;4500:2;4491:12;;4330:179;-1:-1;;4330:179;4518:320;;4678:67;4742:2;4737:3;4678:67;;;-1:-1;;;4758:43;;4829:2;4820:12;;4664:174;-1:-1;;4664:174;4847:316;;5007:67;5071:2;5066:3;5007:67;;;-1:-1;;;5087:39;;5154:2;5145:12;;4993:170;-1:-1;;4993:170;5172:332;;5332:67;5396:2;5391:3;5332:67;;;5432:34;5412:55;;5495:2;5486:12;;5318:186;-1:-1;;5318:186;5513:326;;5673:67;5737:2;5732:3;5673:67;;;5773:28;5753:49;;5830:2;5821:12;;5659:180;-1:-1;;5659:180;5906:482;6120:23;;6049:4;6040:14;;;6149:63;6044:3;6120:23;6149:63;;;6069:149;6292:4;6285:5;6281:16;6275:23;6304:63;6361:4;6356:3;6352:14;6338:12;6304:63;;6625:107;6704:22;6720:5;6704:22;;6739:213;6857:2;6842:18;;6871:71;6846:9;6915:6;6871:71;;6959:451;7141:2;7126:18;;7155:71;7130:9;7199:6;7155:71;;;7237:80;7313:2;7302:9;7298:18;7289:6;7237:80;;;7328:72;7396:2;7385:9;7381:18;7372:6;7328:72;;7417:201;7529:2;7514:18;;7543:65;7518:9;7581:6;7543:65;;7625:539;7823:3;7808:19;;7838:71;7812:9;7882:6;7838:71;;;7920:68;7984:2;7973:9;7969:18;7960:6;7920:68;;;7999:72;8067:2;8056:9;8052:18;8043:6;7999:72;;;8082;8150:2;8139:9;8135:18;8126:6;8082:72;;;7794:370;;;;;;;;8171:239;8302:2;8287:18;;8316:84;8291:9;8373:6;8316:84;;8417:301;8555:2;8569:47;;;8540:18;;8630:78;8540:18;8694:6;8630:78;;8725:407;8916:2;8930:47;;;8901:18;;8991:131;8901:18;8991:131;;9139:407;9330:2;9344:47;;;9315:18;;9405:131;9315:18;9405:131;;9553:407;9744:2;9758:47;;;9729:18;;9819:131;9729:18;9819:131;;9967:407;10158:2;10172:47;;;10143:18;;10233:131;10143:18;10233:131;;10381:407;10572:2;10586:47;;;10557:18;;10647:131;10557:18;10647:131;;10795:407;10986:2;11000:47;;;10971:18;;11061:131;10971:18;11061:131;;11209:313;11377:2;11362:18;;11391:121;11366:9;11485:6;11391:121;;11529:213;11647:2;11632:18;;11661:71;11636:9;11705:6;11661:71;;11749:256;11811:2;11805:9;11837:17;;;11912:18;11897:34;;11933:22;;;11894:62;11891:2;;;11969:1;11966;11959:12;11891:2;11985;11978:22;11789:216;;-1:-1;11789:216;12012:122;12100:12;;12071:63;12142:163;12245:19;;;12294:4;12285:14;;12238:67;12313:91;;12375:24;12393:5;12375:24;;12411:85;12477:13;12470:21;;12453:43;12503:72;12565:5;12548:27;12582:121;-1:-1;;;;;12644:54;;12627:76;12789:81;12860:4;12849:16;;12832:38;12877:129;;12964:37;12995:5;13013:147;;13105:50;13149:5;13105:50;;13539:268;13604:1;13611:101;13625:6;13622:1;13619:13;13611:101;;;13692:11;;;13686:18;13673:11;;;13666:39;13647:2;13640:10;13611:101;;;13727:6;13724:1;13721:13;13718:2;;;-1:-1;;13792:1;13774:16;;13767:27;13588:219;13815:97;13903:2;13883:14;-1:-1;;13879:28;;13863:49;13920:117;13989:24;14007:5;13989:24;;;13982:5;13979:35;13969:2;;14028:1;14025;14018:12;14044:111;14110:21;14125:5;14110:21;;14162:117;14231:24;14249:5;14231:24;;14410:113;14477:22;14493:5;14477:22;

bzzr://c26f99e097a7bc433730ff7276a7294afe4238c36e2381249f7dd1292936015b