Contract 0xD5eA73160954fe5df295C60F8C8e15FA14DcCFb6

 

Contract Overview

Balance:
0 BNB

BNB Value:
$0.00

Token:
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x02cb18f90da568913f826aa9f87f8186933f90fb478aa044e4fbef434dd84f7bBuy Tokens119231782021-10-20 1:23:3514 mins ago0xcfc6368baeadeb2abe98dfe77be3e52a8fea4181 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.057 BNB0.000398645
0x0aec28b928dff4ef5ddf01a922050a3f951f4f45d835ff8a044b0425ac09692dBuy Tokens119206192021-10-19 23:13:482 hrs 23 mins ago0xe75cee6ddc04fbbe90379efb482ffe0dc41ce1c4 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.05 BNB0.000398645
0x30d7d680073879fa569a2adb2d2c4996623ca9f392e221d0dfcc6de308348094Buy Tokens119176662021-10-19 20:45:274 hrs 52 mins ago0xa5a59e564c66cd3a876137f17eaf4a10af6cc6b7 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb61.5 BNB0.000323645
0xd66450c75705000a95862d8adbb4b5020ce53292c067a3e95992d4b540656f82Buy Tokens119058732021-10-19 10:24:1815 hrs 13 mins ago0x9dba5e42d0b3e343017e0c6e384a927119621abf IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.01 BNB0.000398645
0x4e209fc295bcc8580cbef083f4e4b8ac1b5768336f96fa0750851827d44e98e9Buy Tokens119048292021-10-19 9:31:5416 hrs 5 mins ago0xf54fc664481a2093544ffafe4fb910d54c6f4de6 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.004 BNB0.000398645
0x0e10fc2c4906c43b1e8d58a4cf7ca1a4dc23f442ccddc8051b5096d2a42048f4Buy Tokens118507262021-10-17 12:10:322 days 13 hrs ago0x7d61239582e6fe08a3b02fc657b61003884cd99f IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.002 BNB0.000323645
0x034070e4ba3020fe96f225bd82c19cbccb1d97c993f1d3e4fe431a1c92a427feBuy Tokens118372882021-10-17 0:57:383 days 40 mins ago0xd4a2fb6af80598731d81987578a5c3edb1c5da7a IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.03 BNB0.000398645
0x49295db08a84337504a819d375e6b9311736a91a4ada34b3f68b54c2334ae5b5Buy Tokens117979292021-10-15 15:59:174 days 9 hrs ago0x7d61239582e6fe08a3b02fc657b61003884cd99f IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.004 BNB0.000398645
0x021cf9ede2bdc04a14a4bb74d4298b551f007d9cb6de7e1523666960a83cd34dBuy Tokens117249052021-10-13 2:32:246 days 23 hrs ago0xaee88f5cfd248dfca6f52c4c6388d336e877d459 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.1 BNB0.000398645
0x08e04c932e5af750b18738783b824524384763a5017335017370fe618d933a1dBuy Tokens117084982021-10-12 12:46:387 days 12 hrs ago0x36af6b52a260fdb3ca2ef6dc14b82a762730c1a9 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.02 BNB0.000323645
0xd796871ccf08de170c2126f23f26d2909fc9fa416f39190d18949aa6d5935512Buy Tokens116860932021-10-11 17:47:538 days 7 hrs ago0xae30323c012a3fdc07e918735035683cd2347a87 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.119677 BNB0.000398645
0xf9dcfdb4424b5824ea921443ebfc2cc3fbf04d5dd1105d1b7c3204caa1b518aaBuy Tokens116827062021-10-11 14:34:278 days 11 hrs ago0x6ce1728501846579f7270b99eec9b4afb8e8bce0 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.01 BNB0.000323645
0x6c3fa80986aeff2a72731fbe51b35e0293a2a165b3a9eab89cf252ba9f94c3b4Buy Tokens116815552021-10-11 13:36:548 days 12 hrs ago0x6ce1728501846579f7270b99eec9b4afb8e8bce0 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.005 BNB0.000398645
0xeb8c7618e6a97b7dec9a0a1cd25eb4ca48ec463b4413fdd93eae350c639a5f8eBuy Tokens116759172021-10-11 8:54:108 days 16 hrs ago0x14f4b345559ca1bb1b315f0f4adb30a6c43b520a IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.2 BNB0.000323645
0x2af55461959d835ade1414c16e87605dff0ce729be491d93a6ac65c9de7edcb0Buy Tokens116758252021-10-11 8:49:348 days 16 hrs ago0x14f4b345559ca1bb1b315f0f4adb30a6c43b520a IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.01 BNB0.000398645
0xd8711b9ff67b1316fcb245e855bb2c7430038087e7889ebfe2f0bea6005365fcBuy Tokens116611792021-10-10 20:36:029 days 5 hrs ago0x94a5cd9883523c6e9f9ece972365fc4cb5671876 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.024 BNB0.000398645
0xb66597a3f25903492d1175e719ace103fda16b9f7b6bf64b7c98ebe17d8ef9f8Buy Tokens116608412021-10-10 20:19:089 days 5 hrs ago0x3333cb7429f0e7ef3bd421e187511c9304db8f2c IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.1 BNB0.000398645
0x874248af8e1c1768fb52b1d3e2da95d999ce7b5d403390ea0ed6b671ec4803f0Buy Tokens116593332021-10-10 19:03:449 days 6 hrs ago0x95acd52fdcef7e995175056ebb8f44e0157351ff IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.02 BNB0.000398645
0x09c62651963e6be9c8c82df9995bcb6a2965b49770bb4f79c4eb3557c8499bbcBuy Tokens116581252021-10-10 18:03:209 days 7 hrs ago0x1797f1440e9f04cbe75562f8ad4ef6e27c00b630 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.06 BNB0.000398585
0x39ee973c6afc0ec9573314b10af6be6a8ea2ffba772a3c34594c62c5ecfcf3b1Buy Tokens116030172021-10-08 19:55:5311 days 5 hrs ago0x0dea0c00853d39c08057bde2effcca14ca0f3862 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.005 BNB0.000398585
0x4146d03686dab1c66aa3e125b8f224f86c23e0a6dbb44e24c681e1509175e586Buy Tokens115729882021-10-07 18:52:3312 days 6 hrs ago0xa490d9eb6dceaa29053aeb6974dbfce5bd083e21 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.005 BNB0.000398645
0x3c9fd86587fc286d976351bd6c9117701f9c324da01f1194c67e97429dea24c4Buy Tokens115726342021-10-07 18:34:5112 days 7 hrs ago0xcf29e9dbe9593937919119c75b707871bb857896 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.3 BNB0.000398645
0x8fd21c585ea5ebefec5ab66e64a9515504a13b183898a23b8bcbc4223b57b90cBuy Tokens115543992021-10-07 3:21:2912 days 22 hrs ago0x07484aeeb6f93a170af353d110d82b77620e8404 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.006 BNB0.000398645
0x3662e86b47c8b44dd15fc2f05a0d435e5ed8fe3334dc158c890b70f4cdce9eabBuy Tokens115418672021-10-06 16:54:3213 days 8 hrs ago0x23ea592fe06d3e6b3adfa92fa23ded98faf7cbd2 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.007 BNB0.000398645
0xa8a9756e6b7258afb8bb949b9f512da7b1b7b3caccd680f9026ffc04baee38b4Buy Tokens115362062021-10-06 12:10:4713 days 13 hrs ago0x36af6b52a260fdb3ca2ef6dc14b82a762730c1a9 IN  0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60.016 BNB0.000398645
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x02cb18f90da568913f826aa9f87f8186933f90fb478aa044e4fbef434dd84f7b119231782021-10-20 1:23:3514 mins ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.057 BNB
0x0aec28b928dff4ef5ddf01a922050a3f951f4f45d835ff8a044b0425ac09692d119206192021-10-19 23:13:482 hrs 23 mins ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.05 BNB
0x30d7d680073879fa569a2adb2d2c4996623ca9f392e221d0dfcc6de308348094119176662021-10-19 20:45:274 hrs 52 mins ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e691.5 BNB
0xd66450c75705000a95862d8adbb4b5020ce53292c067a3e95992d4b540656f82119058732021-10-19 10:24:1815 hrs 13 mins ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.01 BNB
0x4e209fc295bcc8580cbef083f4e4b8ac1b5768336f96fa0750851827d44e98e9119048292021-10-19 9:31:5416 hrs 5 mins ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.004 BNB
0x0e10fc2c4906c43b1e8d58a4cf7ca1a4dc23f442ccddc8051b5096d2a42048f4118507262021-10-17 12:10:322 days 13 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.002 BNB
0x034070e4ba3020fe96f225bd82c19cbccb1d97c993f1d3e4fe431a1c92a427fe118372882021-10-17 0:57:383 days 40 mins ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.03 BNB
0x49295db08a84337504a819d375e6b9311736a91a4ada34b3f68b54c2334ae5b5117979292021-10-15 15:59:174 days 9 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.004 BNB
0x021cf9ede2bdc04a14a4bb74d4298b551f007d9cb6de7e1523666960a83cd34d117249052021-10-13 2:32:246 days 23 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.1 BNB
0x08e04c932e5af750b18738783b824524384763a5017335017370fe618d933a1d117084982021-10-12 12:46:387 days 12 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.02 BNB
0xd796871ccf08de170c2126f23f26d2909fc9fa416f39190d18949aa6d5935512116860932021-10-11 17:47:538 days 7 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.119677 BNB
0xf9dcfdb4424b5824ea921443ebfc2cc3fbf04d5dd1105d1b7c3204caa1b518aa116827062021-10-11 14:34:278 days 11 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.01 BNB
0x6c3fa80986aeff2a72731fbe51b35e0293a2a165b3a9eab89cf252ba9f94c3b4116815552021-10-11 13:36:548 days 12 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.005 BNB
0xeb8c7618e6a97b7dec9a0a1cd25eb4ca48ec463b4413fdd93eae350c639a5f8e116759172021-10-11 8:54:108 days 16 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.2 BNB
0x2af55461959d835ade1414c16e87605dff0ce729be491d93a6ac65c9de7edcb0116758252021-10-11 8:49:348 days 16 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.01 BNB
0xd8711b9ff67b1316fcb245e855bb2c7430038087e7889ebfe2f0bea6005365fc116611792021-10-10 20:36:029 days 5 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.024 BNB
0xb66597a3f25903492d1175e719ace103fda16b9f7b6bf64b7c98ebe17d8ef9f8116608412021-10-10 20:19:089 days 5 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.1 BNB
0x874248af8e1c1768fb52b1d3e2da95d999ce7b5d403390ea0ed6b671ec4803f0116593332021-10-10 19:03:449 days 6 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.02 BNB
0x09c62651963e6be9c8c82df9995bcb6a2965b49770bb4f79c4eb3557c8499bbc116581252021-10-10 18:03:209 days 7 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.06 BNB
0x39ee973c6afc0ec9573314b10af6be6a8ea2ffba772a3c34594c62c5ecfcf3b1116030172021-10-08 19:55:5311 days 5 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.005 BNB
0x4146d03686dab1c66aa3e125b8f224f86c23e0a6dbb44e24c681e1509175e586115729882021-10-07 18:52:3312 days 6 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.005 BNB
0x3c9fd86587fc286d976351bd6c9117701f9c324da01f1194c67e97429dea24c4115726342021-10-07 18:34:5112 days 7 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.3 BNB
0x8fd21c585ea5ebefec5ab66e64a9515504a13b183898a23b8bcbc4223b57b90c115543992021-10-07 3:21:2912 days 22 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.006 BNB
0x3662e86b47c8b44dd15fc2f05a0d435e5ed8fe3334dc158c890b70f4cdce9eab115418672021-10-06 16:54:3213 days 8 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.007 BNB
0xa8a9756e6b7258afb8bb949b9f512da7b1b7b3caccd680f9026ffc04baee38b4115362062021-10-06 12:10:4713 days 13 hrs ago 0xd5ea73160954fe5df295c60f8c8e15fa14dccfb60xcaaf20ea8c9fcb42cfcb562f04b2108c0d111e690.016 BNB
[ Download CSV Export 
Loading

Contract Source Code Verified (Similar Match)
Note: This contract matches the deployed ByteCode of the Source Code for Contract 0xb4dcadd7d8dfd53bc5b226389901bdc7cf7f45fc

Contract Name:
Crowdsale

Compiler Version
v0.5.17+commit.d19bba13

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, Unlicense license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-09-06
*/

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.4.0/contracts/utils/Address.sol

pragma solidity ^0.5.5;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * This test is non-exhaustive, and there may be false-negatives: during the
     * execution of a contract's constructor, its address will be reported as
     * not containing 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.
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != 0x0 && codehash != accountHash);
    }

    /**
     * @dev Converts an `address` into `address payable`. Note that this is
     * simply a type cast: the actual underlying value is not changed.
     *
     * _Available since v2.4.0._
     */
    function toPayable(address account) internal pure returns (address payable) {
        return address(uint160(account));
    }

    /**
     * @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].
     *
     * _Available since v2.4.0._
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.4.0/contracts/token/ERC20/SafeERC20.sol

pragma solidity ^0.5.0;




/**
 * @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 ERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

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

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

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // 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'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

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

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

    /**
     * @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.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.4.0/contracts/utils/ReentrancyGuard.sol

pragma solidity ^0.5.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.
 */
contract ReentrancyGuard {
    // counter to allow mutex lock with only one SSTORE operation
    uint256 private _guardCounter;

    constructor () internal {
        // The counter starts at one to prevent changing it from zero to a non-zero
        // value, which is a more expensive operation.
        _guardCounter = 1;
    }

    /**
     * @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() {
        _guardCounter += 1;
        uint256 localCounter = _guardCounter;
        _;
        require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.4.0/contracts/math/SafeMath.sol

pragma solidity ^0.5.0;

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

        return c;
    }

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

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

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

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

        return c;
    }

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

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

        return c;
    }

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

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.4.0/contracts/GSN/Context.sol

pragma solidity ^0.5.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 GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor () internal { }
    // solhint-disable-previous-line no-empty-blocks

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

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.4.0/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.5.0;

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

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

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

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

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

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

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

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

// File: contracts/Crowdsale.sol



pragma solidity ^0.5.0;







/**
 * @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 {
    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.
     */
    function () 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;
    }

    /**
     * @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 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) 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) internal view returns (uint256) {
        return weiAmount.mul(_rate);
    }

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

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"uint256","name":"rate","type":"uint256"},{"internalType":"address payable","name":"wallet","type":"address"},{"internalType":"contract IERC20","name":"token","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"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"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"constant":false,"inputs":[{"internalType":"address","name":"beneficiary","type":"address"}],"name":"buyTokens","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"rate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"wallet","outputs":[{"internalType":"address payable","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"weiRaised","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]

608060405234801561001057600080fd5b50604051610d4e380380610d4e8339818101604052606081101561003357600080fd5b810190808051906020019092919080519060200190929190805190602001909291905050506001600081905550600083116100d6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260148152602001807f43726f776473616c653a2072617465206973203000000000000000000000000081525060200191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16141561015c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526025815260200180610d296025913960400191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156101e2576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526024815260200180610d056024913960400191505060405180910390fd5b8260038190555081600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550505050610a888061027d6000396000f3fe60806040526004361061004a5760003560e01c80632c4e722e1461005c5780634042b66f14610087578063521eb273146100b2578063ec8ac4d814610109578063fc0c546a1461014d575b61005a6100556101a4565b6101ac565b005b34801561006857600080fd5b50610071610310565b6040518082815260200191505060405180910390f35b34801561009357600080fd5b5061009c61031a565b6040518082815260200191505060405180910390f35b3480156100be57600080fd5b506100c7610324565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b61014b6004803603602081101561011f57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291905050506101ac565b005b34801561015957600080fd5b5061016261034e565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b600033905090565b6001600080828254019250508190555060008054905060003490506101d18382610378565b60006101dc82610479565b90506101f38260045461049790919063ffffffff16565b600481905550610203848261051f565b8373ffffffffffffffffffffffffffffffffffffffff166102226101a4565b73ffffffffffffffffffffffffffffffffffffffff167f6faf93231a456e552dbc9961f58d9713ee4f2e69d15f1975b050ef0911053a7b8484604051808381526020018281526020019250505060405180910390a3610281848361052d565b610289610531565b610293848361059c565b5050600054811461030c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601f8152602001807f5265656e7472616e637947756172643a207265656e7472616e742063616c6c0081525060200191505060405180910390fd5b5050565b6000600354905090565b6000600454905090565b6000600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6000600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156103fe576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602a815260200180610a00602a913960400191505060405180910390fd5b6000811415610475576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260198152602001807f43726f776473616c653a20776569416d6f756e7420697320300000000000000081525060200191505060405180910390fd5b5050565b6000610490600354836105a090919063ffffffff16565b9050919050565b600080828401905083811015610515576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601b8152602001807f536166654d6174683a206164646974696f6e206f766572666c6f77000000000081525060200191505060405180910390fd5b8091505092915050565b6105298282610626565b5050565b5050565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166108fc349081150290604051600060405180830381858888f19350505050158015610599573d6000803e3d6000fd5b50565b5050565b6000808314156105b35760009050610620565b60008284029050828482816105c457fe5b041461061b576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260218152602001806109df6021913960400191505060405180910390fd5b809150505b92915050565b6106738282600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166106779092919063ffffffff16565b5050565b610743838473ffffffffffffffffffffffffffffffffffffffff1663a9059cbb905060e01b8484604051602401808373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050610748565b505050565b6107678273ffffffffffffffffffffffffffffffffffffffff16610993565b6107d9576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601f8152602001807f5361666545524332303a2063616c6c20746f206e6f6e2d636f6e74726163740081525060200191505060405180910390fd5b600060608373ffffffffffffffffffffffffffffffffffffffff16836040518082805190602001908083835b602083106108285780518252602082019150602081019050602083039250610805565b6001836020036101000a0380198251168184511680821785525050505050509050019150506000604051808303816000865af19150503d806000811461088a576040519150601f19603f3d011682016040523d82523d6000602084013e61088f565b606091505b509150915081610907576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c656481525060200191505060405180910390fd5b60008151111561098d5780806020019051602081101561092657600080fd5b810190808051906020019092919050505061098c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602a815260200180610a2a602a913960400191505060405180910390fd5b5b50505050565b60008060007fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060001b9050833f91506000801b82141580156109d55750808214155b9250505091905056fe536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f7743726f776473616c653a2062656e656669636961727920697320746865207a65726f20616464726573735361666545524332303a204552433230206f7065726174696f6e20646964206e6f742073756363656564a265627a7a72315820002c75fe04400568d3aeb1c0de6720b2c04a340b663d04e8a8baf84a4fa10b2564736f6c6343000511003243726f776473616c653a20746f6b656e20697320746865207a65726f206164647265737343726f776473616c653a2077616c6c657420697320746865207a65726f2061646472657373000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000caaf20ea8c9fcb42cfcb562f04b2108c0d111e6900000000000000000000000096835a2c4556ae84699b07eedde4e9ff83db3862

Deployed ByteCode Sourcemap

19207:6934:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21381:23;21391:12;:10;:12::i;:::-;21381:9;:23::i;:::-;19207:6934;21820:77;;8:9:-1;5:2;;;30:1;27;20:12;5:2;21820:77:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;21965:87;;8:9:-1;5:2;;;30:1;27;20:12;5:2;21965:87:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;21641:89;;8:9:-1;5:2;;;30:1;27;20:12;5:2;21641:89:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;22317:622;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;22317:622:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;21482:78;;8:9:-1;5:2;;;30:1;27;20:12;5:2;21482:78:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;15149:98;15194:15;15229:10;15222:17;;15149:98;:::o;22317:622::-;8516:1;8499:13;;:18;;;;;;;;;;;8528:20;8551:13;;8528:36;;22396:17;22416:9;22396:29;;22436:44;22457:11;22470:9;22436:20;:44::i;:::-;22542:14;22559:26;22575:9;22559:15;:26::i;:::-;22542:43;;22636:25;22651:9;22636:10;;:14;;:25;;;;:::i;:::-;22623:10;:38;;;;22674:37;22691:11;22704:6;22674:16;:37::i;:::-;22757:11;22727:61;;22743:12;:10;:12::i;:::-;22727:61;;;22770:9;22781:6;22727:61;;;;;;;;;;;;;;;;;;;;;;;;22801:46;22824:11;22837:9;22801:22;:46::i;:::-;22860:15;:13;:15::i;:::-;22886:45;22908:11;22921:9;22886:21;:45::i;:::-;8575:1;;8611:13;;8595:12;:29;8587:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22317:622;;:::o;21820:77::-;21857:7;21884:5;;21877:12;;21820:77;:::o;21965:87::-;22007:7;22034:10;;22027:17;;21965:87;:::o;21641:89::-;21680:15;21715:7;;;;;;;;;;;21708:14;;21641:89;:::o;21482:78::-;21520:6;21546;;;;;;;;;;;21539:13;;21482:78;:::o;23492:380::-;23618:1;23595:25;;:11;:25;;;;23587:80;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23699:1;23686:9;:14;;23678:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23492:380;;:::o;25844:122::-;25911:7;25938:20;25952:5;;25938:9;:13;;:20;;;;:::i;:::-;25931:27;;25844:122;;;:::o;9641:181::-;9699:7;9719:9;9735:1;9731;:5;9719:17;;9760:1;9755;:6;;9747:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9813:1;9806:8;;;9641:181;;;;:::o;25027:136::-;25115:40;25130:11;25143;25115:14;:40::i;:::-;25027:136;;:::o;25441:147::-;;;:::o;26058:80::-;26103:7;;;;;;;;;;;:16;;:27;26120:9;26103:27;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;26103:27:0;26058:80::o;24175:151::-;;;:::o;11013:471::-;11071:7;11321:1;11316;:6;11312:47;;;11346:1;11339:8;;;;11312:47;11371:9;11387:1;11383;:5;11371:17;;11416:1;11411;11407;:5;;;;;;:10;11399:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11475:1;11468:8;;;11013:471;;;;;:::o;24614:139::-;24700:45;24720:11;24733;24700:6;;;;;;;;;;;:19;;;;:45;;;;;:::i;:::-;24614:139;;:::o;3896:176::-;3979:85;3998:5;4028;:14;;;:23;;;;4053:2;4057:5;4005:58;;;;;;;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;4005:58:0;;;;;;;38:4:-1;29:7;25:18;67:10;61:17;96:58;199:8;192:4;186;182:15;179:29;167:10;160:49;0:215;;;4005:58:0;3979:18;:85::i;:::-;3896:176;;;:::o;5935:1114::-;6539:27;6547:5;6539:25;;;:27::i;:::-;6531:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6676:12;6690:23;6725:5;6717:19;;6737:4;6717:25;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;6717:25:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;6675:67:0;;;;6761:7;6753:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6842:1;6822:10;:17;:21;6818:224;;;6964:10;6953:30;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;6953:30:0;;;;;;;;;;;;;;;;6945:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6818:224;5935:1114;;;;:::o;681:810::-;741:4;1194:16;1221:19;1243:66;1221:88;;;;1412:7;1400:20;1388:32;;1452:3;1440:15;;:8;:15;;:42;;;;;1471:11;1459:8;:23;;1440:42;1432:51;;;;681:810;;;:::o

Swarm Source

bzzr://002c75fe04400568d3aeb1c0de6720b2c04a340b663d04e8a8baf84a4fa10b25
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.