Contract 0x338af54976b9d4f7f41c97dcb60dfec0694149f9 4

 
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x90b4dfeeb935451d0f32ec7df862cd1bf627d448bf4ea4a960a30a9b9121788eApprove146939192022-01-26 5:23:3712 mins ago0x88afcb010f03b3b6e09c67d4dae308030f7007cb IN Rooster Battle: RICE Token0 BNB0.000220935
0x18cc5bd937b85ac9efae76f1dd7e2c2f6f2a7cf06d52e4dc1661022c520a235dTransfer146938802022-01-26 5:21:4014 mins ago0xac7e97b7defd9d263fbe9de37bb73e23a9c0b66c IN Rooster Battle: RICE Token0 BNB0.000171545
0x5f38f0f2864af76576bc092c54f1913b006e43d5a699e9b6724e523a495453adApprove146937942022-01-26 5:17:2218 mins ago0x9620b69ebdd4998d262b3801b7a92606e7b15b34 IN Rooster Battle: RICE Token0 BNB0.000146115
0x4851f6ca38427ec30105d3e64faeb5e327c61f449aa807e286be66ee650e2503Approve146936382022-01-26 5:09:3426 mins ago0xeacc7ad569e8ae836e84a58eafb281ad656af0ed IN Rooster Battle: RICE Token0 BNB0.000221055
0xe356806a6a18e891c669490f2afe40cb01f130641223032f6a329fecbd4109f5Approve146935222022-01-26 5:03:4631 mins ago0x23a859081bdfd4cb47fa8be87c0d25e2eb326bed IN Rooster Battle: RICE Token0 BNB0.000220935
0xe0a6ff54a661b86ff8219e4d74580dcb24c8197e46204e5e3f2d06c030002849Approve146935032022-01-26 5:02:4932 mins ago0x29edc8c0a8753eeea4f4baa229c76d54199c9cad IN Rooster Battle: RICE Token0 BNB0.000145935
0x0acc53cea602af9a5d639e5e7998c47d46df96e344ec27ffe06f819a7b88b876Approve146934772022-01-26 5:01:3134 mins ago0x548759eab1bc01297f8ee8b920534aae01e11449 IN Rooster Battle: RICE Token0 BNB0.000222435
0x13a9f3caf1bc612b4d54a27d3bc1fdd1ec9dd0b28bdaace0cbbd5c3df9d81a7bApprove146933562022-01-26 4:55:2840 mins ago0x098361f9f1f3a7cb2f256cf5ae9893ba9e85b008 IN Rooster Battle: RICE Token0 BNB0.000220935
0xbde356e688b90cc8899eb808c492dc06dbf2d74d2dc203a3740bf7bc5bf73373Approve146933442022-01-26 4:54:5240 mins ago0xad6cf528670ced094d5062741e3e88e5cdc575d1 IN Rooster Battle: RICE Token0 BNB0.000146115
0x8375d3aac03cec428590d1083310c7629d1bcdaa468a364056c3544a836d6297Approve146933102022-01-26 4:53:1042 mins ago0x7c0cf66a7b91098b129d9f52cdf8248082fc1059 IN Rooster Battle: RICE Token0 BNB0.000220935
0xead08cb72c61a161a8de4b86d3f712bcc0401237c17143223e8df9e38e4ddd0aTransfer146932622022-01-26 4:50:4644 mins ago0x931c1a2cde5a235a134533f3f94a660bdd0617a4 IN Rooster Battle: RICE Token0 BNB0.000171545
0x300c9f1d3b1a523fa5767a091affde89312cd2bf8b745335a66863652a2c17beApprove146932422022-01-26 4:49:4645 mins ago0x66c2749677a1bf8afed943689db28c2a7395578e IN Rooster Battle: RICE Token0 BNB0.00007276
0xdde22806df95d7eab8841fc5389267014df706e0464e432077e04709515e1ab1Approve146932092022-01-26 4:48:0747 mins ago0xa890d773eaab6bec6330a3e3d53a53dcd44389cb IN Rooster Battle: RICE Token0 BNB0.000220935
0xf76a9b403dd44702bae8c6d3604e7df9571d873bbb8d602cda7bdb4ac4faba1cApprove146931932022-01-26 4:47:1948 mins ago0xd77a66635710f0db5aa28c741364f7128260d654 IN Rooster Battle: RICE Token0 BNB0.000220995
0xf4d5996a576f628d56199f72a60299cc91a626e2a182f366343c76bb07b782c7Approve146931082022-01-26 4:43:0452 mins ago0x21854e24e7a657bf07f3bd282d5baf0d56e6d518 IN Rooster Battle: RICE Token0 BNB0.000220935
0x2e6990618321c3756b81a536c72627c01a4208f352fcf2cbe85bdcb4dfcf0e49Transfer146930652022-01-26 4:40:5554 mins ago0xf2d030657275d825114025fa791ea3f38214909d IN Rooster Battle: RICE Token0 BNB0.000246545
0x0f1f0422befa46e95aa0827c036b73c5824c6d653227c969fa7f59700f9ac61bApprove146928842022-01-26 4:31:521 hr 3 mins ago0xd223c4b5bba47d377910dd72de8ee350cdc0c8e7 IN Rooster Battle: RICE Token0 BNB0.000220935
0xb9f24b17de18a39c379d1de9fdc89ae8e1daf5be8c8442fff1ded6689cc7a2cbTransfer146928202022-01-26 4:28:401 hr 7 mins ago0xf2d030657275d825114025fa791ea3f38214909d IN Rooster Battle: RICE Token0 BNB0.000246545
0xfe7b8099bee0be827997d66a02b75bff6f4674c08f243731e454aee2d338e9a1Approve146927322022-01-26 4:24:161 hr 11 mins ago0x2fd2df553868bc24fbf566aeea0dea1487092a6f IN Rooster Battle: RICE Token0 BNB0.000221055
0x199b4c1f3300e0b079d40e529c592a16357488171d2c0c2327b8a47c08f94682Approve146926352022-01-26 4:19:251 hr 16 mins ago0x8e4972a09089a04ae8b9b935ef7cff98cc167e97 IN Rooster Battle: RICE Token0 BNB0.000221115
0x96e201936c2f9371c49bb1361311259508e684d70da1d5082056ad3d3d3157fbApprove146926322022-01-26 4:19:161 hr 16 mins ago0x2fdc144aca6a40b3d7187c7773ec772663e28795 IN Rooster Battle: RICE Token0 BNB0.000145935
0x6a1cafd53ba45f86047cad29c7efc0b642e6a9729ce48adfdeac76e7d884a0edApprove146925262022-01-26 4:13:581 hr 21 mins ago0x197cdd32b281df7e77ffe54a075d46d9b542e7a2 IN Rooster Battle: RICE Token0 BNB0.000221115
0xf7fccebfdf9afab1ba677789bf1a5f31699367e5d12b641c84856accc15ed470Approve146925182022-01-26 4:13:341 hr 22 mins ago0xbea2ab493072dde22323e7f74dcdaa840c593b10 IN Rooster Battle: RICE Token0 BNB0.000145935
0x27c62b09fee67051d1a4ffe31daeb16bf1518262d54c7cc37c76cd500736d331Approve146923222022-01-26 4:03:461 hr 31 mins ago0xfdc564a8a78f0a7780c13e23406a54f0389671d6 IN Rooster Battle: RICE Token0 BNB0.000146055
0x5737045bc2ed5ff963026e934e49f18f680028e2bb7d309f9b36775edbcb1876Approve146923012022-01-26 4:02:431 hr 33 mins ago0xa09d52b8b22ab30c5d21dda51c4e45fcfebe789a IN Rooster Battle: RICE Token0 BNB0.000222435
[ Download CSV Export 

OVERVIEW

Rooster Battle is a game based on the popular cockfighting sport in many countries around the world with a history of up to 6000 years. “Rooster Battle“ game project started in 2013 and quickly gained a lot of attention from cockfighting lovers all over the world.

Latest 1 internal transaction
Parent Txn Hash Block From To Value
0x8d09d8d0d8bdb5d9ee160f203c5888e9c0345b735ee833878e66119c1c785908130120662021-11-28 2:11:1759 days 3 hrs ago Rooster Battle: RICE Token0x4b04213c2774f77e60702880654206b116d005080.2 BNB
[ Download CSV Export 
Loading

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

Contract Name:
AntiBotStandardToken

Compiler Version
v0.8.4+commit.c7e474f2

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-11-21
*/

// Dependency file: @openzeppelin/contracts/token/ERC20/IERC20.sol

// SPDX-License-Identifier: MIT

// pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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


// Dependency file: @openzeppelin/contracts/utils/Context.sol


// pragma solidity ^0.8.0;

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

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


// Dependency file: @openzeppelin/contracts/access/Ownable.sol


// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts/utils/Context.sol";

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

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

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

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

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

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

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

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


// Dependency file: @openzeppelin/contracts/utils/math/SafeMath.sol


// pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// Dependency file: contracts/interfaces/IPinkAntiBot.sol

// pragma solidity >=0.5.0;

interface IPinkAntiBot {
  function setTokenOwner(address owner) external;

  function onPreTransferCheck(
    address from,
    address to,
    uint256 amount
  ) external;
}


// Dependency file: contracts/BaseToken.sol

// pragma solidity =0.8.4;

enum TokenType {
    standard,
    antiBotStandard,
    liquidityGenerator,
    antiBotLiquidityGenerator,
    baby,
    antiBotBaby,
    buybackBaby,
    antiBotBuybackBaby
}

abstract contract BaseToken {
    event TokenCreated(
        address indexed owner,
        address indexed token,
        TokenType tokenType,
        uint256 version
    );
}


// Root file: contracts/standard/AntiBotStandardToken.sol

pragma solidity =0.8.4;

// import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
// import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// import "contracts/interfaces/IPinkAntiBot.sol";
// import "contracts/BaseToken.sol";

contract AntiBotStandardToken is IERC20, Ownable, BaseToken {
    using SafeMath for uint256;

    uint256 public constant VERSION = 1;

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

    string private _name;
    string private _symbol;
    uint8 private _decimals;
    uint256 private _totalSupply;

    IPinkAntiBot public pinkAntiBot;
    bool public enableAntiBot;

    constructor(
        string memory name_,
        string memory symbol_,
        uint8 decimals_,
        uint256 totalSupply_,
        address pinkAntiBot_,
        address serviceFeeReceiver_,
        uint256 serviceFee_
    ) payable {
        _name = name_;
        _symbol = symbol_;
        _decimals = decimals_;
        _mint(owner(), totalSupply_);

        pinkAntiBot = IPinkAntiBot(pinkAntiBot_);
        pinkAntiBot.setTokenOwner(owner());
        enableAntiBot = true;

        emit TokenCreated(
            owner(),
            address(this),
            TokenType.antiBotStandard,
            VERSION
        );

        payable(serviceFeeReceiver_).transfer(serviceFee_);
    }

    function setEnableAntiBot(bool _enable) external onlyOwner {
        enableAntiBot = _enable;
    }

    /**
     * @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 {ERC20} 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
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return _decimals;
    }

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

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

    /**
     * @dev See {IERC20-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 {IERC20-allowance}.
     */
    function allowance(address owner, address spender)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-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 {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * 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,
                "ERC20: 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 {IERC20-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,
                "ERC20: 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), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        if (enableAntiBot) {
            pinkAntiBot.onPreTransferCheck(sender, recipient, amount);
        }

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(
            amount,
            "ERC20: 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), "ERC20: 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), "ERC20: burn from the zero address");

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

        _balances[account] = _balances[account].sub(
            amount,
            "ERC20: 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), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: 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 {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint8","name":"decimals_","type":"uint8"},{"internalType":"uint256","name":"totalSupply_","type":"uint256"},{"internalType":"address","name":"pinkAntiBot_","type":"address"},{"internalType":"address","name":"serviceFeeReceiver_","type":"address"},{"internalType":"uint256","name":"serviceFee_","type":"uint256"}],"stateMutability":"payable","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":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"enum TokenType","name":"tokenType","type":"uint8"},{"indexed":false,"internalType":"uint256","name":"version","type":"uint256"}],"name":"TokenCreated","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":[],"name":"VERSION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"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":[],"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":[],"name":"enableAntiBot","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pinkAntiBot","outputs":[{"internalType":"contract IPinkAntiBot","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enable","type":"bool"}],"name":"setEnableAntiBot","outputs":[],"stateMutability":"nonpayable","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","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

6080604052604051620011ec380380620011ec8339810160408190526200002691620004b2565b6200003133620001cd565b8651620000469060039060208a01906200033c565b5085516200005c9060049060208901906200033c565b506005805460ff191660ff87161790556200008a620000836000546001600160a01b031690565b856200021d565b600780546001600160a01b0319166001600160a01b0385169081179091556318e02bd9620000c06000546001600160a01b031690565b6040516001600160e01b031960e084901b1681526001600160a01b039091166004820152602401600060405180830381600087803b1580156200010257600080fd5b505af115801562000117573d6000803e3d6000fd5b50506007805460ff60a01b1916600160a01b17905550309050620001436000546001600160a01b031690565b6001600160a01b03167f56358b41df5fa59f5639228f0930994cbdde383c8a8fd74e06c04e1deebe3562600180604051620001809291906200056b565b60405180910390a36040516001600160a01b0383169082156108fc029083906000818181858888f19350505050158015620001bf573d6000803e3d6000fd5b505050505050505062000610565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6001600160a01b038216620002785760405162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f206164647265737300604482015260640160405180910390fd5b62000294816006546200032760201b620005951790919060201c565b6006556001600160a01b038216600090815260016020908152604090912054620002c99183906200059562000327821b17901c565b6001600160a01b0383166000818152600160205260408082209390935591519091907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef906200031b9085815260200190565b60405180910390a35050565b600062000335828462000598565b9392505050565b8280546200034a90620005bd565b90600052602060002090601f0160209004810192826200036e5760008555620003b9565b82601f106200038957805160ff1916838001178555620003b9565b82800160010185558215620003b9579182015b82811115620003b95782518255916020019190600101906200039c565b50620003c7929150620003cb565b5090565b5b80821115620003c75760008155600101620003cc565b80516001600160a01b0381168114620003fa57600080fd5b919050565b600082601f83011262000410578081fd5b81516001600160401b03808211156200042d576200042d620005fa565b604051601f8301601f19908116603f01168101908282118183101715620004585762000458620005fa565b8160405283815260209250868385880101111562000474578485fd5b8491505b8382101562000497578582018301518183018401529082019062000478565b83821115620004a857848385830101525b9695505050505050565b600080600080600080600060e0888a031215620004cd578283fd5b87516001600160401b0380821115620004e4578485fd5b620004f28b838c01620003ff565b985060208a015191508082111562000508578485fd5b50620005178a828b01620003ff565b965050604088015160ff811681146200052e578384fd5b606089015190955093506200054660808901620003e2565b92506200055660a08901620003e2565b915060c0880151905092959891949750929550565b60408101600884106200058e57634e487b7160e01b600052602160045260246000fd5b9281526020015290565b60008219821115620005b857634e487b7160e01b81526011600452602481fd5b500190565b600181811c90821680620005d257607f821691505b60208210811415620005f457634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052604160045260246000fd5b610bcc80620006206000396000f3fe608060405234801561001057600080fd5b50600436106101165760003560e01c806370a08231116100a2578063a457c2d711610071578063a457c2d714610247578063a9059cbb1461025a578063dd62ed3e1461026d578063f2fde38b146102a6578063ffa1ad74146102b957600080fd5b806370a08231146101fd578063715018a6146102265780638da5cb5b1461022e57806395d89b411461023f57600080fd5b806323b872dd116100e957806323b872dd14610183578063241ec3be14610196578063313ce567146101aa57806339509351146101bf578063407133d2146101d257600080fd5b806306fdde031461011b578063095ea7b31461013957806318160ddd1461015c5780631f46b1c61461016e575b600080fd5b6101236102c1565b6040516101309190610a3c565b60405180910390f35b61014c6101473660046109f3565b610353565b6040519015158152602001610130565b6006545b604051908152602001610130565b61018161017c366004610a1c565b610369565b005b61014c6101913660046109b8565b6103ba565b60075461014c90600160a01b900460ff1681565b60055460405160ff9091168152602001610130565b61014c6101cd3660046109f3565b610423565b6007546101e5906001600160a01b031681565b6040516001600160a01b039091168152602001610130565b61016061020b36600461096c565b6001600160a01b031660009081526001602052604090205490565b610181610459565b6000546001600160a01b03166101e5565b61012361048f565b61014c6102553660046109f3565b61049e565b61014c6102683660046109f3565b6104ed565b61016061027b366004610986565b6001600160a01b03918216600090815260026020908152604080832093909416825291909152205490565b6101816102b436600461096c565b6104fa565b610160600181565b6060600380546102d090610ae8565b80601f01602080910402602001604051908101604052809291908181526020018280546102fc90610ae8565b80156103495780601f1061031e57610100808354040283529160200191610349565b820191906000526020600020905b81548152906001019060200180831161032c57829003601f168201915b5050505050905090565b60006103603384846105a8565b50600192915050565b6000546001600160a01b0316331461039c5760405162461bcd60e51b815260040161039390610a8f565b60405180910390fd5b60078054911515600160a01b0260ff60a01b19909216919091179055565b60006103c78484846106cd565b610419843361041485604051806060016040528060288152602001610b4a602891396001600160a01b038a16600090815260026020908152604080832033845290915290205491906108d4565b6105a8565b5060019392505050565b3360008181526002602090815260408083206001600160a01b038716845290915281205490916103609185906104149086610595565b6000546001600160a01b031633146104835760405162461bcd60e51b815260040161039390610a8f565b61048d6000610900565b565b6060600480546102d090610ae8565b6000610360338461041485604051806060016040528060258152602001610b72602591393360009081526002602090815260408083206001600160a01b038d16845290915290205491906108d4565b60006103603384846106cd565b6000546001600160a01b031633146105245760405162461bcd60e51b815260040161039390610a8f565b6001600160a01b0381166105895760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610393565b61059281610900565b50565b60006105a18284610ac4565b9392505050565b6001600160a01b03831661060a5760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b6064820152608401610393565b6001600160a01b03821661066b5760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b6064820152608401610393565b6001600160a01b0383811660008181526002602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591015b60405180910390a3505050565b6001600160a01b0383166107315760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f206164604482015264647265737360d81b6064820152608401610393565b6001600160a01b0382166107935760405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201526265737360e81b6064820152608401610393565b600754600160a01b900460ff16156108145760075460405163090ec10b60e31b81526001600160a01b03858116600483015284811660248301526044820184905290911690634876085890606401600060405180830381600087803b1580156107fb57600080fd5b505af115801561080f573d6000803e3d6000fd5b505050505b61085181604051806060016040528060268152602001610b24602691396001600160a01b03861660009081526001602052604090205491906108d4565b6001600160a01b0380851660009081526001602052604080822093909355908416815220546108809082610595565b6001600160a01b0380841660008181526001602052604090819020939093559151908516907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef906106c09085815260200190565b600081848411156108f85760405162461bcd60e51b81526004016103939190610a3c565b505050900390565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b80356001600160a01b038116811461096757600080fd5b919050565b60006020828403121561097d578081fd5b6105a182610950565b60008060408385031215610998578081fd5b6109a183610950565b91506109af60208401610950565b90509250929050565b6000806000606084860312156109cc578081fd5b6109d584610950565b92506109e360208501610950565b9150604084013590509250925092565b60008060408385031215610a05578182fd5b610a0e83610950565b946020939093013593505050565b600060208284031215610a2d578081fd5b813580151581146105a1578182fd5b6000602080835283518082850152825b81811015610a6857858101830151858201604001528201610a4c565b81811115610a795783604083870101525b50601f01601f1916929092016040019392505050565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60008219821115610ae357634e487b7160e01b81526011600452602481fd5b500190565b600181811c90821680610afc57607f821691505b60208210811415610b1d57634e487b7160e01b600052602260045260246000fd5b5091905056fe45524332303a207472616e7366657220616d6f756e7420657863656564732062616c616e636545524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e636545524332303a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726fa2646970667358221220a315ed57d3f9b893d48f5e4b53c7434cc9edcf752c48558caa894249076b0dcc64736f6c6343000804003300000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000d3c21bcecceda10000000000000000000000000000008efdb3b642eb2a20607ffe0a56cfeff6a95df0020000000000000000000000004b04213c2774f77e60702880654206b116d0050800000000000000000000000000000000000000000000000002c68af0bb1400000000000000000000000000000000000000000000000000000000000000000003533031000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035330310000000000000000000000000000000000000000000000000000000000

Deployed ByteCode Sourcemap

14152:11056:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15521:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;17808:210;;;;;;:::i;:::-;;:::i;:::-;;;2331:14:1;;2324:22;2306:41;;2294:2;2279:18;17808:210:0;2261:92:1;16620:108:0;16708:12;;16620:108;;;5726:25:1;;;5714:2;5699:18;16620:108:0;5681:76:1;15350:101:0;;;;;;:::i;:::-;;:::i;:::-;;18500:454;;;;;;:::i;:::-;;:::i;14587:25::-;;;;;-1:-1:-1;;;14587:25:0;;;;;;16464:91;16538:9;;16464:91;;16538:9;;;;5904:36:1;;5892:2;5877:18;16464:91:0;5859:87:1;19363:300:0;;;;;;:::i;:::-;;:::i;14549:31::-;;;;;-1:-1:-1;;;;;14549:31:0;;;;;;-1:-1:-1;;;;;1742:32:1;;;1724:51;;1712:2;1697:18;14549:31:0;1679:102:1;16791:177:0;;;;;;:::i;:::-;-1:-1:-1;;;;;16942:18:0;16910:7;16942:18;;;:9;:18;;;;;;;16791:177;5454:94;;;:::i;4803:87::-;4849:7;4876:6;-1:-1:-1;;;;;4876:6:0;4803:87;;15731:95;;;:::i;20166:400::-;;;;;;:::i;:::-;;:::i;17181:216::-;;;;;;:::i;:::-;;:::i;17460:201::-;;;;;;:::i;:::-;-1:-1:-1;;;;;17626:18:0;;;17594:7;17626:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;17460:201;5703:192;;;;;;:::i;:::-;;:::i;14254:35::-;;14288:1;14254:35;;15521:91;15566:13;15599:5;15592:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15521:91;:::o;17808:210::-;17927:4;17949:39;3601:10;17972:7;17981:6;17949:8;:39::i;:::-;-1:-1:-1;18006:4:0;17808:210;;;;:::o;15350:101::-;4849:7;4876:6;-1:-1:-1;;;;;4876:6:0;3601:10;5023:23;5015:68;;;;-1:-1:-1;;;5015:68:0;;;;;;;:::i;:::-;;;;;;;;;15420:13:::1;:23:::0;;;::::1;;-1:-1:-1::0;;;15420:23:0::1;-1:-1:-1::0;;;;15420:23:0;;::::1;::::0;;;::::1;::::0;;15350:101::o;18500:454::-;18640:4;18657:36;18667:6;18675:9;18686:6;18657:9;:36::i;:::-;18704:220;18727:6;3601:10;18775:138;18831:6;18775:138;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18775:19:0;;;;;;:11;:19;;;;;;;;3601:10;18775:33;;;;;;;;;;:37;:138::i;:::-;18704:8;:220::i;:::-;-1:-1:-1;18942:4:0;18500:454;;;;;:::o;19363:300::-;3601:10;19478:4;19572:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;19572:34:0;;;;;;;;;;19478:4;;19500:133;;19550:7;;19572:50;;19611:10;19572:38;:50::i;5454:94::-;4849:7;4876:6;-1:-1:-1;;;;;4876:6:0;3601:10;5023:23;5015:68;;;;-1:-1:-1;;;5015:68:0;;;;;;;:::i;:::-;5519:21:::1;5537:1;5519:9;:21::i;:::-;5454:94::o:0;15731:95::-;15778:13;15811:7;15804:14;;;;;:::i;20166:400::-;20286:4;20308:228;3601:10;20358:7;20380:145;20437:15;20380:145;;;;;;;;;;;;;;;;;3601:10;20380:25;;;;:11;:25;;;;;;;;-1:-1:-1;;;;;20380:34:0;;;;;;;;;;;;:38;:145::i;17181:216::-;17303:4;17325:42;3601:10;17349:9;17360:6;17325:9;:42::i;5703:192::-;4849:7;4876:6;-1:-1:-1;;;;;4876:6:0;3601:10;5023:23;5015:68;;;;-1:-1:-1;;;5015:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;5792:22:0;::::1;5784:73;;;::::0;-1:-1:-1;;;5784:73:0;;3800:2:1;5784:73:0::1;::::0;::::1;3782:21:1::0;3839:2;3819:18;;;3812:30;3878:34;3858:18;;;3851:62;-1:-1:-1;;;3929:18:1;;;3922:36;3975:19;;5784:73:0::1;3772:228:1::0;5784:73:0::1;5868:19;5878:8;5868:9;:19::i;:::-;5703:192:::0;:::o;8889:98::-;8947:7;8974:5;8978:1;8974;:5;:::i;:::-;8967:12;8889:98;-1:-1:-1;;;8889:98:0:o;23667:380::-;-1:-1:-1;;;;;23803:19:0;;23795:68;;;;-1:-1:-1;;;23795:68:0;;5377:2:1;23795:68:0;;;5359:21:1;5416:2;5396:18;;;5389:30;5455:34;5435:18;;;5428:62;-1:-1:-1;;;5506:18:1;;;5499:34;5550:19;;23795:68:0;5349:226:1;23795:68:0;-1:-1:-1;;;;;23882:21:0;;23874:68;;;;-1:-1:-1;;;23874:68:0;;4207:2:1;23874:68:0;;;4189:21:1;4246:2;4226:18;;;4219:30;4285:34;4265:18;;;4258:62;-1:-1:-1;;;4336:18:1;;;4329:32;4378:19;;23874:68:0;4179:224:1;23874:68:0;-1:-1:-1;;;;;23955:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;24007:32;;5726:25:1;;;24007:32:0;;5699:18:1;24007:32:0;;;;;;;;23667:380;;;:::o;21056:725::-;-1:-1:-1;;;;;21196:20:0;;21188:70;;;;-1:-1:-1;;;21188:70:0;;4971:2:1;21188:70:0;;;4953:21:1;5010:2;4990:18;;;4983:30;5049:34;5029:18;;;5022:62;-1:-1:-1;;;5100:18:1;;;5093:35;5145:19;;21188:70:0;4943:227:1;21188:70:0;-1:-1:-1;;;;;21277:23:0;;21269:71;;;;-1:-1:-1;;;21269:71:0;;3396:2:1;21269:71:0;;;3378:21:1;3435:2;3415:18;;;3408:30;3474:34;3454:18;;;3447:62;-1:-1:-1;;;3525:18:1;;;3518:33;3568:19;;21269:71:0;3368:225:1;21269:71:0;21357:13;;-1:-1:-1;;;21357:13:0;;;;21353:103;;;21387:11;;:57;;-1:-1:-1;;;21387:57:0;;-1:-1:-1;;;;;2044:15:1;;;21387:57:0;;;2026:34:1;2096:15;;;2076:18;;;2069:43;2128:18;;;2121:34;;;21387:11:0;;;;:30;;1961:18:1;;21387:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21353:103;21548:108;21584:6;21548:108;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;21548:17:0;;;;;;:9;:17;;;;;;;:108;:21;:108::i;:::-;-1:-1:-1;;;;;21528:17:0;;;;;;;:9;:17;;;;;;:128;;;;21690:20;;;;;;;:32;;21715:6;21690:24;:32::i;:::-;-1:-1:-1;;;;;21667:20:0;;;;;;;:9;:20;;;;;;;:55;;;;21738:35;;;;;;;;;;21766:6;5726:25:1;;5714:2;5699:18;;5681:76;11168:240:0;11288:7;11349:12;11341:6;;;;11333:29;;;;-1:-1:-1;;;11333:29:0;;;;;;;;:::i;:::-;-1:-1:-1;;;11384:5:0;;;11168:240::o;5903:173::-;5959:16;5978:6;;-1:-1:-1;;;;;5995:17:0;;;-1:-1:-1;;;;;;5995:17:0;;;;;;6028:40;;5978:6;;;;;;;6028:40;;5959:16;6028:40;5903:173;;:::o;14::1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:2;;177:1;174;167:12;111:2;63:124;;;:::o;192:196::-;251:6;304:2;292:9;283:7;279:23;275:32;272:2;;;325:6;317;310:22;272:2;353:29;372:9;353:29;:::i;393:270::-;461:6;469;522:2;510:9;501:7;497:23;493:32;490:2;;;543:6;535;528:22;490:2;571:29;590:9;571:29;:::i;:::-;561:39;;619:38;653:2;642:9;638:18;619:38;:::i;:::-;609:48;;480:183;;;;;:::o;668:338::-;745:6;753;761;814:2;802:9;793:7;789:23;785:32;782:2;;;835:6;827;820:22;782:2;863:29;882:9;863:29;:::i;:::-;853:39;;911:38;945:2;934:9;930:18;911:38;:::i;:::-;901:48;;996:2;985:9;981:18;968:32;958:42;;772:234;;;;;:::o;1011:264::-;1079:6;1087;1140:2;1128:9;1119:7;1115:23;1111:32;1108:2;;;1161:6;1153;1146:22;1108:2;1189:29;1208:9;1189:29;:::i;:::-;1179:39;1265:2;1250:18;;;;1237:32;;-1:-1:-1;;;1098:177:1:o;1280:293::-;1336:6;1389:2;1377:9;1368:7;1364:23;1360:32;1357:2;;;1410:6;1402;1395:22;1357:2;1454:9;1441:23;1507:5;1500:13;1493:21;1486:5;1483:32;1473:2;;1534:6;1526;1519:22;2586:603;2698:4;2727:2;2756;2745:9;2738:21;2788:6;2782:13;2831:6;2826:2;2815:9;2811:18;2804:34;2856:4;2869:140;2883:6;2880:1;2877:13;2869:140;;;2978:14;;;2974:23;;2968:30;2944:17;;;2963:2;2940:26;2933:66;2898:10;;2869:140;;;3027:6;3024:1;3021:13;3018:2;;;3097:4;3092:2;3083:6;3072:9;3068:22;3064:31;3057:45;3018:2;-1:-1:-1;3173:2:1;3152:15;-1:-1:-1;;3148:29:1;3133:45;;;;3180:2;3129:54;;2707:482;-1:-1:-1;;;2707:482:1:o;4408:356::-;4610:2;4592:21;;;4629:18;;;4622:30;4688:34;4683:2;4668:18;;4661:62;4755:2;4740:18;;4582:182::o;5951:229::-;5991:3;6022:1;6018:6;6015:1;6012:13;6009:2;;;-1:-1:-1;;;6048:33:1;;6104:4;6101:1;6094:15;6134:4;6055:3;6122:17;6009:2;-1:-1:-1;6165:9:1;;5999:181::o;6185:380::-;6264:1;6260:12;;;;6307;;;6328:2;;6382:4;6374:6;6370:17;6360:27;;6328:2;6435;6427:6;6424:14;6404:18;6401:38;6398:2;;;6481:10;6476:3;6472:20;6469:1;6462:31;6516:4;6513:1;6506:15;6544:4;6541:1;6534:15;6398:2;;6240:325;;;:::o

Swarm Source

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