Contract 0xcf0ab2809feca548d9f1fd7ed4782e37b79faf51

 
Ad
Ad
Txn Hash
Block
From
To
Value [Txn Fee]
0x686864bd4a3e190a08129fa75881e3faeda3b057df18200c83b9d2279dfc736866319842021-04-17 1:58:022 days 4 hrs ago0x12d450147758c20cc50265665b1cde4f569ce094 IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0xd99279a1836d068d22ae86ffcc62658a2c51a0fc6442d054d077f3ad5988775366256272021-04-16 20:39:062 days 9 hrs ago0xae0aae77d2610815f88dd1d72a79ab0609db834f IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000255995
0x0903801070ea41f1761701cd61eb7aced5f33722b6b53e83a8c22c86e218c27066083742021-04-16 6:10:133 days 28 mins ago0x87874d61eb1d3640f82dd094682bfdadb7613d09 IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000266298
0x5eb0fe42d6ee43915122c95ec089644fa2bd71dce85893d62becedb784a0ca8265806102021-04-15 7:00:313 days 23 hrs ago0x85a096e83d3e900cce5046a293e45c4904ed766f IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.0000725
0xadd5c362c85c2d545e66619565ed84d4c23894a178489600348be89e09920fa765571462021-04-14 11:25:204 days 19 hrs ago0xcfaf4c3451e958d4453aebfab252f1e938ed2f40 IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0x83d125291ceb793ee416b3b4fefabded129dd8261d15958948f81269c3e6c07f65439702021-04-14 0:26:315 days 6 hrs ago0xf1fd3ac9ba02ebb647428df005531c53c6e28124 IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0xe234f0e929b4f1825eed35eb62868b530ff7d93fa388fdc98e3eb00ccb1a1a0b65363022021-04-13 18:03:075 days 12 hrs ago0x9d3df88875ce26323d066b3d613b527e011cdaeb IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0xca8c321701e85c03b596e3f34f286bc430fc72bb013547dd29fd42b100154cc965264672021-04-13 9:51:225 days 20 hrs ago0x0c14473e17bb6fd3d6ba8561346610db9ac613cd IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0x849e14c0c4feea7dd8947245443a2808bbf71709d9fa808bd7bdb13441d8b85865256882021-04-13 9:12:255 days 21 hrs ago0x227f44ff8cf182c93ae613117fea207b3de895ce IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000190295
0x9dadb6e96d49fa91245e8a95811cddf4c1335b6defc081c3b998544da53f339765055192021-04-12 16:23:256 days 14 hrs ago0xe15fb15f3cdd174c540b886bf6738387d280653f IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0x033e19f56589d8c41bef8c19ecce1089facc920b084b76d1fe5566e7b5fade3e64997312021-04-12 11:31:346 days 19 hrs ago0x85a096e83d3e900cce5046a293e45c4904ed766f IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0xdfb7a24c5b6ea1590d079733929feb845ea0c1505f45f0793bff179e0c3493df64964822021-04-12 8:49:036 days 21 hrs ago0xfb9a3bc9e6517ab5389db4704973f6bb1e165179 IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000266298
0x6106ab80ad3f15524e90240afa21e276988f34f15b16880bdd001796e3dcc26064958062021-04-12 8:15:156 days 22 hrs ago0x7c50c689ae6909430ea730a6cb210f819c0c8fc2 IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0xdd075c60f162ad813d7de1f51b48ef264c7d50f84d574d162b705be55f85281964867062021-04-12 0:39:507 days 5 hrs ago0x655880633bf10cf97a91f67f4251b820668de0b0 IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0xbae22963d701ce504d68c85831589b52160c141b732233851d6eb6c33471e02164864192021-04-12 0:25:297 days 6 hrs ago0x99b15dcd84acdd3d9473c342847049c34e83e922 IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0xcbe5658bd3170fc43aeaf095f70a01b1a86c69a0fe0510cabe0fa7b57d783c7c64848402021-04-11 23:06:327 days 7 hrs ago0xaad886d227519875b3a218e445047e3342e6039c IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0x811231960ee05fe11be4db70bf57b1449027881919f0e72b5f20c7f89c9b62af64841592021-04-11 22:32:277 days 8 hrs ago0x0a5e22ac18e091e166bdd94188c1b6542cc59e15 IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0xf9c3e559c635b7b425ce3ba6b2e7f8eda2be94c0ddfaf6f7763f2d07580e6c8c64840602021-04-11 22:27:307 days 8 hrs ago0x88290a269f8ee26ca6182e2ad42c3d40046e4dac IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0x10b83800ddedaec5d426e9efbbcf399e8125b0103e4f887b337f17e266151b3e64757442021-04-11 15:31:387 days 15 hrs ago0x71e592b406d682f962623ebcee3a13ff211bda3b IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0x6eab37ddfd03be09d70a3c89731fa05a8065ed61d7b6e31056ac0a58ff297ced64742102021-04-11 14:14:567 days 16 hrs ago0x53c8f65f8042b3e3e891705efed1520eb3568c33 IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000180995
0xb87311c36ad8bd2c5d0f221ddf9a0f20dfe4e07fc2298402ca8724adf9579e0564733792021-04-11 13:33:157 days 17 hrs ago0x4a7cf2c29a28f90c7fd86e6255cbf2ca9c033c72 IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0x4cfe2f1af176e35d842086dcda8a112aa0d3359ec577c7fdad5f7a7c03e791ce64709982021-04-11 11:34:127 days 19 hrs ago0x5668dd73cd6b12b654053d1717a1f9e972175a6a IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000255995
0xf5f6e7c9fd293d75df810f61b51bfd676c2243dac7f408640665b32c08fb5f0464674712021-04-11 8:37:517 days 22 hrs ago0xae0a01260c53ce114297d8f7128a908d70ab8c8f IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0x226a958ba60b7d1e1f88b6551c9b283110909c6d4d082fd3b0e4e4feb84d19c164670782021-04-11 8:18:127 days 22 hrs ago0x050eb3cd7e6887f85a5a56915a7b88dfa3faa8cf IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.000221915
0x97b57dbb16efc681fd0afd833a30d28e7fa7fb2fcce1ba6f3cdf1df57fa1a0fd64667662021-04-11 8:02:367 days 22 hrs ago0xe0cae9556e4df4e0ed0dc29730231fca3fd9e100 IN  0xcf0ab2809feca548d9f1fd7ed4782e37b79faf510 BNB0.00044383
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
BunkerBitsV2

Compiler Version
v0.7.4+commit.3f05b770

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, Unlicense license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-03-31
*/

//SPDX-License-Identifier: UNLICENSED


// ----------------------------------------------------------------------------
// BunkerBits Token 
// https://bunkerbits.com
//
//Official ERC20 Version by Mr.Underground
// ----------------------------------------------------------------------------



pragma solidity >=0.6.0 <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 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 view virtual returns (address payable) {
        return msg.sender;
    }

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

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


pragma solidity >=0.6.0 <0.8.0;


pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 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);
}


pragma solidity >=0.6.0 <0.8.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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        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) {
        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) {
        // 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) {
        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) {
        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) {
        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) {
        require(b <= a, "SafeMath: subtraction overflow");
        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) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        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) {
        require(b > 0, "SafeMath: modulo by zero");
        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) {
        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.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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);
        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) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

pragma solidity >=0.6.0 <0.8.0;




/**
 * @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}.
 */
contract BEP20 is Context, IBEP20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

    /**
     * @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_) { 
        _name = name_;
        _symbol = symbol_;
        _decimals = 18;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual 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 virtual returns (uint8) {
        return _decimals;
    }

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

    /**
     * @dev See {IBEP20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override 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 view virtual override 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 BIP. 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 {IERC20-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 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 Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal virtual {
        _decimals = decimals_;
    }

    /**
     * @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 { }
}


pragma solidity >=0.6.0 <0.8.0;



/**
 * @dev Extension of {BEP20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract BEP20Burnable is Context, BEP20 {
    using SafeMath for uint256;

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


pragma solidity ^0.7.4;



contract BunkerBitsV2 is Context, BEP20Burnable {
    /**
     * @dev Constructor that gives _msgSender() all of existing tokens.
     */
   constructor(uint256 initialSupply) BEP20("BunkerBits", "BUNKER") {
        _mint(msg.sender, initialSupply);
    }
}

Contract ABI

[{"inputs":[{"internalType":"uint256","name":"initialSupply","type":"uint256"}],"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":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"},{"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":[],"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":"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"}]

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

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

00000000000000000000000000000000000000000000152d02c7e14af6800000

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000152d02c7e14af6800000


Deployed ByteCode Sourcemap

23046:264:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13587:91;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15733:169;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;15733:169:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;14686:108;;;:::i;:::-;;;;;;;;;;;;;;;;16384:321;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;16384:321:0;;;;;;;;;;;;;;;;;:::i;14530:91::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;17114:218;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;17114:218:0;;;;;;;;:::i;22915:91::-;;;;;;;;;;;;;;;;-1:-1:-1;22915:91:0;;:::i;:::-;;14857:127;;;;;;;;;;;;;;;;-1:-1:-1;14857:127:0;-1:-1:-1;;;;;14857:127:0;;:::i;13797:95::-;;;:::i;17835:269::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;17835:269:0;;;;;;;;:::i;15197:175::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;15197:175:0;;;;;;;;:::i;15435:151::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;15435:151:0;;;;;;;;;;:::i;13587:91::-;13665:5;13658:12;;;;;;;;-1:-1:-1;;13658:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13632:13;;13658:12;;13665:5;;13658:12;;13665:5;13658:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13587:91;:::o;15733:169::-;15816:4;15833:39;15842:12;:10;:12::i;:::-;15856:7;15865:6;15833:8;:39::i;:::-;-1:-1:-1;15890:4:0;15733:169;;;;:::o;14686:108::-;14774:12;;14686:108;:::o;16384:321::-;16490:4;16507:36;16517:6;16525:9;16536:6;16507:9;:36::i;:::-;16554:121;16563:6;16571:12;:10;:12::i;:::-;16585:89;16623:6;16585:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;16585:19:0;;;;;;:11;:19;;;;;;16605:12;:10;:12::i;:::-;-1:-1:-1;;;;;16585:33:0;;;;;;;;;;;;-1:-1:-1;16585:33:0;;;:89;:37;:89::i;:::-;16554:8;:121::i;:::-;-1:-1:-1;16693:4:0;16384:321;;;;;:::o;14530:91::-;14604:9;;;;14530:91;:::o;17114:218::-;17202:4;17219:83;17228:12;:10;:12::i;:::-;17242:7;17251:50;17290:10;17251:11;:25;17263:12;:10;:12::i;:::-;-1:-1:-1;;;;;17251:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;17251:25:0;;;:34;;;;;;;;;;;:38;:50::i;22915:91::-;22971:27;22977:12;:10;:12::i;:::-;22991:6;22971:5;:27::i;:::-;22915:91;:::o;14857:127::-;-1:-1:-1;;;;;14958:18:0;14931:7;14958:18;;;;;;;;;;;;14857:127::o;13797:95::-;13877:7;13870:14;;;;;;;;-1:-1:-1;;13870:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13844:13;;13870:14;;13877:7;;13870:14;;13877:7;13870:14;;;;;;;;;;;;;;;;;;;;;;;;17835:269;17928:4;17945:129;17954:12;:10;:12::i;:::-;17968:7;17977:96;18016:15;17977:96;;;;;;;;;;;;;;;;;:11;:25;17989:12;:10;:12::i;:::-;-1:-1:-1;;;;;17977:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;17977:25:0;;;:34;;;;;;;;;;;:96;:38;:96::i;15197:175::-;15283:4;15300:42;15310:12;:10;:12::i;:::-;15324:9;15335:6;15300:9;:42::i;15435:151::-;-1:-1:-1;;;;;15551:18:0;;;15524:7;15551:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;15435:151::o;6820:179::-;6878:7;6910:5;;;6934:6;;;;6926:46;;;;;-1:-1:-1;;;6926:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;6990:1;6820:179;-1:-1:-1;;;6820:179:0:o;886:106::-;974:10;886:106;:::o;20982:346::-;-1:-1:-1;;;;;21084:19:0;;21076:68;;;;-1:-1:-1;;;21076:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;21163:21:0;;21155:68;;;;-1:-1:-1;;;21155:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;21236:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;21288:32;;;;;;;;;;;;;;;;;20982:346;;;:::o;18594:539::-;-1:-1:-1;;;;;18700:20:0;;18692:70;;;;-1:-1:-1;;;18692:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18781:23:0;;18773:71;;;;-1:-1:-1;;;18773:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18857:47;18878:6;18886:9;18897:6;18857:20;:47::i;:::-;18937:71;18959:6;18937:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18937:17:0;;:9;:17;;;;;;;;;;;;:71;:21;:71::i;:::-;-1:-1:-1;;;;;18917:17:0;;;:9;:17;;;;;;;;;;;:91;;;;19042:20;;;;;;;:32;;19067:6;19042:24;:32::i;:::-;-1:-1:-1;;;;;19019:20:0;;;:9;:20;;;;;;;;;;;;:55;;;;19090:35;;;;;;;19019:20;;19090:35;;;;;;;;;;;;;18594:539;;;:::o;9647:166::-;9733:7;9769:12;9761:6;;;;9753:29;;;;-1:-1:-1;;;9753:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;9800:5:0;;;9647:166::o;20126:418::-;-1:-1:-1;;;;;20210:21:0;;20202:67;;;;-1:-1:-1;;;20202:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20282:49;20303:7;20320:1;20324:6;20282:20;:49::i;:::-;20365:68;20388:6;20365:68;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20365:18:0;;:9;:18;;;;;;;;;;;;:68;:22;:68::i;:::-;-1:-1:-1;;;;;20344:18:0;;:9;:18;;;;;;;;;;:89;20459:12;;:24;;20476:6;20459:16;:24::i;:::-;20444:12;:39;20499:37;;;;;;;;20525:1;;-1:-1:-1;;;;;20499:37:0;;;;;;;;;;;;20126:418;;:::o;22361:92::-;;;;:::o;7282:158::-;7340:7;7373:1;7368;:6;;7360:49;;;;;-1:-1:-1;;;7360:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7427:5:0;;;7282:158::o

Swarm Source

ipfs://68d97c527ddea614264ccbf99b2bef1427b11b03ea56c77e9334ba2c9e534ee5
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.