Token Levolution.io Token

 

Overview [ERC-20]

Price
$0.00 @ 0.000003 Eth (+0.23%)
Fully Diluted Market Cap
Max Total Supply:
311,000,000 LEVL

Holders:
842
 
Balance
9,235,639.449180795793772779 LEVL

Value
$29,452.36 ( ~24.1375 Eth) [2.9697%]
0x6d57129430f30fe1ea03e2aea78b5e134263f3d4
Loading
[ Download CSV Export  ] 
Loading
[ Download CSV Export  ] 
Loading

OVERVIEW

Levolution is an all-in-one platform that makes it easy for blockchain entrepreneurs to create, develop, market and optimize ITO projects.

Profitability / Loss

Since Initial Offer Price
:ETH 0.002 99.85%

Market

Volume (24H):$0.03
Market Capitalization:$0.00
Circulating Supply:0.00 LEVL
Market Data Source: Coinmarketcap

ICO Information

ICO Start Date : Jan 2, 2019  
ICO End Date : Mar 15, 2019
Total Cap : 225,000,000 LEVL
Hard Cap : 465,000 ETH
Soft Cap : 14,000 ETH
Token Distribution Date : Apr 8, 2019
ICO Price  : 0.002 ETH
Bonus : 50% / 35% / 10% 
Country : Cayman Islands

# Exchange Pair Price  24H Volume % Volume
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
Token

Compiler Version
v0.5.7+commit.6da8b019

Optimization Enabled:
Yes with 200 runs

Other Settings:
byzantium EvmVersion

Contract Source Code (Solidity Multiple files format)

File 12 of 12: Token.sol
pragma solidity ^0.5.0;

import "Ownable.sol";
import "ERC20Detailed.sol";
import "ERC20Pausable.sol";
import "ERC20Burnable.sol";
import "ERC20.sol";
import "ECDSA.sol";
import "SafeMath.sol";

contract Token is ERC20, ERC20Detailed, ERC20Pausable, ERC20Burnable, Ownable {
    using ECDSA for bytes32;
    using SafeMath for uint256;

    event HashRedeemed(bytes32 indexed txHash, address indexed from);

    constructor(
        string memory name,
        string memory symbol,
        uint8 decimals,
        uint256 initialSupply
    )
        ERC20Pausable()
        ERC20Burnable()
        ERC20Detailed(name, symbol, decimals)
        ERC20()
        public
    {
        require(initialSupply > 0);
        _mint(msg.sender, initialSupply);
    }

    /**
     * Returns the circulating supply (total supply minus tokens held by owner)
     */
    function circulatingSupply() public view returns (uint256) {
        return totalSupply().sub(balanceOf(owner()));
    }

    /**
     * Owner can withdraw any ERC20 token received by the contract
     */
    function transferAnyERC20Token(address tokenAddress, uint256 tokens) public onlyOwner returns (bool success) {
        return ERC20(tokenAddress).transfer(owner(), tokens);
    }

    mapping(bytes32 => bool) invalidHashes;

    /**
     * Transfer tokens as the owner on his behalf for signer of signature.
     *
     * @param to address The address which you want to transfer to.
     * @param value uint256 The amount of tokens to be transferred.
     * @param gasPrice uint256 The price in tokens that will be paid per unit of gas.
     * @param nonce uint256 The unique transaction number per user.
     * @param signature bytes The signature of the signer.
     */
    function transferPreSigned(
        address to,
        uint256 value,
        uint256 gasPrice,
        uint256 nonce,
        bytes memory signature
    )
        public
        whenNotPaused
        returns (bool)
    {
        uint256 gas = gasleft();

        require(to != address(0));

        bytes32 payloadHash = transferPreSignedPayloadHash(address(this), to, value, gasPrice, nonce);

        // Recover signer address from signature
        address from = payloadHash.toEthSignedMessageHash().recover(signature);
        require(from != address(0), "Invalid signature provided.");

        // Generate transaction hash
        bytes32 txHash = keccak256(abi.encodePacked(from, payloadHash));

        // Make sure this transfer didn't happen yet
        require(!invalidHashes[txHash], "Transaction has already been executed.");

        // Mark hash as used
        invalidHashes[txHash] = true;

        // Initiate token transfer
        _transfer(from, to, value);

        // If a gas price is set, pay the sender of this transaction in tokens
        uint256 fee = 0;
        if (gasPrice > 0) {
            // 21000 base + ~14000 transfer + ~10000 event
            gas = 21000 + 14000 + 10000 + gas.sub(gasleft());
            fee = gasPrice.mul(gas);
            _transfer(from, tx.origin, fee);
        }

        emit HashRedeemed(txHash, from);

        return true;
    }

    /**
     * Calculates the hash for the payload used by transferPreSigned
     *
     * @param token address The address of this token.
     * @param to address The address which you want to transfer to.
     * @param value uint256 The amount of tokens to be transferred.
     * @param gasPrice uint256 The price in tokens that will be paid per unit of gas.
     * @param nonce uint256 The unique transaction number per user.
     */
    function transferPreSignedPayloadHash(
        address token,
        address to,
        uint256 value,
        uint256 gasPrice,
        uint256 nonce
    )
        public
        pure
        returns (bytes32)
    {
        /* "452d3c59": transferPreSignedPayloadHash(address,address,uint256,uint256,uint256) */
        return keccak256(abi.encodePacked(bytes4(0x452d3c59), token, to, value, gasPrice, nonce));
    }
}

File 1 of 12: ECDSA.sol
pragma solidity ^0.5.2;

/**
 * @title Elliptic curve signature operations
 * @dev Based on https://gist.github.com/axic/5b33912c6f61ae6fd96d6c4a47afde6d
 * TODO Remove this library once solidity supports passing a signature to ecrecover.
 * See https://github.com/ethereum/solidity/issues/864
 */

library ECDSA {
    /**
     * @dev Recover signer address from a message by using their signature
     * @param hash bytes32 message, the hash is the signed message. What is recovered is the signer address.
     * @param signature bytes signature, the signature is generated using web3.eth.sign()
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        // Check the signature length
        if (signature.length != 65) {
            return (address(0));
        }

        // Divide the signature in r, s and v variables
        bytes32 r;
        bytes32 s;
        uint8 v;

        // ecrecover takes the signature parameters, and the only way to get them
        // currently is to use assembly.
        // solhint-disable-next-line no-inline-assembly
        assembly {
            r := mload(add(signature, 0x20))
            s := mload(add(signature, 0x40))
            v := byte(0, mload(add(signature, 0x60)))
        }

        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return address(0);
        }

        if (v != 27 && v != 28) {
            return address(0);
        }

        // If the signature is valid (and not malleable), return the signer address
        return ecrecover(hash, v, r, s);
    }

    /**
     * toEthSignedMessageHash
     * @dev prefix a bytes32 value with "\x19Ethereum Signed Message:"
     * and hash the result
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }
}

File 2 of 12: ERC20.sol
pragma solidity ^0.5.2;

import "IERC20.sol";
import "SafeMath.sol";

/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * https://eips.ethereum.org/EIPS/eip-20
 * Originally based on code by FirstBlood:
 * https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 *
 * This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
 * all accounts just by listening to said events. Note that this isn't required by the specification, and other
 * compliant implementations may not do it.
 */
contract ERC20 is IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

    /**
     * @dev Total number of tokens in existence
     */
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev Gets the balance of the specified address.
     * @param owner The address to query the balance of.
     * @return A uint256 representing the amount owned by the passed address.
     */
    function balanceOf(address owner) public view returns (uint256) {
        return _balances[owner];
    }

    /**
     * @dev Function to check the amount of tokens that an owner allowed to a spender.
     * @param owner address The address which owns the funds.
     * @param spender address The address which will spend the funds.
     * @return A uint256 specifying the amount of tokens still available for the spender.
     */
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowed[owner][spender];
    }

    /**
     * @dev Transfer token to a specified address
     * @param to The address to transfer to.
     * @param value The amount to be transferred.
     */
    function transfer(address to, uint256 value) public returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    /**
     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
     * 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
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     */
    function approve(address spender, uint256 value) public returns (bool) {
        _approve(msg.sender, spender, value);
        return true;
    }

    /**
     * @dev Transfer tokens from one address to another.
     * Note that while this function emits an Approval event, this is not required as per the specification,
     * and other compliant implementations may not emit the event.
     * @param from address The address which you want to send tokens from
     * @param to address The address which you want to transfer to
     * @param value uint256 the amount of tokens to be transferred
     */
    function transferFrom(address from, address to, uint256 value) public returns (bool) {
        _transfer(from, to, value);
        _approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
        return true;
    }

    /**
     * @dev Increase the amount of tokens that an owner allowed to a spender.
     * approve should be called when _allowed[msg.sender][spender] == 0. To increment
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * Emits an Approval event.
     * @param spender The address which will spend the funds.
     * @param addedValue The amount of tokens to increase the allowance by.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Decrease the amount of tokens that an owner allowed to a spender.
     * approve should be called when _allowed[msg.sender][spender] == 0. To decrement
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * Emits an Approval event.
     * @param spender The address which will spend the funds.
     * @param subtractedValue The amount of tokens to decrease the allowance by.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
        return true;
    }

    /**
     * @dev Transfer token for a specified addresses
     * @param from The address to transfer from.
     * @param to The address to transfer to.
     * @param value The amount to be transferred.
     */
    function _transfer(address from, address to, uint256 value) internal {
        require(to != address(0));

        _balances[from] = _balances[from].sub(value);
        _balances[to] = _balances[to].add(value);
        emit Transfer(from, to, value);
    }

    /**
     * @dev Internal function that mints an amount of the token and assigns it to
     * an account. This encapsulates the modification of balances such that the
     * proper events are emitted.
     * @param account The account that will receive the created tokens.
     * @param value The amount that will be created.
     */
    function _mint(address account, uint256 value) internal {
        require(account != address(0));

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

    /**
     * @dev Internal function that burns an amount of the token of a given
     * account.
     * @param account The account whose tokens will be burnt.
     * @param value The amount that will be burnt.
     */
    function _burn(address account, uint256 value) internal {
        require(account != address(0));

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

    /**
     * @dev Approve an address to spend another addresses' tokens.
     * @param owner The address that owns the tokens.
     * @param spender The address that will spend the tokens.
     * @param value The number of tokens that can be spent.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        require(spender != address(0));
        require(owner != address(0));

        _allowed[owner][spender] = value;
        emit Approval(owner, spender, value);
    }

    /**
     * @dev Internal function that burns an amount of the token of a given
     * account, deducting from the sender's allowance for said account. Uses the
     * internal burn function.
     * Emits an Approval event (reflecting the reduced allowance).
     * @param account The account whose tokens will be burnt.
     * @param value The amount that will be burnt.
     */
    function _burnFrom(address account, uint256 value) internal {
        _burn(account, value);
        _approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
    }
}

File 3 of 12: ERC20Burnable.sol
pragma solidity ^0.5.2;

import "ERC20.sol";

/**
 * @title Burnable Token
 * @dev Token that can be irreversibly burned (destroyed).
 */
contract ERC20Burnable is ERC20 {
    /**
     * @dev Burns a specific amount of tokens.
     * @param value The amount of token to be burned.
     */
    function burn(uint256 value) public {
        _burn(msg.sender, value);
    }

    /**
     * @dev Burns a specific amount of tokens from the target address and decrements allowance
     * @param from address The account whose tokens will be burned.
     * @param value uint256 The amount of token to be burned.
     */
    function burnFrom(address from, uint256 value) public {
        _burnFrom(from, value);
    }
}

File 4 of 12: ERC20Detailed.sol
pragma solidity ^0.5.2;

import "IERC20.sol";

/**
 * @title ERC20Detailed token
 * @dev The decimals are only for visualization purposes.
 * All the operations are done using the smallest and indivisible token unit,
 * just as on Ethereum all the operations are done in wei.
 */
contract ERC20Detailed is IERC20 {
    string private _name;
    string private _symbol;
    uint8 private _decimals;

    constructor (string memory name, string memory symbol, uint8 decimals) public {
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
    }

    /**
     * @return the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @return the symbol of the token.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @return the number of decimals of the token.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }
}

File 5 of 12: ERC20Pausable.sol
pragma solidity ^0.5.2;

import "ERC20.sol";
import "Pausable.sol";

/**
 * @title Pausable token
 * @dev ERC20 modified with pausable transfers.
 */
contract ERC20Pausable is ERC20, Pausable {
    function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
        return super.transfer(to, value);
    }

    function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
        return super.transferFrom(from, to, value);
    }

    function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
        return super.approve(spender, value);
    }

    function increaseAllowance(address spender, uint addedValue) public whenNotPaused returns (bool success) {
        return super.increaseAllowance(spender, addedValue);
    }

    function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused returns (bool success) {
        return super.decreaseAllowance(spender, subtractedValue);
    }
}

File 6 of 12: IERC20.sol
pragma solidity ^0.5.2;

/**
 * @title ERC20 interface
 * @dev see https://eips.ethereum.org/EIPS/eip-20
 */
interface IERC20 {
    function transfer(address to, uint256 value) external returns (bool);

    function approve(address spender, uint256 value) external returns (bool);

    function transferFrom(address from, address to, uint256 value) external returns (bool);

    function totalSupply() external view returns (uint256);

    function balanceOf(address who) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

File 7 of 12: Ownable.sol
pragma solidity ^0.5.2;

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
    address private _owner;

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

    /**
     * @dev The Ownable constructor sets the original `owner` of the contract to the sender
     * account.
     */
    constructor () internal {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), _owner);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner());
        _;
    }

    /**
     * @return true if `msg.sender` is the owner of the contract.
     */
    function isOwner() public view returns (bool) {
        return msg.sender == _owner;
    }

    /**
     * @dev Allows the current owner to relinquish control of the contract.
     * It will not be possible to call the functions with the `onlyOwner`
     * modifier anymore.
     * @notice 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 Allows the current owner to transfer control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0));
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

File 8 of 12: Pausable.sol
pragma solidity ^0.5.2;

import "PauserRole.sol";

/**
 * @title Pausable
 * @dev Base contract which allows children to implement an emergency stop mechanism.
 */
contract Pausable is PauserRole {
    event Paused(address account);
    event Unpaused(address account);

    bool private _paused;

    constructor () internal {
        _paused = false;
    }

    /**
     * @return true if the contract is paused, false otherwise.
     */
    function paused() public view returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     */
    modifier whenNotPaused() {
        require(!_paused);
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     */
    modifier whenPaused() {
        require(_paused);
        _;
    }

    /**
     * @dev called by the owner to pause, triggers stopped state
     */
    function pause() public onlyPauser whenNotPaused {
        _paused = true;
        emit Paused(msg.sender);
    }

    /**
     * @dev called by the owner to unpause, returns to normal state
     */
    function unpause() public onlyPauser whenPaused {
        _paused = false;
        emit Unpaused(msg.sender);
    }
}

File 9 of 12: PauserRole.sol
pragma solidity ^0.5.2;

import "Roles.sol";

contract PauserRole {
    using Roles for Roles.Role;

    event PauserAdded(address indexed account);
    event PauserRemoved(address indexed account);

    Roles.Role private _pausers;

    constructor () internal {
        _addPauser(msg.sender);
    }

    modifier onlyPauser() {
        require(isPauser(msg.sender));
        _;
    }

    function isPauser(address account) public view returns (bool) {
        return _pausers.has(account);
    }

    function addPauser(address account) public onlyPauser {
        _addPauser(account);
    }

    function renouncePauser() public {
        _removePauser(msg.sender);
    }

    function _addPauser(address account) internal {
        _pausers.add(account);
        emit PauserAdded(account);
    }

    function _removePauser(address account) internal {
        _pausers.remove(account);
        emit PauserRemoved(account);
    }
}

File 10 of 12: Roles.sol
pragma solidity ^0.5.2;

/**
 * @title Roles
 * @dev Library for managing addresses assigned to a Role.
 */
library Roles {
    struct Role {
        mapping (address => bool) bearer;
    }

    /**
     * @dev give an account access to this role
     */
    function add(Role storage role, address account) internal {
        require(account != address(0));
        require(!has(role, account));

        role.bearer[account] = true;
    }

    /**
     * @dev remove an account's access to this role
     */
    function remove(Role storage role, address account) internal {
        require(account != address(0));
        require(has(role, account));

        role.bearer[account] = false;
    }

    /**
     * @dev check if an account has this role
     * @return bool
     */
    function has(Role storage role, address account) internal view returns (bool) {
        require(account != address(0));
        return role.bearer[account];
    }
}

File 11 of 12: SafeMath.sol
pragma solidity ^0.5.2;

/**
 * @title SafeMath
 * @dev Unsigned math operations with safety checks that revert on error
 */
library SafeMath {
    /**
     * @dev Multiplies two unsigned integers, reverts on 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-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b);

        return c;
    }

    /**
     * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Adds two unsigned integers, reverts on overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a);

        return c;
    }

    /**
     * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
     * reverts when dividing by zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0);
        return a % b;
    }
}

Contract Security Audit

Contract ABI

[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"spender","type":"address"},{"name":"value","type":"uint256"}],"name":"approve","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"from","type":"address"},{"name":"to","type":"address"},{"name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"spender","type":"address"},{"name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"unpause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"value","type":"uint256"}],"name":"burn","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"token","type":"address"},{"name":"to","type":"address"},{"name":"value","type":"uint256"},{"name":"gasPrice","type":"uint256"},{"name":"nonce","type":"uint256"}],"name":"transferPreSignedPayloadHash","outputs":[{"name":"","type":"bytes32"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[{"name":"account","type":"address"}],"name":"isPauser","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"paused","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renouncePauser","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"from","type":"address"},{"name":"value","type":"uint256"}],"name":"burnFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"account","type":"address"}],"name":"addPauser","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"pause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"circulatingSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"spender","type":"address"},{"name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"value","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"value","type":"uint256"},{"name":"gasPrice","type":"uint256"},{"name":"nonce","type":"uint256"},{"name":"signature","type":"bytes"}],"name":"transferPreSigned","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"tokenAddress","type":"address"},{"name":"tokens","type":"uint256"}],"name":"transferAnyERC20Token","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"owner","type":"address"},{"name":"spender","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"name","type":"string"},{"name":"symbol","type":"string"},{"name":"decimals","type":"uint8"},{"name":"initialSupply","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"txHash","type":"bytes32"},{"indexed":true,"name":"from","type":"address"}],"name":"HashRedeemed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"},{"indexed":true,"name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"account","type":"address"}],"name":"PauserAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"account","type":"address"}],"name":"PauserRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"owner","type":"address"},{"indexed":true,"name":"spender","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Approval","type":"event"}]

60806040523480156200001157600080fd5b50604051620018a7380380620018a7833981018060405260808110156200003757600080fd5b8101908080516401000000008111156200005057600080fd5b820160208101848111156200006457600080fd5b81516401000000008111828201871017156200007f57600080fd5b505092919060200180516401000000008111156200009c57600080fd5b82016020810184811115620000b057600080fd5b8151640100000000811182820187101715620000cb57600080fd5b50506020808301516040909301518651929550929350859185918591620000f9916003919086019062000375565b5081516200010f90600490602085019062000375565b506005805460ff191660ff92909216919091179055506200013b905033640100000000620001bd810204565b60078054600160a860020a0319166101003381029190911791829055604051600160a060020a039190920416906000907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a3600081116200019e57600080fd5b620001b333826401000000006200020f810204565b505050506200041a565b620001d8600682640100000000620013df620002cc82021704565b604051600160a060020a038216907f6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f890600090a250565b600160a060020a0382166200022357600080fd5b600254620002409082640100000000620013856200032582021704565b600255600160a060020a038216600090815260208190526040902054620002769082640100000000620013856200032582021704565b600160a060020a0383166000818152602081815260408083209490945583518581529351929391927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9281900390910190a35050565b600160a060020a038116620002e057600080fd5b620002f582826401000000006200033f810204565b156200030057600080fd5b600160a060020a0316600090815260209190915260409020805460ff19166001179055565b6000828201838110156200033857600080fd5b9392505050565b6000600160a060020a0382166200035557600080fd5b50600160a060020a03166000908152602091909152604090205460ff1690565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f10620003b857805160ff1916838001178555620003e8565b82800160010185558215620003e8579182015b82811115620003e8578251825591602001919060010190620003cb565b50620003f6929150620003fa565b5090565b6200041791905b80821115620003f6576000815560010162000401565b90565b61147d806200042a6000396000f3fe608060405234801561001057600080fd5b50600436106101c6576000357c010000000000000000000000000000000000000000000000000000000090048063715018a61161011657806395d89b41116100b4578063cf0f2bf81161008e578063cf0f2bf8146104dd578063dc39d06d146105a4578063dd62ed3e146105d0578063f2fde38b146105fe576101c6565b806395d89b411461047d578063a457c2d714610485578063a9059cbb146104b1576101c6565b80638456cb59116100f05780638456cb59146104415780638da5cb5b146104495780638f32d59b1461046d5780639358928b14610475576101c6565b8063715018a6146103e757806379cc6790146103ef57806382dc1ec41461041b576101c6565b80633f4ba83a1161018357806346fbf68e1161015d57806346fbf68e1461038b5780635c975abb146103b15780636ef8d66d146103b957806370a08231146103c1576101c6565b80633f4ba83a1461032257806342966c681461032c578063452d3c5914610349576101c6565b806306fdde03146101cb578063095ea7b31461024857806318160ddd1461028857806323b872dd146102a2578063313ce567146102d857806339509351146102f6575b600080fd5b6101d3610624565b6040805160208082528351818301528351919283929083019185019080838360005b8381101561020d5781810151838201526020016101f5565b50505050905090810190601f16801561023a5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6102746004803603604081101561025e57600080fd5b50600160a060020a0381351690602001356106ba565b604080519115158252519081900360200190f35b6102906106e0565b60408051918252519081900360200190f35b610274600480360360608110156102b857600080fd5b50600160a060020a038135811691602081013590911690604001356106e6565b6102e061070c565b6040805160ff9092168252519081900360200190f35b6102746004803603604081101561030c57600080fd5b50600160a060020a038135169060200135610715565b61032a610732565b005b61032a6004803603602081101561034257600080fd5b5035610792565b610290600480360360a081101561035f57600080fd5b50600160a060020a0381358116916020810135909116906040810135906060810135906080013561079f565b610274600480360360208110156103a157600080fd5b5035600160a060020a031661082b565b61027461083e565b61032a610847565b610290600480360360208110156103d757600080fd5b5035600160a060020a0316610852565b61032a61086d565b61032a6004803603604081101561040557600080fd5b50600160a060020a0381351690602001356108db565b61032a6004803603602081101561043157600080fd5b5035600160a060020a03166108e9565b61032a610904565b610451610968565b60408051600160a060020a039092168252519081900360200190f35b61027461097c565b610290610992565b6101d36109c0565b6102746004803603604081101561049b57600080fd5b50600160a060020a038135169060200135610a21565b610274600480360360408110156104c757600080fd5b50600160a060020a038135169060200135610a3e565b610274600480360360a08110156104f357600080fd5b600160a060020a038235169160208101359160408201359160608101359181019060a08101608082013564010000000081111561052f57600080fd5b82018360208201111561054157600080fd5b8035906020019184600183028401116401000000008311171561056357600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250929550610a5b945050505050565b610274600480360360408110156105ba57600080fd5b50600160a060020a038135169060200135610c7f565b610290600480360360408110156105e657600080fd5b50600160a060020a0381358116916020013516610d48565b61032a6004803603602081101561061457600080fd5b5035600160a060020a0316610d73565b60038054604080516020601f60026000196101006001881615020190951694909404938401819004810282018101909252828152606093909290918301828280156106b05780601f10610685576101008083540402835291602001916106b0565b820191906000526020600020905b81548152906001019060200180831161069357829003601f168201915b5050505050905090565b60075460009060ff16156106cd57600080fd5b6106d78383610d8d565b90505b92915050565b60025490565b60075460009060ff16156106f957600080fd5b610704848484610da3565b949350505050565b60055460ff1690565b60075460009060ff161561072857600080fd5b6106d78383610dfa565b61073b3361082b565b61074457600080fd5b60075460ff1661075357600080fd5b6007805460ff191690556040805133815290517f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa9181900360200190a1565b61079c3382610e36565b50565b604080517f452d3c59000000000000000000000000000000000000000000000000000000006020808301919091526c01000000000000000000000000600160a060020a03808a16820260248501528816026038830152604c8201869052606c8201859052608c8083018590528351808403909101815260ac909201909252805191012095945050505050565b60006106da60068363ffffffff610edd16565b60075460ff1690565b61085033610f12565b565b600160a060020a031660009081526020819052604090205490565b61087561097c565b61087e57600080fd5b6007546040516000916101009004600160a060020a0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a36007805474ffffffffffffffffffffffffffffffffffffffff0019169055565b6108e58282610f5a565b5050565b6108f23361082b565b6108fb57600080fd5b61079c81610f9f565b61090d3361082b565b61091657600080fd5b60075460ff161561092657600080fd5b6007805460ff191660011790556040805133815290517f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a2589181900360200190a1565b6007546101009004600160a060020a031690565b6007546101009004600160a060020a0316331490565b60006109bb6109a76109a2610968565b610852565b6109af6106e0565b9063ffffffff610fe716565b905090565b60048054604080516020601f60026000196101006001881615020190951694909404938401819004810282018101909252828152606093909290918301828280156106b05780601f10610685576101008083540402835291602001916106b0565b60075460009060ff1615610a3457600080fd5b6106d78383610ffc565b60075460009060ff1615610a5157600080fd5b6106d78383611038565b60075460009060ff1615610a6e57600080fd5b60005a9050600160a060020a038716610a8657600080fd5b6000610a95308989898961079f565b90506000610ab285610aa684611045565b9063ffffffff61109616565b9050600160a060020a038116610b2957604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601b60248201527f496e76616c6964207369676e61747572652070726f76696465642e0000000000604482015290519081900360640190fd5b604080516c01000000000000000000000000600160a060020a0384160260208083019190915260348083018690528351808403909101815260549092018352815191810191909120600081815260089092529190205460ff1615610bd8576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602681526020018061142c6026913960400191505060405180910390fd5b6000818152600860205260409020805460ff19166001179055610bfc828b8b611184565b60008815610c3857610c155a869063ffffffff610fe716565b61afc8019450610c2b898663ffffffff61124f16565b9050610c38833283611184565b604051600160a060020a0384169083907ff4a65fdaee7ca2336b6b5ea720055552af3fd371f7ebe46b8c83fa89d8c733f890600090a35060019a9950505050505050505050565b6000610c8961097c565b610c9257600080fd5b82600160a060020a031663a9059cbb610ca9610968565b846040518363ffffffff167c01000000000000000000000000000000000000000000000000000000000281526004018083600160a060020a0316600160a060020a0316815260200182815260200192505050602060405180830381600087803b158015610d1557600080fd5b505af1158015610d29573d6000803e3d6000fd5b505050506040513d6020811015610d3f57600080fd5b50519392505050565b600160a060020a03918216600090815260016020908152604080832093909416825291909152205490565b610d7b61097c565b610d8457600080fd5b61079c81611276565b6000610d9a3384846112fd565b50600192915050565b6000610db0848484611184565b600160a060020a038416600090815260016020908152604080832033808552925290912054610df0918691610deb908663ffffffff610fe716565b6112fd565b5060019392505050565b336000818152600160209081526040808320600160a060020a03871684529091528120549091610d9a918590610deb908663ffffffff61138516565b600160a060020a038216610e4957600080fd5b600254610e5c908263ffffffff610fe716565b600255600160a060020a038216600090815260208190526040902054610e88908263ffffffff610fe716565b600160a060020a038316600081815260208181526040808320949094558351858152935191937fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef929081900390910190a35050565b6000600160a060020a038216610ef257600080fd5b50600160a060020a03166000908152602091909152604090205460ff1690565b610f2360068263ffffffff61139716565b604051600160a060020a038216907fcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e90600090a250565b610f648282610e36565b600160a060020a0382166000908152600160209081526040808320338085529252909120546108e5918491610deb908563ffffffff610fe716565b610fb060068263ffffffff6113df16565b604051600160a060020a038216907f6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f890600090a250565b600082821115610ff657600080fd5b50900390565b336000818152600160209081526040808320600160a060020a03871684529091528120549091610d9a918590610deb908663ffffffff610fe716565b6000610d9a338484611184565b604080517f19457468657265756d205369676e6564204d6573736167653a0a333200000000602080830191909152603c8083019490945282518083039094018452605c909101909152815191012090565b600081516041146110a9575060006106da565b60208201516040830151606084015160001a7f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a08211156110ef57600093505050506106da565b8060ff16601b1415801561110757508060ff16601c14155b1561111857600093505050506106da565b6040805160008152602080820180845289905260ff8416828401526060820186905260808201859052915160019260a0808401939192601f1981019281900390910190855afa15801561116f573d6000803e3d6000fd5b5050604051601f190151979650505050505050565b600160a060020a03821661119757600080fd5b600160a060020a0383166000908152602081905260409020546111c0908263ffffffff610fe716565b600160a060020a0380851660009081526020819052604080822093909355908416815220546111f5908263ffffffff61138516565b600160a060020a038084166000818152602081815260409182902094909455805185815290519193928716927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef92918290030190a3505050565b60008261125e575060006106da565b8282028284828161126b57fe5b04146106d757600080fd5b600160a060020a03811661128957600080fd5b600754604051600160a060020a0380841692610100900416907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a360078054600160a060020a039092166101000274ffffffffffffffffffffffffffffffffffffffff0019909216919091179055565b600160a060020a03821661131057600080fd5b600160a060020a03831661132357600080fd5b600160a060020a03808416600081815260016020908152604080832094871680845294825291829020859055815185815291517f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259281900390910190a3505050565b6000828201838110156106d757600080fd5b600160a060020a0381166113aa57600080fd5b6113b48282610edd565b6113bd57600080fd5b600160a060020a0316600090815260209190915260409020805460ff19169055565b600160a060020a0381166113f257600080fd5b6113fc8282610edd565b1561140657600080fd5b600160a060020a0316600090815260209190915260409020805460ff1916600117905556fe5472616e73616374696f6e2068617320616c7265616479206265656e2065786563757465642ea165627a7a7230582047c6c18e3f7a85a61bd911f66405fa224baeb91bfd8636fe62ca1183c47739460029000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000019d971e4fe8401e7400000000000000000000000000000000000000000000000000000000000000000000134c65766f6c7574696f6e2e696f20546f6b656e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044c45564c00000000000000000000000000000000000000000000000000000000

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000019d971e4fe8401e7400000000000000000000000000000000000000000000000000000000000000000000134c65766f6c7574696f6e2e696f20546f6b656e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044c45564c00000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): Levolution.io Token
Arg [1] : symbol (string): LEVL
Arg [2] : decimals (uint8): 18
Arg [3] : initialSupply (uint256): 500000000000000000000000000

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [3] : 0000000000000000000000000000000000000000019d971e4fe8401e74000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000013
Arg [5] : 4c65766f6c7574696f6e2e696f20546f6b656e00000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [7] : 4c45564c00000000000000000000000000000000000000000000000000000000


Swarm Source

bzzr://47c6c18e3f7a85a61bd911f66405fa224baeb91bfd8636fe62ca1183c4773946

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.