Contract 0x5344c20fd242545f31723689662ac12b9556fc3d 5

 

Contract Overview

Wakanda Inu: WKD Token
Balance:
0 BNB

BNB Value:
$0.00

Token:
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xcf09574866d1def42ba18723addf4e351614bdeafa26f79356b4db05055d0d41Approve144619452022-01-18 3:21:2618 mins ago0xe8d5a87c67807872ed53a4b82066ef6382c6ff26 IN  Wakanda Inu: WKD Token0 BNB0.000266148
0x64c42d4b7c65e043aa383b761d33bb8f5805c082084a3eb156683953d304e98bApprove144614502022-01-18 2:56:0244 mins ago0x89f1eb690603d2ea42f3ee58ba6a81c62ac7142f IN  Wakanda Inu: WKD Token0 BNB0.000072435
0xfecd56ba9fbbb5524667dc67920f4cf0250d7e06e0b17094af386d060ac17e62Approve144610292022-01-18 2:34:541 hr 5 mins ago0x93239d2a5b0b327c192e0effbe662a96282ba956 IN  Wakanda Inu: WKD Token0 BNB0.00022179
0x43d398eede96863927e62ea33a10caa98c7a2fafb4f766f6ce465316981c1b30Transfer144610252022-01-18 2:34:421 hr 5 mins ago0xc531fce29abe514b874583bd6426fef95aa0c54a IN  Wakanda Inu: WKD Token0 BNB0.00025999
0x1f1387358f6f2693f8b560e69690815381aadee0fc441d222726c7b2fdcd7484Approve144607682022-01-18 2:21:511 hr 18 mins ago0xc90a1b3dfc4a6464bc9c1e30e7277a38f2740c93 IN  Wakanda Inu: WKD Token0 BNB0.00022179
0x9456919eb3e3b09254c427cb65a9fcb224cc1cf730b63ce913ed9401fee64bb1Transfer144598772022-01-18 1:36:522 hrs 3 mins ago0x6d362188e11e431f4a1666df12f5129da37bb585 IN  Wakanda Inu: WKD Token0 BNB0.00025987
0x0a11ea232e67fa3955a4d0091a07257a062c5b9f947ebb84b4c5c867e385a735Approve144593612022-01-18 1:11:042 hrs 28 mins ago0x2b4a6f417fbcf08bb4fb8911478e4f19151fdbde IN  Wakanda Inu: WKD Token0 BNB0.00022179
0x87fbc8dfac0f73e03b7449353183e85291b2224b7d45a3f13ecfa5d392748fdcTransfer144592262022-01-18 1:04:192 hrs 35 mins ago0x1490b9bd1865f892422a3ba4bb8eb7ef33858b04 IN  Wakanda Inu: WKD Token0 BNB0.00018505
0x75ecbd5903461632cee3250c828c34e276ce607ca8b49871f092b695800926f7Transfer144592252022-01-18 1:04:162 hrs 35 mins ago0xd122febfddd0f9b8fc8a13971bb6fd68066e8cce IN  Wakanda Inu: WKD Token0 BNB0.00018493
0xbe50593a8366e4dcc9457767710ee96e23484c4508dfc86f4773b2b0b6bb6d8cApprove144591552022-01-18 1:00:422 hrs 39 mins ago0x2e1355d5b5ad46ecede21c4f08f1f18312f3aba4 IN  Wakanda Inu: WKD Token0 BNB0.00022179
0x42c0ca9c6fd246536e8388d259ee3e23fb906ddda3d234c807e5b851ed951eafApprove144591422022-01-18 1:00:032 hrs 39 mins ago0x291941935fe2fac47c25f31b055d48f9a54ceebf IN  Wakanda Inu: WKD Token0 BNB0.00022179
0x3bdb84f264edf20ef2c7608f8e86f90646179ade768a8aeb39f261688c0b10c8Transfer144590592022-01-18 0:55:542 hrs 44 mins ago0xfa09e326e203a9b4a24975a1c8556e63882f2fe2 IN  Wakanda Inu: WKD Token0 BNB0.00018505
0x089947a32535b84d78d75f91a7a525c83b0ab7a71e62306312bd7bb14d1e0b32Approve144587762022-01-18 0:41:452 hrs 58 mins ago0x29b7813bb2e3b421402a50ddecf45c6eec6eef9d IN  Wakanda Inu: WKD Token0 BNB0.00022179
0x1cedce324413b37f008003b0be08e3654c9eafd3fd32e73216f8a044d139fdbdApprove144584562022-01-18 0:25:453 hrs 14 mins ago0x738b0139e4a6b28478056174916623cdfafbc2db IN  Wakanda Inu: WKD Token0 BNB0.000310506
0xec2b4a34178de5959828547037c30b2516a963bd72d80b5df8bd4b7ccee617e6Transfer144582962022-01-18 0:17:453 hrs 22 mins ago0x81f074bf41232f59db67355fd81e3c2df44df065 IN  Wakanda Inu: WKD Token0 BNB0.00025993
0xfff30db442e695e39b6c2ceecc5149a64eb0314732f5200995dd07c132370d21Transfer144581572022-01-18 0:10:483 hrs 29 mins ago0x4868ea12ef3deb01cfcff7cb62e651f03d2c2d9d IN  Wakanda Inu: WKD Token0 BNB0.00014305
0x5bdb4ef210b149ee539ae48591934b8f5cb3671fcb1842e12389e7f7ac3a145aApprove144580482022-01-18 0:05:113 hrs 34 mins ago0xb3f06f8ff6e235bbd8d736d225baa89dc5366c6b IN  Wakanda Inu: WKD Token0 BNB0.000176106
0x44f28ea7d503841ae47fbddb0253232938fc8940c8a7d097ba3dfe2bf05380d1Approve144580392022-01-18 0:04:433 hrs 35 mins ago0xb3f06f8ff6e235bbd8d736d225baa89dc5366c6b IN  Wakanda Inu: WKD Token0 BNB0.000310506
0x1336bb89af9bb20d398c94a3823dd20a1a31b8c70e487426dbd64df2a55a2146Transfer144576672022-01-17 23:44:373 hrs 55 mins ago0x5edfda62c75a9bd110fab79a8c03255ed48f5e4f IN  Wakanda Inu: WKD Token0 BNB0.00018487
0x50f65d33dd92abfed8e878711caa003db476622c5d1c2d357a1c6612cbd8b367Transfer144575842022-01-17 23:40:033 hrs 59 mins ago0xfa69e792456240111a723db69f26ca5d74de7d9d IN  Wakanda Inu: WKD Token0 BNB0.00018493
0x30ab2aa56fde62b03f38fc8cd507d2edbd4d602a04a758cf640ce3dc89f5b7eeTransfer144574522022-01-17 23:33:274 hrs 6 mins ago0x0e3c4666620a56680e44581f2991b1a0b393f5c4 IN  Wakanda Inu: WKD Token0 BNB0.00025987
0x43f0c76fa249af6472922d135a01f096e92feae3540750a4bf168edf9a8efe12Transfer144572582022-01-17 23:23:454 hrs 16 mins ago0xca2694ff2254a20f08dac6d1d92a0604a9ad0b25 IN  Wakanda Inu: WKD Token0 BNB0.00026005
0xd9752ee1444b5bd8888a28c7f1737141494b3881ff84b85013966c91bec2bc25Approve144571092022-01-17 23:16:184 hrs 23 mins ago0x536d9945d17fda4c5e40119e56e3817ec0d68e66 IN  Wakanda Inu: WKD Token0 BNB0.00022179
0xd81092002685f57dfa66c38391f61c8d9e784a924bbacf636049e45e83a094fbTransfer144570432022-01-17 23:13:004 hrs 27 mins ago0xc815fa20e0a6a53604e600eef963990e4207ec66 IN  Wakanda Inu: WKD Token0 BNB0.00025993
0xf4386fe5fb9d7d2451bd439f44980c49fb5e0e8b1735fc438c86b5a8636ee319Transfer144570172022-01-17 23:11:424 hrs 28 mins ago0xa4f0afa87da6ffd51124ff2be93b040ea913d807 IN  Wakanda Inu: WKD Token0 BNB0.00018487
[ Download CSV Export 

OVERVIEW

Wakanda Inu is a community meme project forged from the deep and warm consciousness of humanity. Wakanda Inu (WKD), the digital meme token that represents the daily struggles and aspirations of the best aspects of what it means to be alive - truly alive as a community.

Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
WakandaInuToken

Compiler Version
v0.7.0+commit.9e61f92b

Optimization Enabled:
Yes with 999999 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity Standard Json-Input format)

File 1 of 10 : WakandaInuToken.sol
// SPDX-License-Identifier: MIT
pragma solidity =0.7.0;
import "./BEP20Pausable.sol";
import "./BEP20.sol";
import "./interfaces/IBEP20.sol";

import "./SafeMath.sol";
import "./SafeBEP20.sol";

contract WakandaInuToken is BEP20Pausable {
    using SafeMath for uint256;
    using SafeBEP20 for IBEP20;

    uint256 private _price;

    constructor() BEP20("Wakanda Inu Token", "WKD", 9, 1000000000000000000000000) {}

    function withdrawTokens() public virtual onlyOwner{
        address contractAddress = address(this);
        uint tokenBalance = balanceOf(contractAddress);
        _transfer(contractAddress,owner,tokenBalance);
    }

    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {BEP20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {BEP20-_burn} and {BEP20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        uint256 decreasedAllowance = allowance(account, _msgSender()).sub(
            amount,
            "BEP20: burn amount exceeds allowance"
        );

        _approve(account, _msgSender(), decreasedAllowance);
        _burn(account, amount);
    }

    function withdraw() external onlyOwner {
        uint balance = address(this).balance;
        msg.sender.transfer(balance);
    }

    function withdraw(address tokenAddress) external onlyOwner {
        IBEP20 token = IBEP20(tokenAddress);
        uint256 balance = token.balanceOf(address(this));
        token.safeTransfer(_msgSender(), balance);        
    }

    
}

File 2 of 10 : IBEP20.sol
// SPDX-License-Identifier: MIT

pragma solidity 0.7.0;

/**
 * @dev Interface of the BEP20 standard as defined in the EIP.
 */
interface IBEP20 {
    /**
     * @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 3 of 10 : SafeMath.sol
// SPDX-License-Identifier: MIT

pragma solidity 0.7.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.
     */
    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.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @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.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

File 4 of 10 : SafeBEP20.sol
// SPDX-License-Identifier: MIT

pragma solidity 0.7.0;

import './SafeMath.sol';
import './Address.sol';
import './interfaces/IBEP20.sol';

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

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

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

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

    function safeIncreaseAllowance(IBEP20 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(IBEP20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeBEP20: decreased allowance below zero");
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }
    function callOptionalReturn(IBEP20 token, bytes memory data) private {
        require(address(token).isContract(), "SafeBEP20: call to non-contract");

        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeBEP20: low-level call failed");

        if (returndata.length > 0) {
            require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed");
        }
    }
}

File 5 of 10 : Pausable.sol
// SPDX-License-Identifier: MIT

pragma solidity 0.7.0;

import "./Context.sol";
import "./Ownable.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context, Ownable {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

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

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!_paused, "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(_paused, "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual onlyOwner whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual onlyOwner whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

File 6 of 10 : Ownable.sol
// SPDX-License-Identifier: MIT

pragma solidity 0.7.0;

/*
 * Ownable
 *
 * Base contract with an owner.
 * Provides onlyOwner modifier, which prevents function from running if it is called by anyone other than the owner.
 */
abstract contract Ownable {
    address payable public owner;

    constructor() {
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Unauthorized access to contract");
        _;
    }

    function transferOwnership(address payable newOwner) public onlyOwner {
        if (newOwner != address(0)) {
            owner = newOwner;
        }
    }
}

File 7 of 10 : Context.sol
// SPDX-License-Identifier: MIT

pragma solidity 0.7.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.
 */
abstract contract Context {
    function _msgSender() internal virtual view returns (address payable) {
        return msg.sender;
    }

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

File 8 of 10 : BEP20Pausable.sol
// SPDX-License-Identifier: MIT

pragma solidity 0.7.0;

import "./BEP20.sol";
import "./Pausable.sol";

/**
 * @dev BEP20 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 */
abstract contract BEP20Pausable is BEP20, Pausable {
    /**
     * @dev See {BEP20-_beforeTokenTransfer}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);

        require(!paused(), "BEP20Pausable: token transfer while paused");
    }
}

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

pragma solidity 0.7.0;

import "./Context.sol";
import "./interfaces/IBEP20.sol";
import "./SafeMath.sol";
import "./Address.sol";

/**
 * @dev Implementation of the {IBEP20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {BEP20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-BEP20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of BEP20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IBEP20-approve}.
 */
abstract contract BEP20 is Context, IBEP20 {
    using SafeMath for uint256;
    using Address for address;

    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(
        string memory name,
        string memory symbol,
        uint8 decimals,
        uint256 totalSupply
    ) {
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
        _totalSupply = totalSupply;

        _totalSupply = totalSupply;
        _balances[msg.sender] = totalSupply;

        emit Transfer(address(0), msg.sender, totalSupply);
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {BEP20} uses, unless {_setupDecimals} is
     * called.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IBEP20-balanceOf} and {IBEP20-transfer}.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IBEP20-totalSupply}.
     */
    function totalSupply() public override view returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IBEP20-balanceOf}.
     */
    function balanceOf(address account) public override view returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IBEP20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount)
        public
        virtual
        override
        returns (bool)
    {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IBEP20-allowance}.
     */
    function allowance(address owner, address spender)
        public
        virtual
        override
        view
        returns (uint256)
    {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IBEP20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount)
        public
        virtual
        override
        returns (bool)
    {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IBEP20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {BEP20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(
            sender,
            _msgSender(),
            _allowances[sender][_msgSender()].sub(
                amount,
                "BEP20: transfer amount exceeds allowance"
            )
        );
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IBEP20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue)
        public
        virtual
        returns (bool)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].add(addedValue)
        );
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IBEP20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue)
        public
        virtual
        returns (bool)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].sub(
                subtractedValue,
                "BEP20: decreased allowance below zero"
            )
        );
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "BEP20: transfer from the zero address");
        require(recipient != address(0), "BEP20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

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

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "BEP20: mint to the zero address");

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

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

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "BEP20: burn from the zero address");

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

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

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "BEP20: approve from the zero address");
        require(spender != address(0), "BEP20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

   

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

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

pragma solidity 0.7.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) {
        // 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 != accountHash && codehash != 0x0);
    }

    /**
     * @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");

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

Settings
{
  "remappings": [],
  "optimizer": {
    "enabled": true,
    "runs": 999999
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

Contract Security Audit

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawTokens","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.