Contract 0x857f630c2eC9A37a476D8201E5Bb8E9640139EBe

 

Contract Overview

Balance:
0.616250199999999998 BNB

BNB Value:
$235.47 (@ $382.10/BNB)
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xbebef37c6b3ac2e53c7016b99ac96ceeba3350b31312a2e36e8420cb23fa5c31Set Rate145720182022-01-21 23:35:1821 mins ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0001373
0x10dbdb9eb7b11d4ae2d36711200af4357fe33bdb08fdb2099c8551caf627004eSet Rate145714172022-01-21 23:05:1551 mins ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0001373
0x58053ac76bf6e21fa7d0a00367575909495f155d8f0574abf5157c508242cb35Set Rate145711322022-01-21 22:50:561 hr 6 mins ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0001373
0x963b76a9719ce88b343774aa9139ccbb269a6a13524965ccece19278432f216cSet Rate145700262022-01-21 21:55:042 hrs 2 mins ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0001373
0x33f128bdf79851887de2c7338644eb2993e561a04bcd9ea4936dc470e1fde34bSet Rate145585482022-01-21 12:19:1111 hrs 38 mins ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0002123
0x328e3e8e719766dd6b0cc3b69e551165e2dd71e9b3549d4d5c30c9e12028ee17Set Rate145582472022-01-21 12:04:0811 hrs 53 mins ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.00006859
0x5a18fe39ddd4309039d1e868d10d4bef397b0ef4124d72297e3e71b3ecc875caSet Rate145576452022-01-21 11:34:0212 hrs 23 mins ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0001373
0x28f871dfbebc5b1dd3fa2c39f4a79f2a089583fe455584363583ca0a8bf97d4dClaim Tokens145519392022-01-21 6:48:4217 hrs 8 mins ago0xe328791f331075c3c085f93cc0d4ec511c95e625 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0.003 BNB0.000560815
0xe2e280c50be9292978216875881e973cf46e7ea3547478435d00c76ae1831b95Buy Tokens With ...145517932022-01-21 6:41:2417 hrs 15 mins ago0xe328791f331075c3c085f93cc0d4ec511c95e625 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0.20077 BNB0.000582225
0x3d35e1dac630be603f524f6fffa3f2b788ca00661709cd566e22943e7ac4248cSet Rate145513372022-01-21 6:18:3617 hrs 38 mins ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0002123
0x0551958a923fee86e90a2ace11e492085967751941550146a53717cb69adccd5Set Rate145510362022-01-21 6:03:3317 hrs 53 mins ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.00006859
0xf9cd75848293c96404e65eab62c3e1c609292eac613a39d65787ad632950726aSet Rate145477032022-01-21 3:16:2920 hrs 40 mins ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.00013724
0x388fd16ac3b63044f4e294b93c1b53cd9d33acfbb2e2b9b3503e678d1bbc2676Set Rate145465072022-01-21 2:16:2221 hrs 40 mins ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0001373
0x23709d93e6b9a08ec26dd5493662c2d17170b6693b891eb184c50506c10c0869Set Rate145462062022-01-21 2:01:1921 hrs 55 mins ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0001373
0x60653b370eb4894d010f97080ee0c515b4e85387e14997710d00a4d6f4657257Set Rate145411112022-01-20 21:45:561 day 2 hrs ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0001373
0x86816054badef2552fc7ee87251871d7a12c116fb350232919cff4bb397c3c41Set Rate145360062022-01-20 17:30:341 day 6 hrs ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0001373
0xd1bde3c74f50fd2aa888694ad518ce128f0ed59b4a1792d772422eee5e1dcb21Set Rate145333062022-01-20 15:15:241 day 8 hrs ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0001373
0xb2361dc6ec1ef08f50e4fcc7fb41c966900341f028a535e6a449507fbd093121Set Rate145282022022-01-20 10:59:431 day 12 hrs ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0001373
0x5e3d4edca494e33e03b1b5b0834420cfef0c7228a17b7f71da6501d56ed255d2Claim Tokens145275052022-01-20 10:24:521 day 13 hrs ago0x68d55c93b8d07bcf8d7700852da8791b8dde9425 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0.003 BNB0.00074314
0x3928f1abeea8baf72af3dd2a99c1fde43a45db607256da690df034b9ced67b55Set Rate145260842022-01-20 9:13:491 day 14 hrs ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0001373
0x7869e4ff056387ef9a10e5f87e1d8864055888072f9defe2281886e990f2f3d9Set Rate145230792022-01-20 6:43:331 day 17 hrs ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0001373
0x3ea0b078b25751ee83fd1c2f31402a13b349aa3ef73f689d3ed6b1c79b95b9a7Set Rate145122622022-01-19 21:42:382 days 2 hrs ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0001373
0xc727168ddbfb9ac9a0834f88f4d127a9301d968ab4289dd37cdeaa457c9eb354Set Rate145062612022-01-19 16:41:592 days 7 hrs ago0x5331c8e7d8ba4b212ed996160c26ddac11d9c788 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0 BNB0.0001373
0x658ca932a6380392b921ed267974f8f2256620b8f7634b1d8edf55b211c04307Claim Tokens145060622022-01-19 16:32:022 days 7 hrs ago0xa05474bf43e7d744a44922f5cec3618a4beae2e7 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0.003 BNB0.00074314
0xf34e6a870464fefb1977c416dbd155bce3c2e0a24c5ebe664ad15dbe0a0c2b90Claim Tokens145044172022-01-19 15:08:572 days 8 hrs ago0x877bfc1ef5e93a7022003414bcb00da29eb22af3 IN  0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0.003 BNB0.00074314
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x28f871dfbebc5b1dd3fa2c39f4a79f2a089583fe455584363583ca0a8bf97d4d145519392022-01-21 6:48:4217 hrs 8 mins ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0xe2e280c50be9292978216875881e973cf46e7ea3547478435d00c76ae1831b95145517932022-01-21 6:41:2417 hrs 15 mins ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.180693 BNB
0x5e3d4edca494e33e03b1b5b0834420cfef0c7228a17b7f71da6501d56ed255d2145275052022-01-20 10:24:521 day 13 hrs ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0x658ca932a6380392b921ed267974f8f2256620b8f7634b1d8edf55b211c04307145060622022-01-19 16:32:022 days 7 hrs ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0xf34e6a870464fefb1977c416dbd155bce3c2e0a24c5ebe664ad15dbe0a0c2b90145044172022-01-19 15:08:572 days 8 hrs ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0x6fa21e5c15aff55251541cefcd0020b96a815d961ed2e272766c7991eb1f1ceb145010962022-01-19 12:19:062 days 11 hrs ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0x07f351c86f85c301f62f7f57b851426bcda59588a927d5007fbe489431dfa6e7144985412022-01-19 10:11:162 days 13 hrs ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0xbbf080c32117c79ff04ed49898f2959286eeb5e5f89f85a652881a5527c0e5ff144949922022-01-19 7:13:272 days 16 hrs ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0xaa1d7a233fc0256a627777370653a4f93dbd779e88711b93d7e03155085477a9144799372022-01-18 18:39:073 days 5 hrs ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0xa1d835fc4a6b6762b4f618fadf972dd6070ab0b093242e709de4c52452f729db144793982022-01-18 18:12:093 days 5 hrs ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0x4f251bb49c77313c2875f888a4026637395df89721584f2beb5e5a38965f290a144734062022-01-18 13:04:503 days 10 hrs ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0xfe35cce6d4c5d26fcf768bba6a9039b2816a53fa74e920fdff6381662c22cb3d144368992022-01-17 6:15:154 days 17 hrs ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0x12578f4b7b4dbd8e1d1c8dd8055802899704305ef0e0bfc689f331d85bf0721d144286382022-01-16 23:18:045 days 39 mins ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0xb9d6cbefe7469d8d0f852975f86355a922ed931ec173662a7f2e27954745b9f0144286012022-01-16 23:16:135 days 41 mins ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0x5d048cec32f37df26edd08f41b0df635ac258a36d63738983db6a56de2592c08144285622022-01-16 23:14:165 days 42 mins ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0xa44252be66d94f176c81f5fd28c4e19961354f7412a492afa92937328ad2789a144285102022-01-16 23:11:405 days 45 mins ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0xb56893f140b943e57f8aef6a91de551a99af9024240593e8828b2c9957f72668144284532022-01-16 23:08:495 days 48 mins ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0x76075764ff98d476f9b2ff322e40acc17706ed95052b08b11ed0bb90460e0932144283952022-01-16 23:05:555 days 51 mins ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0xbbf8390623a868a71d77f9d9358f712144967b66809d5eab3db591305f12b3c1144282942022-01-16 23:00:525 days 56 mins ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0xff4d606839df1d07aad0bb4d551e053dfa664e230829b579f3979f3845648f8c144279912022-01-16 22:45:435 days 1 hr ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0xff5a48d69693589fa0fc69e939f749d4d488bfa9cb056f28830583fd136c1121144274922022-01-16 22:20:465 days 1 hr ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
0x0b7022d934d2d6217dce527d35271fadec544c095189499ad8c5cc7288fe1c49144266642022-01-16 21:39:225 days 2 hrs ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.0288 BNB
0xf02b5b81ddf5f9911f9baaa4d93c5ceef0b655d63e873ed047408c8d18c4fdea144265382022-01-16 21:33:045 days 2 hrs ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.0855 BNB
0x5518b9b552aaa509abb8064ade979482d0f59059ab7c44b6ac0cea4107aef212144264472022-01-16 21:28:315 days 2 hrs ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.3717 BNB
0xc5a113533fdb48595ab913b879057644579bb76e1b1c303006bf3a97d71ae872144254112022-01-16 20:36:435 days 3 hrs ago 0x857f630c2ec9a37a476d8201e5bb8e9640139ebe0xa1a6e865f08918fc2994386530fa9d169c9e1fc30.003 BNB
[ Download CSV Export 
Loading

Similar Match Source Code
Note: This contract matches the deployed ByteCode of the Source Code for Contract 0x1971e42b6EB403e2d9439692a664BF1bC7257510

Contract Name:
CLDSale_V3

Compiler Version
v0.8.0+commit.c7dfd78e

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity Standard Json-Input format)

File 1 of 9 : CLDSale_V3.sol
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title Crowdsale
 * @dev Crowdsale is a base contract for managing a token crowdsale,
 * allowing investors to purchase tokens with ether. This contract implements
 * such functionality in its most fundamental form and can be extended to provide additional
 * functionality and/or custom behavior.
 * The external interface represents the basic interface for purchasing tokens, and conforms
 * the base architecture for crowdsales. It is *not* intended to be modified / overridden.
 * The internal interface conforms the extensible and modifiable surface of crowdsales. Override
 * the methods to add functionality. Consider using 'super' where appropriate to concatenate
 * behavior.
 */
contract Crowdsale is Context, ReentrancyGuard, Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // The token being sold
    IERC20 private _token;

    // Address where funds are collected
    address payable private _wallet;

    // How many token units a buyer gets per wei.
    // The rate is the conversion between wei and the smallest and indivisible token unit.
    // So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
    // 1 wei will give you 1 unit, or 0.001 TOK.
    uint256 private _rate;

    // Amount of wei raised
    uint256 private _weiRaised;

    /**
     * Event for token purchase logging
     * @param purchaser who paid for the tokens
     * @param beneficiary who got the tokens
     * @param value weis paid for purchase
     * @param amount amount of tokens purchased
     */
    event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);

    /**
     * @param rate Number of token units a buyer gets per wei
     * @dev The rate is the conversion between wei and the smallest and indivisible
     * token unit. So, if you are using a rate of 1 with a ERC20Detailed token
     * with 3 decimals called TOK, 1 wei will give you 1 unit, or 0.001 TOK.
     * @param wallet Address where collected funds will be forwarded to
     * @param token Address of the token being sold
     */
    constructor (uint256 rate, address payable wallet, IERC20 token) public {
        require(rate > 0, "Crowdsale: rate is 0");
        require(wallet != address(0), "Crowdsale: wallet is the zero address");
        require(address(token) != address(0), "Crowdsale: token is the zero address");

        _rate = rate;
        _wallet = wallet;
        _token = token;
    }

    /**
     * @dev fallback function ***DO NOT OVERRIDE***
     * Note that other contracts will transfer funds with a base gas stipend
     * of 2300, which is not enough to call buyTokens. Consider calling
     * buyTokens directly when purchasing tokens from a contract.
     */
    fallback () external payable {
        buyTokens(_msgSender());
    }

    /**
     * @return the token being sold.
     */
    function token() public view returns (IERC20) {
        return _token;
    }

    /**
     * @return the address where funds are collected.
     */
    function wallet() public view returns (address payable) {
        return _wallet;
    }

    /**
     * @return the number of token units a buyer gets per wei.
     */
    function rate() public view returns (uint256) {
        return _rate;
    }

    /**
     * @dev set the number of token units a buyer gets per wei.
     */
    function setRate(uint256 newRate) public onlyOwner {
        _rate = newRate;
    }

    /**
     * @return the amount of wei raised.
     */
    function weiRaised() public view returns (uint256) {
        return _weiRaised;
    }

    /**
     * @dev low level token purchase ***DO NOT OVERRIDE***
     * This function has a non-reentrancy guard, so it shouldn't be called by
     * another `nonReentrant` function.
     * @param beneficiary Recipient of the token purchase
     */
    function buyTokens(address beneficiary) public virtual nonReentrant payable {
        uint256 weiAmount = msg.value;
        _preValidatePurchase(beneficiary, weiAmount);

        // calculate token amount to be created
        uint256 tokens = _getTokenAmount(weiAmount);

        // update state
        _weiRaised = _weiRaised.add(weiAmount);

        _processPurchase(beneficiary, tokens);
        emit TokensPurchased(_msgSender(), beneficiary, weiAmount, tokens);

        _updatePurchasingState(beneficiary, weiAmount);

        _forwardFunds();
        _postValidatePurchase(beneficiary, weiAmount);
    }

    /**
     * @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met.
     * Use `super` in contracts that inherit from Crowdsale to extend their validations.
     * Example from CappedCrowdsale.sol's _preValidatePurchase method:
     *     super._preValidatePurchase(beneficiary, weiAmount);
     *     require(weiRaised().add(weiAmount) <= cap);
     * @param beneficiary Address performing the token purchase
     * @param weiAmount Value in wei involved in the purchase
     */
    function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
        require(beneficiary != address(0), "Crowdsale: beneficiary is the zero address");
        require(weiAmount != 0, "Crowdsale: weiAmount is 0");
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
    }

    /**
     * @dev Validation of an executed purchase. Observe state and use revert statements to undo rollback when valid
     * conditions are not met.
     * @param beneficiary Address performing the token purchase
     * @param weiAmount Value in wei involved in the purchase
     */
    function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
        // solhint-disable-previous-line no-empty-blocks
    }

    /**
     * @dev Source of tokens. Override this method to modify the way in which the crowdsale ultimately gets and sends
     * its tokens.
     * @param beneficiary Address performing the token purchase
     * @param tokenAmount Number of tokens to be emitted
     */
    function _deliverTokens(address beneficiary, uint256 tokenAmount) virtual internal {
        _token.safeTransfer(beneficiary, tokenAmount);
    }

    /**
     * @dev Executed when a purchase has been validated and is ready to be executed. Doesn't necessarily emit/send
     * tokens.
     * @param beneficiary Address receiving the tokens
     * @param tokenAmount Number of tokens to be purchased
     */
    function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
        _deliverTokens(beneficiary, tokenAmount);
    }

    /**
     * @dev Override for extensions that require an internal state to check for validity (current user contributions,
     * etc.)
     * @param beneficiary Address receiving the tokens
     * @param weiAmount Value in wei involved in the purchase
     */
    function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal {
        // solhint-disable-previous-line no-empty-blocks
    }

    /**
     * @dev Override to extend the way in which ether is converted to tokens.
     * @param weiAmount Value in wei to be converted into tokens
     * @return Number of tokens that can be purchased with the specified _weiAmount
     */
    function _getTokenAmount(uint256 weiAmount) virtual internal view returns (uint256) {
        return weiAmount.mul(_rate);
    }

    /**
     * @dev Determines how ETH is stored/forwarded on purchases.
     */
    function _forwardFunds() virtual internal {
        _wallet.transfer(msg.value);
    }
}

/**
 * @title AllowanceCrowdsale
 * @dev Extension of Crowdsale where tokens are held by a wallet, which approves an allowance to the crowdsale.
 */
abstract contract AllowanceCrowdsale is Crowdsale {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    address private _tokenWallet;

    /**
     * @dev Constructor, takes token wallet address.
     * @param tokenWallet Address holding the tokens, which has approved allowance to the crowdsale.
     */
    constructor (address tokenWallet) {
        require(tokenWallet != address(0), "AllowanceCrowdsale: token wallet is the zero address");
        _tokenWallet = tokenWallet;
    }

    /**
     * @return the address of the wallet that will hold the tokens.
     */
    function tokenWallet() public view returns (address) {
        return _tokenWallet;
    }

    /**
     * @dev Checks the amount of tokens left in the allowance.
     * @return Amount of tokens left in the allowance
     */
    function remainingTokens() public view returns (uint256) {
        return Math.min(token().balanceOf(_tokenWallet), token().allowance(_tokenWallet, address(this)));
    }

    /**
     * @dev Overrides parent behavior by transferring tokens from wallet.
     * @param beneficiary Token purchaser
     * @param tokenAmount Amount of tokens purchased
     */
    function _deliverTokens(address beneficiary, uint256 tokenAmount) override internal {
        token().safeTransferFrom(_tokenWallet, beneficiary, tokenAmount);
    }
}

contract Referral{
    using SafeMath for uint256;

    uint256 private constant _referralPercent = 10;
    mapping(address => uint256) internal _referralCommission;
    mapping(address => uint256) private _commissionPaid;
    mapping(address => address) private _parent;

    /**
     * Event for register new account
     * @param beneficiary who got the tokens
     * @param referrer Refer purchaser to purchase token
     */
    event Register(address indexed beneficiary, address referrer);

    /**
     * Event for token purchase logging
     * @param beneficiary who got the tokens
     * @param value weis paid for purchase
     */
    event CommissionPaid(address indexed beneficiary, uint256 value);

    constructor(){

    }

    /**
     * @dev return amount of referral percent.
     */
    function referralPercent() public view returns (uint256) {
        return _referralPercent;
    }
    
    /**
     * @dev return amount of referral commission.
     */
    function referralCommission(address account) public view returns (uint256) {
        return _referralCommission[account];
    }
    
    /**
     * @dev return amount of referral commission.
     */
    function commissionPaid(address account) public view returns (uint256) {
        return _commissionPaid[account];
    }

    /**
     * @dev Getter the address of parent participant.
     */
    function parent(address account) public view returns (address) {
        return _parent[account];
    }

    /**
     * @dev Getter the address of parent participant.
     */
    function withdrawReferralCommission() public {
        require(referralCommission(msg.sender) > 0, "Your Commission must be greater than zero");
        uint256 value = _referralCommission[msg.sender];
        _referralCommission[msg.sender] = 0;
        _commissionPaid[msg.sender] = _commissionPaid[msg.sender].add(value);
        payable(msg.sender).transfer(value);
        emit CommissionPaid(msg.sender, value);
    }
    
    /**
     * @dev check referrer account for purchase
     * @param beneficiary Recipient of the token purchase
     * @param referrer Refer purchaser to purchase token
     */
    function _preValidateReferrer(address beneficiary, address referrer) internal view {
        require(referrer != beneficiary, "Beneficiary can't refer to self");
        require(parent(beneficiary) == address(0) || parent(beneficiary) == referrer, "Invalid referrer");
    }
    
    /**
     * @dev update referrer account for purchase
     * @param beneficiary Recipient of the token purchase
     * @param referrer Refer purchaser to purchase token
     */
    function _updateReferral(address beneficiary, address referrer) virtual internal {
        if (parent(beneficiary) == address(0)){
            _parent[beneficiary] = referrer;
            emit Register(beneficiary, referrer);
        }
    }
}

/**
 * @title Airdrop
 * @dev Airdrop is a base contract for managing claim tokens,
 */
contract Airdrop is Context, Referral {
    using SafeMath for uint256;

    uint256 private _airdropFee;
    mapping(address => bool) private _airdropClaimed;

    // Amount of wei raised for Airdrop
    uint256 private _airdropWeiRaised;
    
     /**
     * Event for token airdrop logging
     * @param claimer who paid for the tokens
     * @param referrer who refer for airdrop
     * @param value weis paid for claim
     * @param amount amount of tokens claimed
     */
    event AirdropClaimed(address indexed claimer, address indexed referrer, uint256 value, uint256 amount);

    constructor(uint256 airdropFee)public
    {
        _airdropFee = airdropFee;
    }

    /**
     * @return the amount of airdrop fee.
     */
    function airdropFee() public view returns (uint256) {
        return _airdropFee;
    }

    /**
     * @param beneficiary Token claimed account
     * @return the address claimed token state.
     */
    function airdropClaimed(address beneficiary) public view returns (bool) {
        return _airdropClaimed[beneficiary];
    }

    /**
     * @return the amount of wei raised for airdrop.
     */
    function airdropWeiRaised() public view returns (uint256) {
        return _airdropWeiRaised;
    }

    /**
     * @return the amount of airdrop tokens.
     */
    function airdropAmount() virtual public view returns (uint256) {
        return 32 * 10 ** 18;
    }

    /**
     * @dev This function to claim via referral account
     * @param referrer Refer claimer to claim token
     */
    function claimTokens(address referrer) public virtual payable{
        uint256 weiAmount = msg.value;
        _preValidateReferrer(msg.sender, referrer);
        _preValidateAirdrop(_msgSender(), referrer, weiAmount);

        // update state
        _airdropWeiRaised = _airdropWeiRaised.add(weiAmount);

        _processAirdrop(_msgSender(), referrer, airdropAmount());
        emit AirdropClaimed(_msgSender(), referrer, weiAmount, airdropAmount());

        _airdropClaimed[_msgSender()] = true;     
    }
    
    /**
     * @dev Validation of an incoming claim. Use require statements to revert state when conditions are not met.
     * @param beneficiary Address performing the token claim
     * @param referrer Refer claimer to claim token
     * @param weiAmount Value in wei involved in the claim
     */
    function _preValidateAirdrop(address beneficiary, address referrer, uint256 weiAmount) virtual internal view {
        require(weiAmount >= _airdropFee, 'Fee not paid!');
        require(_airdropClaimed[beneficiary] == false, 'Beneficiary already claimed!');
        this;
    }

    /**
     * @dev Executed when a claim has been validated and is ready to be executed. Doesn't necessarily emit/send
     * tokens.
     * @param beneficiary Address receiving the tokens
     * @param referrer Refer claimer to claim token
     * @param tokenAmount Number of tokens to be claimed
     */
    function _processAirdrop(address beneficiary, address referrer, uint256 tokenAmount) virtual internal {

    }
}


/**
 * @title CLDSale_V2
 * @dev The CLDSale enables the purchasing of CLD token at rates determined by the current block time.
 *      It requires the crowdsale contract address be given an allowance of 14000000 CLD enabling it to distribute the purchased tokens.
 */
contract CLDSale_V3 is AllowanceCrowdsale, Airdrop{
    using SafeMath for uint256;

    /**
     * @dev Constructor, calls the inherited classes constructors
     * @param rate Number of token units a buyer gets per wei
     * @param landToken The landToken address, must be an ERC20 contract
     * @param landTokensOwner Address holding the tokens, which has approved allowance to the crowdsale
     * @param fundWallet Address that will receive the deposited fund
     * @param airdropFee amount of BNB for claim airdrop
     */
    constructor(uint256 rate, IERC20 landToken, address landTokensOwner, address payable fundWallet, uint256 airdropFee)
        Crowdsale(rate, fundWallet, landToken)
        AllowanceCrowdsale(landTokensOwner)
        Airdrop(airdropFee)
        public
    {
    }

     /**
     * @dev This function to purchase
     * @param beneficiary Recipient of the token purchase
     */
    function buyTokens(address beneficiary) public override payable {
        super.buyTokens(beneficiary);
        wallet().transfer(msg.value.mul(10).div(100)); // transfer referral Commission to wallet
    }

    
     /**
     * @dev This function to purchase via reffral account
     * @param beneficiary Recipient of the token purchase
     * @param referrer Refer purchaser to purchase token
     */
    function buyTokensWithRefer(address beneficiary, address referrer) public payable {
        _preValidateReferrer(beneficiary, referrer);
        super.buyTokens(beneficiary);
        _updateReferral(beneficiary, referrer);
        _referralCommission[referrer] = _referralCommission[referrer].add(msg.value.mul(referralPercent()).div(100));
    }

    /**
     * @dev Overrides function in the Crowdsale contract to enable a custom phased distribution
     * @param weiAmount Value in wei to be converted into tokens
     * @return Number of tokens that can be purchased with the specified weiAmount
     */
    function _getTokenAmount(uint256 weiAmount) override internal view returns (uint256) {
        uint256 amount = weiAmount.mul(rate());
        if (amount >= 500000 * 1e18) {
            return amount.mul(120).div(100);
        } else if (amount >= 200000 * 1e18) {
            return amount.mul(114).div(100);
        } else if (amount >= 70000 * 1e18) {
            return amount.mul(109).div(100);
        } else if (amount >= 30000 * 1e18) {
            return amount.mul(106).div(100);
        } else if (amount >= 10000 * 1e18) {
            return amount.mul(104).div(100);
        } else {
            return amount;
        }
    }

    /**
     * @dev Determines how ETH is stored/forwarded on purchases.
     */
    function _forwardFunds() override internal {
        wallet().transfer(msg.value.sub(msg.value.mul(referralPercent()).div(100)));
    }
    
    /**
     * @dev Executed when a claim has been validated and is ready to be executed. Doesn't necessarily emit/send
     * tokens.
     * @param beneficiary Address receiving the tokens
     * @param referrer Refer claimer to claim token
     * @param tokenAmount Number of tokens to be claimed
     */
    function _processAirdrop(address beneficiary, address referrer, uint256 tokenAmount) override internal {
        _deliverTokens(beneficiary, tokenAmount);
        _updateReferral(beneficiary, referrer);
        _deliverTokens(parent(beneficiary), tokenAmount.mul(referralPercent()).div(100));
        wallet().transfer(msg.value);

    }
}

File 2 of 9 : Context.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

File 3 of 9 : IERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

File 4 of 9 : Math.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a / b + (a % b == 0 ? 0 : 1);
    }
}

File 5 of 9 : SafeMath.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

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

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

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

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

File 6 of 9 : SafeERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    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));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        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) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

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

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

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

File 7 of 9 : ReentrancyGuard.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

File 8 of 9 : Ownable.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

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

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

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

File 9 of 9 : Address.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    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");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    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");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    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);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    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);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    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);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    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);
            }
        }
    }
}

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"uint256","name":"rate","type":"uint256"},{"internalType":"contract IERC20","name":"landToken","type":"address"},{"internalType":"address","name":"landTokensOwner","type":"address"},{"internalType":"address payable","name":"fundWallet","type":"address"},{"internalType":"uint256","name":"airdropFee","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"claimer","type":"address"},{"indexed":true,"internalType":"address","name":"referrer","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AirdropClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"CommissionPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"address","name":"referrer","type":"address"}],"name":"Register","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"purchaser","type":"address"},{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensPurchased","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"airdropAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"}],"name":"airdropClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"airdropFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"airdropWeiRaised","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"}],"name":"buyTokens","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"address","name":"referrer","type":"address"}],"name":"buyTokensWithRefer","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"referrer","type":"address"}],"name":"claimTokens","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"commissionPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"parent","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"referralCommission","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"referralPercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"remainingTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newRate","type":"uint256"}],"name":"setRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wallet","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"weiRaised","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawReferralCommission","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

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