Contract 0xf500a6d2b0c713054c8641b90d0d37109ed0a0b1

Txn Hash Method
Block
From
To
Value [Txn Fee]
0x20ddc06f895b73c07deb7651f50ea31d7b6dbc4b91320d285c68bb687a4abac7Claim Rewards53731242022-11-02 9:51:2726 days 8 hrs ago0xdcb8aeb8634d38fef75bd4d5c542c62069e01a1f IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.663639241654 4,885.752985967
0xeb4bd5f8c7a7c200b2cd497055ba1a6d6404314dbd35bffb47d781fd859c14eeApprove Rewards53731212022-11-02 9:51:1126 days 8 hrs ago0xdcb8aeb8634d38fef75bd4d5c542c62069e01a1f IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO0.243520592624 4,885.753117288
0x9fc316cbeeaa66c8dc861f20c0ed39effad36eb80babbbb70c6aa659b8e69997Buy53707052022-11-02 6:03:2126 days 12 hrs ago0xb3e8445d612d3566b8edca0ac27ba8669d06a0bd IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO3.786060889505 4,887.365072948
0xe81808dbaf0486558ef1002be5a8927030fc7987a5fb96c1bad3da7a9eb4ee20Buy53707002022-11-02 6:02:5226 days 12 hrs ago0xb3e8445d612d3566b8edca0ac27ba8669d06a0bd IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO3.810825349471 4,887.365305261
0x0c412be00ce0584a9d3f6df01ae2ff649d5b04fc13709d19ebaff181262b208eClaim Rewards53635312022-11-01 18:46:3826 days 23 hrs ago0x0a3edfb13e1a7551ac76fe6ddde48631fa592940 IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.75346247392 4,886.19278839
0xab0e5574759413dd68320e6d4832cabb6bf008b1672e253cfd6f5c8f489bb4cbClaim Rewards53630942022-11-01 18:05:2227 days 1 min ago0xbd7ebc405f639f6588f8d28fb55c698fcaa9c849 IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.7776638167140
0xaf704bebd008089515f9d67acb541691d3166e871afd3ce2355e1facf994444eClaim Rewards53628042022-11-01 17:37:5927 days 28 mins ago0xfb3cbb774e2b5bcc6803292ccb054e8a25f5c9e9 IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.754326670856 4,887.726360348
0xaee843657167e987cf75994d55db74d3069c54d2562fa2dd04f429a21fbb29b1Claim Rewards53621612022-11-01 16:37:2527 days 1 hr ago0xdd5ca0f206097a828fc89769f50beeed18576a7d IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.754343490065 4,887.756207095
0x3eab57aaea2f36e6402d8203b62015b0ada41b4f9a1ed7afac964aed3c7adc9fClaim Rewards53621332022-11-01 16:34:4527 days 1 hr ago0xf968ef1fafdee125c223b560dc2dc9e1c96fe03d IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.797611493732 4,964.538008004
0x29ea1a924f29abc7c81f0116b942de03eada188bc5ee32d773c1a3bfafbc55f0Claim Rewards53619532022-11-01 16:17:4727 days 1 hr ago0x6d7cc1045bb46e1c697f4d3db88df3e2453e8c5b IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.777693815290
0x29dd619078502d482c21bdd9520bb3e4ca5b48da86016cbb0873731b43927eafClaim Rewards53619152022-11-01 16:14:1227 days 1 hr ago0x4222349340e689291d3a96b07e5897c025e4e80a IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.7529411957760
0x8c731e125ac7ab9ce1a3ae1090889a3c0037c19e3add48f057eb850d53b23571Claim Rewards53618562022-11-01 16:08:3927 days 1 hr ago0x2f3cad850b087b7682d44b2204ee86be2d332771 IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.7529426975570
0x581234630d1fcd99bc4def0a42aaba7860a436de14653fbff8baed3e147188ceClaim Rewards53618442022-11-01 16:07:3127 days 1 hr ago0x930715929a28f977be9f150bd4181da727a43811 IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.779118036487 4,887.770779596
0x0e84ffd129f54a6fb3630e9231b32c6a9900cda2c53e89bbc6f63a3d455c84f7Approve Rewards53617652022-11-01 16:00:0327 days 2 hrs ago0xdcb8aeb8634d38fef75bd4d5c542c62069e01a1f IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO0.839128219232 4,887.774388435
0x00b0e1dfe554af914cbfe75e0fa3b715b47a441d497f6949c001b3f4060ff1cfBuy53601102022-11-01 13:23:5127 days 4 hrs ago0x97c18ee2b7fc6c78f543f3c92692de7ca90db31e IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO3.78649574659 4,887.850707188
0x2a911ad696837490c286421ac8b3d27c72a01d3f1ea005407b2d8eab1ff6482eBuy53600172022-11-01 13:15:0327 days 4 hrs ago0x97c18ee2b7fc6c78f543f3c92692de7ca90db31e IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO3.811265844707 4,887.855014489
0xf1f9f2f66f27cac9c51f10128d2cebebadc61422ae569c38f6c16c7cbc7d66f7Claim Rewards53594832022-11-01 12:24:3127 days 5 hrs ago0x1cd46f67d1af1f373d3e7f38f3c9edcaebc30ae0 IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.779179939488 4,887.879651431
0xe20738040f5ae68cf29c78529930102951ea5710fb10563217fa60d615e06a3aClaim Rewards53537662022-11-01 3:24:2527 days 14 hrs ago0xca8ee2dcacba56664221d41ec9fb041262784ed8 IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.779331298994 4,888.145854795
0x5780eb28398a0b3006f6d747c1e6c23ea108b62ee1e0d0f7f9d27870e1fc7f48Claim Rewards53514612022-10-31 23:46:4627 days 18 hrs ago0xcbeae48ca49ca404f36abe27913370e2a89d30e1 IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.779392050903 4,888.252702148
0xe92c8784d0b9848d255037e4bafb24a54e61483a2040f0fb8741c2421c23488dClaim Rewards53487122022-10-31 19:26:4427 days 22 hrs ago0x3a7f2a930aac00454500091ee07c0c7c8a0c37dd IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.78607140
0x64b90e1fb827fb44747d78920bf0158060079f52d13b65d17fac9a8aa11edb62Claim Rewards53481322022-10-31 18:31:5027 days 23 hrs ago0xfc7bb93d64cd48d5754830b70630d9ee89c87c44 IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.779478610814 4,888.404939296
0x67aaac2abe79ce24d5d4e074e1202f44fcf9b66cde6f18a2721b43ef2c919697Claim Rewards53480872022-10-31 18:27:3427 days 23 hrs ago0x930715929a28f977be9f150bd4181da727a43811 IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.779479773558 4,888.40698427
0xfbda949147415daf8f7deeecaea10bdf89c4b8c7224515de8e9e5c83eb25ff4cClaim Rewards53477002022-10-31 17:51:0028 days 15 mins ago0xfb3cbb774e2b5bcc6803292ccb054e8a25f5c9e9 IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.779489800587 4,888.424619297
0xf616c0012cda88eebdf73271743362294eff1d5fed3eea7c9235ba87b28b9e66Approve Rewards53469702022-10-31 16:41:5528 days 1 hr ago0x1405d7e44400824de19b24c6333d0dfa2f241774 IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO0.243479432501 4,888.458098295
0x3d887bdc9c0b28af85d79b747d71c00d6c0ad3d7585356ca750cac52c28bc419Claim Rewards53459522022-10-31 15:05:3628 days 3 hrs ago0xbec344bd12e208ba6e47ee80411ac3ecd9758287 IN  0xf500a6d2b0c713054c8641b90d0d37109ed0a0b10 CRO2.7533564774330
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
DBF_learnToEarn

Compiler Version
v0.8.2+commit.661d1103

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at cronoscan.com on 2022-09-26
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;


library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    function toString(uint256 value) internal pure returns (string memory) {
        
        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}


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

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    constructor() {
        _transferOwnership(_msgSender());
    }

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

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

    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

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

    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


library Address {

    function isContract(address account) internal view returns (bool) {
        return account.code.length > 0;
    }

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

        (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");

        (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");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

interface IERC721Receiver {

    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

contract ERC721Holder is IERC721Receiver {
 
    function onERC721Received(
        address,
        address,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC721Received.selector;
    }
}


interface IERC165 {

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

abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

interface IERC721 is IERC165 {
  
    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 IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);

        _afterTokenTransfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);

        _afterTokenTransfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

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

  
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 from,
        address to,
        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);
}

contract DBF_learnToEarn is Ownable {
    IERC20 internal rToken;

    constructor(address _rToken) {
        rToken = IERC20(_rToken);
    }
    	
    mapping (address => uint256) public Admins;
    mapping (address => uint256) public Rewards;

    function ownerAddAdmin(address account) onlyOwner public{
        Admins[account] = 1;
    }
    function ownerDelAdmin(address account) onlyOwner public{
        Admins[account] = 0;
    }

    function addAdmin(address account) public{
        require(Admins[msg.sender] == 1, "Your not an admin");
        Admins[account] = 1;
    }
    function delAdmin(address account) public{
        require(Admins[msg.sender] == 1, "Your not an admin");
        Admins[account] = 0;
    }

    function approveRewards(address[] calldata _accounts, uint256[] calldata _rewards) public {
        require(Admins[msg.sender] == 1, "Your not an admin");
        for(uint i = 0; i < _accounts.length; i++)
        {
            Rewards[_accounts[i]] += _rewards[i];
        }
    }

    function claimRewards() public {
		require(Rewards[msg.sender] > 0, "You do not have anything to claim!");
        require(rToken.balanceOf(address(this)) >= Rewards[msg.sender], "Oops the rewards pool is empty!");
        rToken.transfer(msg.sender,Rewards[msg.sender]);
        Rewards[msg.sender] = 0;
    }

    function buy(uint256 dbf) public {
        require(rToken.balanceOf(msg.sender) >= dbf, "You do not have enough to send");
        require(rToken.allowance(msg.sender, address(this)) >= dbf, "You do not have enough allowance");
        rToken.transferFrom(msg.sender, address(this), dbf);
    }
}

Contract ABI

[{"inputs":[{"internalType":"address","name":"_rToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"Admins","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"Rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_accounts","type":"address[]"},{"internalType":"uint256[]","name":"_rewards","type":"uint256[]"}],"name":"approveRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"dbf","type":"uint256"}],"name":"buy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"delAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"ownerAddAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"ownerDelAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040523480156200001157600080fd5b506040516200189d3803806200189d833981810160405281019062000037919062000182565b620000576200004b6200009f60201b60201c565b620000a760201b60201c565b80600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050620001fc565b600033905090565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050816000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6000815190506200017c81620001e2565b92915050565b6000602082840312156200019557600080fd5b6000620001a5848285016200016b565b91505092915050565b6000620001bb82620001c2565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b620001ed81620001ae565b8114620001f957600080fd5b50565b611691806200020c6000396000f3fe608060405234801561001057600080fd5b50600436106100b45760003560e01c80638c23e8ea116100715780638c23e8ea146101655780638da5cb5b14610181578063aa1fa8df1461019f578063d96a094a146101bb578063e2638983146101d7578063f2fde38b146101f3576100b4565b80630ec6d58a146100b9578063237634c8146100e9578063372500ab1461011957806362d9185514610123578063704802751461013f578063715018a61461015b575b600080fd5b6100d360048036038101906100ce9190610fb9565b61020f565b6040516100e09190611369565b60405180910390f35b61010360048036038101906100fe9190610fb9565b610227565b6040516101109190611369565b60405180910390f35b61012161023f565b005b61013d60048036038101906101389190610fb9565b610523565b005b61015960048036038101906101549190610fb9565b6105ed565b005b6101636106b7565b005b61017f600480360381019061017a9190610fb9565b61073f565b005b610189610803565b60405161019691906111e5565b60405180910390f35b6101b960048036038101906101b49190610fe2565b61082c565b005b6101d560048036038101906101d09190611080565b6109b8565b005b6101f160048036038101906101ec9190610fb9565b610c49565b005b61020d60048036038101906102089190610fb9565b610d0d565b005b60026020528060005260406000206000915090505481565b60036020528060005260406000206000915090505481565b6000600360003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054116102c1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016102b8906112e9565b60405180910390fd5b600360003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b815260040161035c91906111e5565b60206040518083038186803b15801561037457600080fd5b505afa158015610388573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906103ac91906110a9565b10156103ed576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016103e4906112a9565b60405180910390fd5b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb33600360003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546040518363ffffffff1660e01b8152600401610489929190611260565b602060405180830381600087803b1580156104a357600080fd5b505af11580156104b7573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906104db9190611057565b506000600360003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550565b6001600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054146105a5576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161059c906112c9565b60405180910390fd5b6000600260008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000208190555050565b6001600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020541461066f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610666906112c9565b60405180910390fd5b6001600260008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000208190555050565b6106bf610e05565b73ffffffffffffffffffffffffffffffffffffffff166106dd610803565b73ffffffffffffffffffffffffffffffffffffffff1614610733576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161072a90611309565b60405180910390fd5b61073d6000610e0d565b565b610747610e05565b73ffffffffffffffffffffffffffffffffffffffff16610765610803565b73ffffffffffffffffffffffffffffffffffffffff16146107bb576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107b290611309565b60405180910390fd5b6001600260008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000208190555050565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6001600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054146108ae576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108a5906112c9565b60405180910390fd5b60005b848490508110156109b1578282828181106108f5577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b9050602002013560036000878785818110610939577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b905060200201602081019061094e9190610fb9565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282546109979190611395565b9250508190555080806109a990611433565b9150506108b1565b5050505050565b80600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231336040518263ffffffff1660e01b8152600401610a1491906111e5565b60206040518083038186803b158015610a2c57600080fd5b505afa158015610a40573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a6491906110a9565b1015610aa5576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a9c90611329565b60405180910390fd5b80600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663dd62ed3e33306040518363ffffffff1660e01b8152600401610b03929190611200565b60206040518083038186803b158015610b1b57600080fd5b505afa158015610b2f573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b5391906110a9565b1015610b94576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b8b90611349565b60405180910390fd5b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166323b872dd3330846040518463ffffffff1660e01b8152600401610bf393929190611229565b602060405180830381600087803b158015610c0d57600080fd5b505af1158015610c21573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c459190611057565b5050565b610c51610e05565b73ffffffffffffffffffffffffffffffffffffffff16610c6f610803565b73ffffffffffffffffffffffffffffffffffffffff1614610cc5576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610cbc90611309565b60405180910390fd5b6000600260008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000208190555050565b610d15610e05565b73ffffffffffffffffffffffffffffffffffffffff16610d33610803565b73ffffffffffffffffffffffffffffffffffffffff1614610d89576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d8090611309565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610df9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610df090611289565b60405180910390fd5b610e0281610e0d565b50565b600033905090565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050816000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b600081359050610ee081611616565b92915050565b60008083601f840112610ef857600080fd5b8235905067ffffffffffffffff811115610f1157600080fd5b602083019150836020820283011115610f2957600080fd5b9250929050565b60008083601f840112610f4257600080fd5b8235905067ffffffffffffffff811115610f5b57600080fd5b602083019150836020820283011115610f7357600080fd5b9250929050565b600081519050610f898161162d565b92915050565b600081359050610f9e81611644565b92915050565b600081519050610fb381611644565b92915050565b600060208284031215610fcb57600080fd5b6000610fd984828501610ed1565b91505092915050565b60008060008060408587031215610ff857600080fd5b600085013567ffffffffffffffff81111561101257600080fd5b61101e87828801610ee6565b9450945050602085013567ffffffffffffffff81111561103d57600080fd5b61104987828801610f30565b925092505092959194509250565b60006020828403121561106957600080fd5b600061107784828501610f7a565b91505092915050565b60006020828403121561109257600080fd5b60006110a084828501610f8f565b91505092915050565b6000602082840312156110bb57600080fd5b60006110c984828501610fa4565b91505092915050565b6110db816113eb565b82525050565b60006110ee602683611384565b91506110f9826114ab565b604082019050919050565b6000611111601f83611384565b915061111c826114fa565b602082019050919050565b6000611134601183611384565b915061113f82611523565b602082019050919050565b6000611157602283611384565b91506111628261154c565b604082019050919050565b600061117a602083611384565b91506111858261159b565b602082019050919050565b600061119d601e83611384565b91506111a8826115c4565b602082019050919050565b60006111c0602083611384565b91506111cb826115ed565b602082019050919050565b6111df81611429565b82525050565b60006020820190506111fa60008301846110d2565b92915050565b600060408201905061121560008301856110d2565b61122260208301846110d2565b9392505050565b600060608201905061123e60008301866110d2565b61124b60208301856110d2565b61125860408301846111d6565b949350505050565b600060408201905061127560008301856110d2565b61128260208301846111d6565b9392505050565b600060208201905081810360008301526112a2816110e1565b9050919050565b600060208201905081810360008301526112c281611104565b9050919050565b600060208201905081810360008301526112e281611127565b9050919050565b600060208201905081810360008301526113028161114a565b9050919050565b600060208201905081810360008301526113228161116d565b9050919050565b6000602082019050818103600083015261134281611190565b9050919050565b60006020820190508181036000830152611362816111b3565b9050919050565b600060208201905061137e60008301846111d6565b92915050565b600082825260208201905092915050565b60006113a082611429565b91506113ab83611429565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff038211156113e0576113df61147c565b5b828201905092915050565b60006113f682611409565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600061143e82611429565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8214156114715761147061147c565b5b600182019050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f4f6f707320746865207265776172647320706f6f6c20697320656d7074792100600082015250565b7f596f7572206e6f7420616e2061646d696e000000000000000000000000000000600082015250565b7f596f7520646f206e6f74206861766520616e797468696e6720746f20636c616960008201527f6d21000000000000000000000000000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b7f596f7520646f206e6f74206861766520656e6f75676820746f2073656e640000600082015250565b7f596f7520646f206e6f74206861766520656e6f75676820616c6c6f77616e6365600082015250565b61161f816113eb565b811461162a57600080fd5b50565b611636816113fd565b811461164157600080fd5b50565b61164d81611429565b811461165857600080fd5b5056fea2646970667358221220536f103acc0bd6524d81eff8d34a47e5b3c27027f27c08c37223a26a023d89ad64736f6c63430008020033000000000000000000000000a2ae6273dd65f9fa76c3d383ede9c1261e025dac

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

000000000000000000000000a2ae6273dd65f9fa76c3d383ede9c1261e025dac

-----Decoded View---------------
Arg [0] : _rToken (address): 0xa2ae6273dd65f9fa76c3d383ede9c1261e025dac

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000a2ae6273dd65f9fa76c3d383ede9c1261e025dac


Deployed ByteCode Sourcemap

21688:1681:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21847:42;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21896:43;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22745:315;;;:::i;:::-;;22299:143;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;22150;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2222:103;;;:::i;:::-;;21948:94;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1999:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22450:287;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;23068:298;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;22048:94;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2333:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;21847:42;;;;;;;;;;;;;;;;;:::o;21896:43::-;;;;;;;;;;;;;;;;;:::o;22745:315::-;22811:1;22789:7;:19;22797:10;22789:19;;;;;;;;;;;;;;;;:23;22781:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;22905:7;:19;22913:10;22905:19;;;;;;;;;;;;;;;;22870:6;;;;;;;;;;;:16;;;22895:4;22870:31;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:54;;22862:98;;;;;;;;;;;;:::i;:::-;;;;;;;;;22971:6;;;;;;;;;;;:15;;;22987:10;22998:7;:19;23006:10;22998:19;;;;;;;;;;;;;;;;22971:47;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;23051:1;23029:7;:19;23037:10;23029:19;;;;;;;;;;;;;;;:23;;;;22745:315::o;22299:143::-;22381:1;22359:6;:18;22366:10;22359:18;;;;;;;;;;;;;;;;:23;22351:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;22433:1;22415:6;:15;22422:7;22415:15;;;;;;;;;;;;;;;:19;;;;22299:143;:::o;22150:::-;22232:1;22210:6;:18;22217:10;22210:18;;;;;;;;;;;;;;;;:23;22202:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;22284:1;22266:6;:15;22273:7;22266:15;;;;;;;;;;;;;;;:19;;;;22150:143;:::o;2222:103::-;2145:12;:10;:12::i;:::-;2134:23;;:7;:5;:7::i;:::-;:23;;;2126:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2287:30:::1;2314:1;2287:18;:30::i;:::-;2222:103::o:0;21948:94::-;2145:12;:10;:12::i;:::-;2134:23;;:7;:5;:7::i;:::-;:23;;;2126:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;22033:1:::1;22015:6;:15;22022:7;22015:15;;;;;;;;;;;;;;;:19;;;;21948:94:::0;:::o;1999:87::-;2045:7;2072:6;;;;;;;;;;;2065:13;;1999:87;:::o;22450:287::-;22581:1;22559:6;:18;22566:10;22559:18;;;;;;;;;;;;;;;;:23;22551:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;22619:6;22615:115;22635:9;;:16;;22631:1;:20;22615:115;;;22707:8;;22716:1;22707:11;;;;;;;;;;;;;;;;;;;;;22682:7;:21;22690:9;;22700:1;22690:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22682:21;;;;;;;;;;;;;;;;:36;;;;;;;:::i;:::-;;;;;;;;22653:3;;;;;:::i;:::-;;;;22615:115;;;;22450:287;;;;:::o;23068:298::-;23152:3;23120:6;;;;;;;;;;;:16;;;23137:10;23120:28;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:35;;23112:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;23256:3;23209:6;;;;;;;;;;;:16;;;23226:10;23246:4;23209:43;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:50;;23201:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;23307:6;;;;;;;;;;;:19;;;23327:10;23347:4;23354:3;23307:51;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;23068:298;:::o;22048:94::-;2145:12;:10;:12::i;:::-;2134:23;;:7;:5;:7::i;:::-;:23;;;2126:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;22133:1:::1;22115:6;:15;22122:7;22115:15;;;;;;;;;;;;;;;:19;;;;22048:94:::0;:::o;2333:201::-;2145:12;:10;:12::i;:::-;2134:23;;:7;:5;:7::i;:::-;:23;;;2126:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2442:1:::1;2422:22;;:8;:22;;;;2414:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;2498:28;2517:8;2498:18;:28::i;:::-;2333:201:::0;:::o;1545:98::-;1598:7;1625:10;1618:17;;1545:98;:::o;2542:191::-;2616:16;2635:6;;;;;;;;;;;2616:25;;2661:8;2652:6;;:17;;;;;;;;;;;;;;;;;;2716:8;2685:40;;2706:8;2685:40;;;;;;;;;;;;2542:191;;:::o;7:139:1:-;;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;59:87;;;;:::o;169:367::-;;;302:3;295:4;287:6;283:17;279:27;269:2;;320:1;317;310:12;269:2;356:6;343:20;333:30;;386:18;378:6;375:30;372:2;;;418:1;415;408:12;372:2;455:4;447:6;443:17;431:29;;509:3;501:4;493:6;489:17;479:8;475:32;472:41;469:2;;;526:1;523;516:12;469:2;259:277;;;;;:::o;559:367::-;;;692:3;685:4;677:6;673:17;669:27;659:2;;710:1;707;700:12;659:2;746:6;733:20;723:30;;776:18;768:6;765:30;762:2;;;808:1;805;798:12;762:2;845:4;837:6;833:17;821:29;;899:3;891:4;883:6;879:17;869:8;865:32;862:41;859:2;;;916:1;913;906:12;859:2;649:277;;;;;:::o;932:137::-;;1017:6;1011:13;1002:22;;1033:30;1057:5;1033:30;:::i;:::-;992:77;;;;:::o;1075:139::-;;1159:6;1146:20;1137:29;;1175:33;1202:5;1175:33;:::i;:::-;1127:87;;;;:::o;1220:143::-;;1308:6;1302:13;1293:22;;1324:33;1351:5;1324:33;:::i;:::-;1283:80;;;;:::o;1369:262::-;;1477:2;1465:9;1456:7;1452:23;1448:32;1445:2;;;1493:1;1490;1483:12;1445:2;1536:1;1561:53;1606:7;1597:6;1586:9;1582:22;1561:53;:::i;:::-;1551:63;;1507:117;1435:196;;;;:::o;1637:733::-;;;;;1832:2;1820:9;1811:7;1807:23;1803:32;1800:2;;;1848:1;1845;1838:12;1800:2;1919:1;1908:9;1904:17;1891:31;1949:18;1941:6;1938:30;1935:2;;;1981:1;1978;1971:12;1935:2;2017:80;2089:7;2080:6;2069:9;2065:22;2017:80;:::i;:::-;1999:98;;;;1862:245;2174:2;2163:9;2159:18;2146:32;2205:18;2197:6;2194:30;2191:2;;;2237:1;2234;2227:12;2191:2;2273:80;2345:7;2336:6;2325:9;2321:22;2273:80;:::i;:::-;2255:98;;;;2117:246;1790:580;;;;;;;:::o;2376:278::-;;2492:2;2480:9;2471:7;2467:23;2463:32;2460:2;;;2508:1;2505;2498:12;2460:2;2551:1;2576:61;2629:7;2620:6;2609:9;2605:22;2576:61;:::i;:::-;2566:71;;2522:125;2450:204;;;;:::o;2660:262::-;;2768:2;2756:9;2747:7;2743:23;2739:32;2736:2;;;2784:1;2781;2774:12;2736:2;2827:1;2852:53;2897:7;2888:6;2877:9;2873:22;2852:53;:::i;:::-;2842:63;;2798:117;2726:196;;;;:::o;2928:284::-;;3047:2;3035:9;3026:7;3022:23;3018:32;3015:2;;;3063:1;3060;3053:12;3015:2;3106:1;3131:64;3187:7;3178:6;3167:9;3163:22;3131:64;:::i;:::-;3121:74;;3077:128;3005:207;;;;:::o;3218:118::-;3305:24;3323:5;3305:24;:::i;:::-;3300:3;3293:37;3283:53;;:::o;3342:366::-;;3505:67;3569:2;3564:3;3505:67;:::i;:::-;3498:74;;3581:93;3670:3;3581:93;:::i;:::-;3699:2;3694:3;3690:12;3683:19;;3488:220;;;:::o;3714:366::-;;3877:67;3941:2;3936:3;3877:67;:::i;:::-;3870:74;;3953:93;4042:3;3953:93;:::i;:::-;4071:2;4066:3;4062:12;4055:19;;3860:220;;;:::o;4086:366::-;;4249:67;4313:2;4308:3;4249:67;:::i;:::-;4242:74;;4325:93;4414:3;4325:93;:::i;:::-;4443:2;4438:3;4434:12;4427:19;;4232:220;;;:::o;4458:366::-;;4621:67;4685:2;4680:3;4621:67;:::i;:::-;4614:74;;4697:93;4786:3;4697:93;:::i;:::-;4815:2;4810:3;4806:12;4799:19;;4604:220;;;:::o;4830:366::-;;4993:67;5057:2;5052:3;4993:67;:::i;:::-;4986:74;;5069:93;5158:3;5069:93;:::i;:::-;5187:2;5182:3;5178:12;5171:19;;4976:220;;;:::o;5202:366::-;;5365:67;5429:2;5424:3;5365:67;:::i;:::-;5358:74;;5441:93;5530:3;5441:93;:::i;:::-;5559:2;5554:3;5550:12;5543:19;;5348:220;;;:::o;5574:366::-;;5737:67;5801:2;5796:3;5737:67;:::i;:::-;5730:74;;5813:93;5902:3;5813:93;:::i;:::-;5931:2;5926:3;5922:12;5915:19;;5720:220;;;:::o;5946:118::-;6033:24;6051:5;6033:24;:::i;:::-;6028:3;6021:37;6011:53;;:::o;6070:222::-;;6201:2;6190:9;6186:18;6178:26;;6214:71;6282:1;6271:9;6267:17;6258:6;6214:71;:::i;:::-;6168:124;;;;:::o;6298:332::-;;6457:2;6446:9;6442:18;6434:26;;6470:71;6538:1;6527:9;6523:17;6514:6;6470:71;:::i;:::-;6551:72;6619:2;6608:9;6604:18;6595:6;6551:72;:::i;:::-;6424:206;;;;;:::o;6636:442::-;;6823:2;6812:9;6808:18;6800:26;;6836:71;6904:1;6893:9;6889:17;6880:6;6836:71;:::i;:::-;6917:72;6985:2;6974:9;6970:18;6961:6;6917:72;:::i;:::-;6999;7067:2;7056:9;7052:18;7043:6;6999:72;:::i;:::-;6790:288;;;;;;:::o;7084:332::-;;7243:2;7232:9;7228:18;7220:26;;7256:71;7324:1;7313:9;7309:17;7300:6;7256:71;:::i;:::-;7337:72;7405:2;7394:9;7390:18;7381:6;7337:72;:::i;:::-;7210:206;;;;;:::o;7422:419::-;;7626:2;7615:9;7611:18;7603:26;;7675:9;7669:4;7665:20;7661:1;7650:9;7646:17;7639:47;7703:131;7829:4;7703:131;:::i;:::-;7695:139;;7593:248;;;:::o;7847:419::-;;8051:2;8040:9;8036:18;8028:26;;8100:9;8094:4;8090:20;8086:1;8075:9;8071:17;8064:47;8128:131;8254:4;8128:131;:::i;:::-;8120:139;;8018:248;;;:::o;8272:419::-;;8476:2;8465:9;8461:18;8453:26;;8525:9;8519:4;8515:20;8511:1;8500:9;8496:17;8489:47;8553:131;8679:4;8553:131;:::i;:::-;8545:139;;8443:248;;;:::o;8697:419::-;;8901:2;8890:9;8886:18;8878:26;;8950:9;8944:4;8940:20;8936:1;8925:9;8921:17;8914:47;8978:131;9104:4;8978:131;:::i;:::-;8970:139;;8868:248;;;:::o;9122:419::-;;9326:2;9315:9;9311:18;9303:26;;9375:9;9369:4;9365:20;9361:1;9350:9;9346:17;9339:47;9403:131;9529:4;9403:131;:::i;:::-;9395:139;;9293:248;;;:::o;9547:419::-;;9751:2;9740:9;9736:18;9728:26;;9800:9;9794:4;9790:20;9786:1;9775:9;9771:17;9764:47;9828:131;9954:4;9828:131;:::i;:::-;9820:139;;9718:248;;;:::o;9972:419::-;;10176:2;10165:9;10161:18;10153:26;;10225:9;10219:4;10215:20;10211:1;10200:9;10196:17;10189:47;10253:131;10379:4;10253:131;:::i;:::-;10245:139;;10143:248;;;:::o;10397:222::-;;10528:2;10517:9;10513:18;10505:26;;10541:71;10609:1;10598:9;10594:17;10585:6;10541:71;:::i;:::-;10495:124;;;;:::o;10625:169::-;;10743:6;10738:3;10731:19;10783:4;10778:3;10774:14;10759:29;;10721:73;;;;:::o;10800:305::-;;10859:20;10877:1;10859:20;:::i;:::-;10854:25;;10893:20;10911:1;10893:20;:::i;:::-;10888:25;;11047:1;10979:66;10975:74;10972:1;10969:81;10966:2;;;11053:18;;:::i;:::-;10966:2;11097:1;11094;11090:9;11083:16;;10844:261;;;;:::o;11111:96::-;;11177:24;11195:5;11177:24;:::i;:::-;11166:35;;11156:51;;;:::o;11213:90::-;;11290:5;11283:13;11276:21;11265:32;;11255:48;;;:::o;11309:126::-;;11386:42;11379:5;11375:54;11364:65;;11354:81;;;:::o;11441:77::-;;11507:5;11496:16;;11486:32;;;:::o;11524:233::-;;11586:24;11604:5;11586:24;:::i;:::-;11577:33;;11632:66;11625:5;11622:77;11619:2;;;11702:18;;:::i;:::-;11619:2;11749:1;11742:5;11738:13;11731:20;;11567:190;;;:::o;11763:180::-;11811:77;11808:1;11801:88;11908:4;11905:1;11898:15;11932:4;11929:1;11922:15;11949:225;12089:34;12085:1;12077:6;12073:14;12066:58;12158:8;12153:2;12145:6;12141:15;12134:33;12055:119;:::o;12180:181::-;12320:33;12316:1;12308:6;12304:14;12297:57;12286:75;:::o;12367:167::-;12507:19;12503:1;12495:6;12491:14;12484:43;12473:61;:::o;12540:221::-;12680:34;12676:1;12668:6;12664:14;12657:58;12749:4;12744:2;12736:6;12732:15;12725:29;12646:115;:::o;12767:182::-;12907:34;12903:1;12895:6;12891:14;12884:58;12873:76;:::o;12955:180::-;13095:32;13091:1;13083:6;13079:14;13072:56;13061:74;:::o;13141:182::-;13281:34;13277:1;13269:6;13265:14;13258:58;13247:76;:::o;13329:122::-;13402:24;13420:5;13402:24;:::i;:::-;13395:5;13392:35;13382:2;;13441:1;13438;13431:12;13382:2;13372:79;:::o;13457:116::-;13527:21;13542:5;13527:21;:::i;:::-;13520:5;13517:32;13507:2;;13563:1;13560;13553:12;13507:2;13497:76;:::o;13579:122::-;13652:24;13670:5;13652:24;:::i;:::-;13645:5;13642:35;13632:2;;13691:1;13688;13681:12;13632:2;13622:79;:::o

Swarm Source

ipfs://536f103acc0bd6524d81eff8d34a47e5b3c27027f27c08c37223a26a023d89ad
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.