SUSHI的源码及方案解析一（流动性挖矿部分的解析与克隆）

问答区块链
更新于 2021-02-07 16:53
阅读 2707

我的开发项目是智能设备自治，其中有一个很关键的部分就是，物联网设备之前如何进行有价的信息交换。本文首先对流动性挖矿（SUSHI）进行方案的解析，进而解决token是怎么来的问题。

首先说一下。我的开发项目是智能设备自治，其中有一个很关键的部分就是，物联网设备之前如何进行有价的信息交换。
# 前言
我的思路是这样的，如果把设备按功能分成不同的群体，那么群体内设备与设备之间通过token来完成信息的交互，这里最简单的例子就是基于预言机来完成信息的报价和购买，我们在[《关于预言机nest的源码解析及克隆》](https://learnblockchain.cn/article/2125)里面已经对nest预言机部分的源码和克隆进行了解析，有兴趣的可以看一下。
接下来还有两个非常重要的内容需要解决。第一个是token是怎么来的，另一个是token之间是如何进行交互的。关于token是怎么来的，我们考虑的是模仿SUSHI的流动性挖矿来解决，而token之间是如何交易的，则模仿uniswap来完成。
本文首先对流动性挖矿（SUSHI）进行方案的解析。
特别说明，本文基于的是SUSHI早期的源码，那个时候交易所部分还没出来。 
# 流动性挖矿（SUSHI）概述
流动性挖矿（SUSHI）很多人都知道开发者一个月赚了几千万的事情。我简单的从技术角度说一下。
SUSHI模仿YAM进行流动性挖矿，但创造性的用uniswap的令牌来完成。
主要的功能分四部分：
1.管理员建立uniswap令牌池
2.用户将自己的uniswap令牌（LP）存入令牌池
3.根据不同的令牌池权重和不同数量的用户LP存入币实时计算该用户应该获得的SUSHI
4.用户通过取功能获得SUSHI，以及存入的uniswap令牌。
5.将用户的LP令牌转移到SUSHI的去中心化交易所。
所以说核心函数其实就那么几个：
1.SUSHI的挖矿接口函数；
2.建立令牌池及修改令牌池（管理员权限）
3.用户存、取LP；
4.用户查看及取SUSHI；
5.将用户的LP令牌转移到SUSHI的去中心化交易所
# Token.sol
这个里面erc20部分大部分内容来自于openzeppelin，而// SushiToken with Governance.部分主要来自于yam。
大家理解为一个简单的可以挖矿的erc20币即可。
这里面的关键代码就一句：
```
contract PITAYAToken is ERC20("PITAYAswap", "PITAYA"), Ownable {
```
这里的PITAYAToken是我自己改的名字。后面的PITAYAswap是项目的名字，PITAYA是货币符号。
也就是说，用这段代码克隆的同学，就改这三个地方即可。
# chef.sol
这个里面没有什么要改的，但要理解。
这个里面看似合约很多，但其实主要关注的只有一个，MasterChef。
我们对照着前言里面提到的几个函数说明一下。
```
contract MasterChef is Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

// Info of each user.
    struct UserInfo {
        uint256 amount;     // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
    }

// Info of each pool.
//每一个矿池的数据结构
    struct PoolInfo {
        IERC20 lpToken;           // Address of LP token contract.uniswap的令牌地址
        uint256 allocPoint;       // How many allocation points assigned to this pool. SUSHIs to distribute per block.
        uint256 lastRewardBlock;  // Last block number that SUSHIs distribution occurs.
        uint256 accSushiPerShare; // Accumulated SUSHIs per share, times 1e12. See below.sushi的配额
    }

// The SUSHI TOKEN!
//sushi的token地址
    SushiToken public sushi;
    // Dev address.
//管理员地址
    address public devaddr;
    // Block number when bonus SUSHI period ends.
    uint256 public bonusEndBlock;
    // SUSHI tokens created per block.
    uint256 public sushiPerBlock;
    // Bonus muliplier for early sushi makers.
    uint256 public constant BONUS_MULTIPLIER = 2;
    // The migrator contract. It has a lot of power. Can only be set through governance (owner).
//迁移地址，当sushi的去中心化交易所完成后进行的迁移
    IMigratorChef public migrator;

// Info of each pool.
//矿池注册
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
//用户令牌
    mapping (uint256 => mapping (address => UserInfo)) public userInfo;
    // Total allocation poitns. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block number when SUSHI mining starts.
    uint256 public startBlock;

event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);

constructor(
        SushiToken _sushi,
        address _devaddr,
        uint256 _sushiPerBlock,
        uint256 _startBlock,
        uint256 _bonusEndBlock
    ) public {
        sushi = _sushi;
        devaddr = _devaddr;
        sushiPerBlock = _sushiPerBlock;
        bonusEndBlock = _bonusEndBlock;
        startBlock = _startBlock;
    }

function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

// Add a new lp to the pool. Can only be called by the owner.
    // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
//增加矿池，管理员权限
    function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            allocPoint: _allocPoint,
            lastRewardBlock: lastRewardBlock,
            accSushiPerShare: 0
        }));
    }

// Update the given pool's SUSHI allocation point. Can only be called by the owner.
//设置矿池参数，管理员权限
    function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
    }

// Set the migrator contract. Can only be called by the owner.
//设置迁移地址，管理员权限
    function setMigrator(IMigratorChef _migrator) public onlyOwner {
        migrator = _migrator;
    }

// Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good.
//进行迁移
    function migrate(uint256 _pid) public {
        require(address(migrator) != address(0), "migrate: no migrator");
        PoolInfo storage pool = poolInfo[_pid];
        IERC20 lpToken = pool.lpToken;
        uint256 bal = lpToken.balanceOf(address(this));
        lpToken.safeApprove(address(migrator), bal);
        IERC20 newLpToken = migrator.migrate(lpToken);
        require(bal == newLpToken.balanceOf(address(this)), "migrate: bad");
        pool.lpToken = newLpToken;
    }

// Return reward multiplier over the given _from to _to block.
//获得参数信息
    function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
        if (_to <= bonusEndBlock) {
            return _to.sub(_from).mul(BONUS_MULTIPLIER);
        } else if (_from >= bonusEndBlock) {
            return _to.sub(_from);
        } else {
            return bonusEndBlock.sub(_from).mul(BONUS_MULTIPLIER).add(
                _to.sub(bonusEndBlock)
            );
        }
    }

// View function to see pending SUSHIs on frontend.
//获得矿池信息
    function pendingSushi(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accSushiPerShare = pool.accSushiPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
            uint256 sushiReward = multiplier.mul(sushiPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
            accSushiPerShare = accSushiPerShare.add(sushiReward.mul(1e12).div(lpSupply));
        }
        return user.amount.mul(accSushiPerShare).div(1e12).sub(user.rewardDebt);
    }

// Update reward vairables for all pools. Be careful of gas spending!
//更新所有矿池信息
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

// Update reward variables of the given pool to be up-to-date.
//更新某个矿池信息
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 sushiReward = multiplier.mul(sushiPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
        sushi.mint(devaddr, sushiReward.div(20));
        sushi.mint(address(this), sushiReward);
        pool.accSushiPerShare = pool.accSushiPerShare.add(sushiReward.mul(1e12).div(lpSupply));
        pool.lastRewardBlock = block.number;
    }

// Deposit LP tokens to MasterChef for SUSHI allocation.
//存入LP
    function deposit(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accSushiPerShare).div(1e12).sub(user.rewardDebt);
            safeSushiTransfer(msg.sender, pending);
        }
        pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
        user.amount = user.amount.add(_amount);
        user.rewardDebt = user.amount.mul(pool.accSushiPerShare).div(1e12);
        emit Deposit(msg.sender, _pid, _amount);
    }

// Withdraw LP tokens from MasterChef.
//撤出令牌
    function withdraw(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        uint256 pending = user.amount.mul(pool.accSushiPerShare).div(1e12).sub(user.rewardDebt);
        safeSushiTransfer(msg.sender, pending);
        user.amount = user.amount.sub(_amount);
        user.rewardDebt = user.amount.mul(pool.accSushiPerShare).div(1e12);
        pool.lpToken.safeTransfer(address(msg.sender), _amount);
        emit Withdraw(msg.sender, _pid, _amount);
    }

// Withdraw without caring about rewards. EMERGENCY ONLY.
//无条件撤出令牌，用于矿池出现严重问题的时候
    function emergencyWithdraw(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        pool.lpToken.safeTransfer(address(msg.sender), user.amount);
        emit EmergencyWithdraw(msg.sender, _pid, user.amount);
        user.amount = 0;
        user.rewardDebt = 0;
    }

// Safe sushi transfer function, just in case if rounding error causes pool to not have enough SUSHIs.
//安全转移sushi
    function safeSushiTransfer(address _to, uint256 _amount) internal {
        uint256 sushiBal = sushi.balanceOf(address(this));
        if (_amount > sushiBal) {
            sushi.transfer(_to, sushiBal);
        } else {
            sushi.transfer(_to, _amount);
        }
    }

// Update dev address by the previous dev.
//设置管理员信息
    function dev(address _devaddr) public {
        require(msg.sender == devaddr, "dev: wut?");
        devaddr = _devaddr;
    }
}
```
# 重新编译和布置sushi的智能合约
说明一下，这部分的内容当时笔记做的不太好，大家当参考即可。
另外，由于我当时做相关开发的时候，sushi网站的源码并没有开源，所以用的是banana的网站源码。也就是说，**sushi智能合约源码+banana网站源码**
## 一 Token的安装
Token的安装比较简单
记得在最后面把名字改一下就行。（建议用yuno的，对比banana），用的是banana的。
contract PITAYAToken is ERC20("PITAYAswap","PITAYA"), Ownable {o:p
修改为Pitaya PITAYAToken （火龙果）
Token：0x9527bf8828a991537558f33d291271b206376412o:p
## 二 chief
chief则需要修改很多的内容，而且是一次性完成的。（用的banana）
A 需要修改这个BONUS_MULTIPLIER，变为2（表示最开始的发现是之后的2倍，sushi默认是10倍）
B 一次性需要完成的是下面几个
SushiToken地址，
devaddr地址（治理员，建议跟ower不能是一个，0x404331C629D53B500Ac06b596eaF533423A413a7）
sushiPerBlock（每块创建的寿司代币数量，40暂定，输入40000000000000000000）
bonusEndBlock（块结束时间，区块号，在这个后面就开始变少了，我们把这个时间设定为3个月左右10846048+600000=11446048）
也就是说，慢了10%。也就是说，真正持续的时间大概是三个月零3天。
startBlock（开始块的时间，开始才出口，预计设计为后天，10846048，12号九点）
Ps:devaddr的作用主要是用来分成的，每挖一次都要给额外的10%，也可以用来提前偷摸挖矿，但咱们不干这个。
Chief：0x6a6db5fe904366023a0c0a9e2cea29ed8226b415o:p
## 三 建立后需要完成的两件事情
建立后需要完成的两件事情，注意对比yuno和banana。
第一个是Token合约的转换权限（transferownership），换成chief合约地址。
第二个是chef合约里面建立pool0和1（add函数，就是y.js里面的前几个列表，根据banana来就行，区别是改banana的第一个），剩余的慢慢来。Set函数可以修改对应的值。
Pool0：2，0xb23b4b10099690ff7e9ebe16d94c25124f9c4d07
true
# 重新编译和运行前端
因为我写笔记那会，sushi的前端还没有开源所以用的是yuno和banano的前端。
## 一 修改
a var chefAddress = "0x6a6db5fe904366023a0c0a9e2cea29ed8226b415";//改
b var tokenAddress = "0x9527bf8828a991537558f33d291271b206376412";//改o:p
c ["0xb23b4b10099690ff7e9ebe16d94c25124f9c4d07",
"UNISWAP NEST/ETH", "https://uniswap.info/pair/0xb23b4b10099690ff7e9ebe16d94c25124f9c4d07",
2, 0, 0],//改两个
*function getUniswapPrice() {
*    var ctx0 =
new web3.eth.Contract(uniswapABI, pools[0][0]);
*    var ctx1 =
new web3.eth.Contract(uniswapABI, uni1);
    var ctx2 = new
web3.eth.Contract(uniswapABI, "0xb23b4b10099690ff7e9ebe16d94c25124f9c4d07");//改一个。
d
http-server
## 二 第一次使用
进入到so部分，然后第一次设置会显示需要授权。
授权后就可以存入，建议存入少量。
存入后刷新页面，几秒钟到几分钟在staked token就可以出现了。
然后再取出。几次就ok了。
## 三 启动测试与运行
http-serve
## 四 正常运行后的第三阶段
等稳定了后，做两件事情。（暂时不做，kimchi做了这个，yuno，hotdog都没有做这部分）.特别说明，所谓的稳定是在测试网测试过，搞清楚executeTransaction怎么用。
A 建立timelock，时间设定为delay（7天），管理员admin为我自己。
B 将chef合约的owner更改为timelock地址（这里还有很多问题需要解决起码还没搞清楚executeTransaction怎么用）
C等完全都完事了，要部署GovernorAlpha，将timelock与挂接GovernorAlpha。就正式开启自治。
## 五自治后运行的事情
SushiSwap（SUSHI）发起流动性迁移提案＃QmXm9T7，投票期限为 1 天。Timelock的管理者（本人）将部署所有必需的智能合约 Migrator、SushiSwapFactory（UniswapFactory）、SushiMaker 以及 SushiBar，并设置「setMigrator」功能来调用时间锁智能合约，将在 48 小时后完成迁移。一旦迁移完成，SushiSwap 将会借助自有的 AMM，把收取的交易费用的 1/6 分配给 SUSHI 代币持有者。
# 注意事项
## 一 分红从哪里来的。
按照sushi的逻辑就是，用sushi进行分红，可以分25%，但这个东西是从后面的交易所得来的。而后期进行转换的时候，则需要最开始的一段时间过去才行。
## 二 可能存在的风险
慢雾创始人余弦发文分析，SushiSwap 仿盘项目 KIMCHI （泡菜） 项目方确实拥有任意铸币的权限，只是如果项目方要任意铸币，至少需要等待2天时间。对接泡菜的平台可以观测泡菜厨师的devaddr地址是否变更为泡菜厨师的当前owner地址。
## 三 Migrator.sol
就是从旧的工厂合约迁移到新的工厂合约里面去，里面有一个时间点，少于这个时间点是不可以的。
## 四 部分源码说明
Solidity中当签名不匹配任何的函数方法时，将会触发回退函数。比如，当你调用address.call(bytes4(bytes32(sha3("thisShouldBeAFunction(uint,bytes32)"))),
1, "test")时，EVM实际尝试调用地址中的thisShouldBeAFunction()，当这个函数不存在，会触发fallback函数。
call函数转账的使用方法是：地址.call.value(转账金额)()o:p
## 五 令牌分红的本质
Uniswap 中的 LP Token，对于每一个交易对，Uniswap 合约会给流动性提供者发行相应的 LP Token，LP Token 是日后流动性提供者赎回本金的凭证，当交易产生手续费时，手续费会自动打到
Pool 中，此时如果价格不变的话，相当于单位 LP Token 所能赎回的本金变多了，通过这种方法完成分红。
## 六 布置合约的说明
A 布置UniswapV2Factory.sol合约，其中那个地址就是我自己的地址（管理者）
B 布置migrator（千万注意没有那个s），将UniswapV2Factory地址传输过去。还有一个旧地址，参考sushiswap里面的migraotr的oldfactory。布置将chef的owner转为timelock
C Timelock.sol、migrator和GovernorAlpha.sol是一体的，用于治理。o:p
D MasterChef里面有一个migrate合约，如果恶意放到不同的合约地址则有可能转走所有的币（在MasterChef里面的），Migrator合约的主要功能就是将uniswap里面的币转换为自己的池子里面并发新的币。这个里面需要注意的是，迁移的时间是需要大于一个值（这个值可以设计为很久），这样当set的时候，就可以由owner运行，而owner可以设计为可以换为另外一个，到时候则切换为GovernorAlpha投票进行即可
## 七 部分解析
1. timelock，governoralpha，migrator不着急做，合一起就是用治理委员会完成迁移。但现在还没有启用。
2. MasterChef的owner给了timelock，Timelock的管理员（admin）可以设置一次，之后就锁死了，目前设置为某一个人；pendingAdmin目前还没有设置（为0）
3. 目前最主要的方案就是masterchef里面的迁移，这个需要在一个规定时间后（比如是3个月，在migrator的初始化里面设置），由masterchef的owner进行。因为这种权限太危险，所以要把这个owner权限给timelock，同时设定timelock的admin为自己（pendingAdmin待定）。
4.特别提示：
等正式运行稳定了了，到了一定的规模，就将GovernorAlpha的权限转给timelock。在此之前一定要进行足够的风险提示。
# 总结
我的开发项目是智能设备自治，其中有一个很关键的部分就是，物联网设备之前如何进行有价的信息交换。本文首先对流动性挖矿（SUSHI）进行方案的解析，进而解决token是怎么来的问题。
关于如何具体的怎么增加矿池修改矿池的流程，当时笔记就没再记录详细，就没写。而且相关的文件都是半年前写的，很多内容未做校对，错误很多，因此在这里，大家仅做参考。

首先说一下。我的开发项目是智能设备自治，其中有一个很关键的部分就是，物联网设备之前如何进行有价的信息交换。

前言

我的思路是这样的，如果把设备按功能分成不同的群体，那么群体内设备与设备之间通过token来完成信息的交互，这里最简单的例子就是基于预言机来完成信息的报价和购买，我们在《关于预言机nest的源码解析及克隆》里面已经对nest预言机部分的源码和克隆进行了解析，有兴趣的可以看一下。接下来还有两个非常重要的内容需要解决。第一个是token是怎么来的，另一个是token之间是如何进行交互的。关于token是怎么来的，我们考虑的是模仿SUSHI的流动性挖矿来解决，而token之间是如何交易的，则模仿uniswap来完成。本文首先对流动性挖矿（SUSHI）进行方案的解析。特别说明，本文基于的是SUSHI早期的源码，那个时候交易所部分还没出来。

流动性挖矿（SUSHI）概述

流动性挖矿（SUSHI）很多人都知道开发者一个月赚了几千万的事情。我简单的从技术角度说一下。 SUSHI模仿YAM进行流动性挖矿，但创造性的用uniswap的令牌来完成。主要的功能分四部分： 1.管理员建立uniswap令牌池 2.用户将自己的uniswap令牌（LP）存入令牌池 3.根据不同的令牌池权重和不同数量的用户LP存入币实时计算该用户应该获得的SUSHI 4.用户通过取功能获得SUSHI，以及存入的uniswap令牌。 5.将用户的LP令牌转移到SUSHI的去中心化交易所。所以说核心函数其实就那么几个： 1.SUSHI的挖矿接口函数； 2.建立令牌池及修改令牌池（管理员权限） 3.用户存、取LP； 4.用户查看及取SUSHI； 5.将用户的LP令牌转移到SUSHI的去中心化交易所

Token.sol

这个里面erc20部分大部分内容来自于openzeppelin，而// SushiToken with Governance.部分主要来自于yam。大家理解为一个简单的可以挖矿的erc20币即可。这里面的关键代码就一句：

contract PITAYAToken is ERC20("PITAYAswap", "PITAYA"), Ownable {

这里的PITAYAToken是我自己改的名字。后面的PITAYAswap是项目的名字，PITAYA是货币符号。也就是说，用这段代码克隆的同学，就改这三个地方即可。

chef.sol

这个里面没有什么要改的，但要理解。这个里面看似合约很多，但其实主要关注的只有一个，MasterChef。我们对照着前言里面提到的几个函数说明一下。

contract MasterChef is Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // Info of each user.
    struct UserInfo {
        uint256 amount;     // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
    }

    // Info of each pool.
//每一个矿池的数据结构
    struct PoolInfo {
        IERC20 lpToken;           // Address of LP token contract.uniswap的令牌地址
        uint256 allocPoint;       // How many allocation points assigned to this pool. SUSHIs to distribute per block.
        uint256 lastRewardBlock;  // Last block number that SUSHIs distribution occurs.
        uint256 accSushiPerShare; // Accumulated SUSHIs per share, times 1e12. See below.sushi的配额
    }

    // The SUSHI TOKEN!
//sushi的token地址
    SushiToken public sushi;
    // Dev address.
//管理员地址
    address public devaddr;
    // Block number when bonus SUSHI period ends.
    uint256 public bonusEndBlock;
    // SUSHI tokens created per block.
    uint256 public sushiPerBlock;
    // Bonus muliplier for early sushi makers.
    uint256 public constant BONUS_MULTIPLIER = 2;
    // The migrator contract. It has a lot of power. Can only be set through governance (owner).
//迁移地址，当sushi的去中心化交易所完成后进行的迁移
    IMigratorChef public migrator;

    // Info of each pool.
//矿池注册
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
//用户令牌
    mapping (uint256 => mapping (address => UserInfo)) public userInfo;
    // Total allocation poitns. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block number when SUSHI mining starts.
    uint256 public startBlock;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);

    constructor(
        SushiToken _sushi,
        address _devaddr,
        uint256 _sushiPerBlock,
        uint256 _startBlock,
        uint256 _bonusEndBlock
    ) public {
        sushi = _sushi;
        devaddr = _devaddr;
        sushiPerBlock = _sushiPerBlock;
        bonusEndBlock = _bonusEndBlock;
        startBlock = _startBlock;
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    // Add a new lp to the pool. Can only be called by the owner.
    // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
//增加矿池，管理员权限
    function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            allocPoint: _allocPoint,
            lastRewardBlock: lastRewardBlock,
            accSushiPerShare: 0
        }));
    }

    // Update the given pool's SUSHI allocation point. Can only be called by the owner.
//设置矿池参数，管理员权限
    function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
    }

    // Set the migrator contract. Can only be called by the owner.
//设置迁移地址，管理员权限
    function setMigrator(IMigratorChef _migrator) public onlyOwner {
        migrator = _migrator;
    }

    // Migrate lp token to another lp contract. Can be called by anyone. We trust that migrator contract is good.
//进行迁移
    function migrate(uint256 _pid) public {
        require(address(migrator) != address(0), "migrate: no migrator");
        PoolInfo storage pool = poolInfo[_pid];
        IERC20 lpToken = pool.lpToken;
        uint256 bal = lpToken.balanceOf(address(this));
        lpToken.safeApprove(address(migrator), bal);
        IERC20 newLpToken = migrator.migrate(lpToken);
        require(bal == newLpToken.balanceOf(address(this)), "migrate: bad");
        pool.lpToken = newLpToken;
    }

    // Return reward multiplier over the given _from to _to block.
//获得参数信息
    function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
        if (_to &lt;= bonusEndBlock) {
            return _to.sub(_from).mul(BONUS_MULTIPLIER);
        } else if (_from >= bonusEndBlock) {
            return _to.sub(_from);
        } else {
            return bonusEndBlock.sub(_from).mul(BONUS_MULTIPLIER).add(
                _to.sub(bonusEndBlock)
            );
        }
    }

    // View function to see pending SUSHIs on frontend.
//获得矿池信息
    function pendingSushi(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accSushiPerShare = pool.accSushiPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
            uint256 sushiReward = multiplier.mul(sushiPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
            accSushiPerShare = accSushiPerShare.add(sushiReward.mul(1e12).div(lpSupply));
        }
        return user.amount.mul(accSushiPerShare).div(1e12).sub(user.rewardDebt);
    }

    // Update reward vairables for all pools. Be careful of gas spending!
//更新所有矿池信息
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid &lt; length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
//更新某个矿池信息
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number &lt;= pool.lastRewardBlock) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 sushiReward = multiplier.mul(sushiPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
        sushi.mint(devaddr, sushiReward.div(20));
        sushi.mint(address(this), sushiReward);
        pool.accSushiPerShare = pool.accSushiPerShare.add(sushiReward.mul(1e12).div(lpSupply));
        pool.lastRewardBlock = block.number;
    }

    // Deposit LP tokens to MasterChef for SUSHI allocation.
//存入LP
    function deposit(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accSushiPerShare).div(1e12).sub(user.rewardDebt);
            safeSushiTransfer(msg.sender, pending);
        }
        pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
        user.amount = user.amount.add(_amount);
        user.rewardDebt = user.amount.mul(pool.accSushiPerShare).div(1e12);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw LP tokens from MasterChef.
//撤出令牌
    function withdraw(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        uint256 pending = user.amount.mul(pool.accSushiPerShare).div(1e12).sub(user.rewardDebt);
        safeSushiTransfer(msg.sender, pending);
        user.amount = user.amount.sub(_amount);
        user.rewardDebt = user.amount.mul(pool.accSushiPerShare).div(1e12);
        pool.lpToken.safeTransfer(address(msg.sender), _amount);
        emit Withdraw(msg.sender, _pid, _amount);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
//无条件撤出令牌，用于矿池出现严重问题的时候
    function emergencyWithdraw(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        pool.lpToken.safeTransfer(address(msg.sender), user.amount);
        emit EmergencyWithdraw(msg.sender, _pid, user.amount);
        user.amount = 0;
        user.rewardDebt = 0;
    }

    // Safe sushi transfer function, just in case if rounding error causes pool to not have enough SUSHIs.
//安全转移sushi
    function safeSushiTransfer(address _to, uint256 _amount) internal {
        uint256 sushiBal = sushi.balanceOf(address(this));
        if (_amount > sushiBal) {
            sushi.transfer(_to, sushiBal);
        } else {
            sushi.transfer(_to, _amount);
        }
    }

    // Update dev address by the previous dev.
//设置管理员信息
    function dev(address _devaddr) public {
        require(msg.sender == devaddr, "dev: wut?");
        devaddr = _devaddr;
    }
}

重新编译和布置sushi的智能合约

说明一下，这部分的内容当时笔记做的不太好，大家当参考即可。另外，由于我当时做相关开发的时候，sushi网站的源码并没有开源，所以用的是banana的网站源码。也就是说，sushi智能合约源码+banana网站源码

一 Token的安装

Token的安装比较简单记得在最后面把名字改一下就行。（建议用yuno的，对比banana），用的是banana的。 contract PITAYAToken is ERC20("PITAYAswap","PITAYA"), Ownable {o:p 修改为Pitaya PITAYAToken （火龙果） Token：0x9527bf8828a991537558f33d291271b206376412o:p

二 chief

chief则需要修改很多的内容，而且是一次性完成的。（用的banana） A 需要修改这个BONUS_MULTIPLIER，变为2（表示最开始的发现是之后的2倍，sushi默认是10倍） B 一次性需要完成的是下面几个 SushiToken地址， devaddr地址（治理员，建议跟ower不能是一个，0x404331C629D53B500Ac06b596eaF533423A413a7） sushiPerBlock（每块创建的寿司代币数量，40暂定，输入40000000000000000000） bonusEndBlock（块结束时间，区块号，在这个后面就开始变少了，我们把这个时间设定为3个月左右10846048+600000=11446048）也就是说，慢了10%。也就是说，真正持续的时间大概是三个月零3天。 startBlock（开始块的时间，开始才出口，预计设计为后天，10846048，12号九点） Ps:devaddr的作用主要是用来分成的，每挖一次都要给额外的10%，也可以用来提前偷摸挖矿，但咱们不干这个。 Chief：0x6a6db5fe904366023a0c0a9e2cea29ed8226b415o:p

三建立后需要完成的两件事情

建立后需要完成的两件事情，注意对比yuno和banana。第一个是Token合约的转换权限（transferownership），换成chief合约地址。第二个是chef合约里面建立pool0和1（add函数，就是y.js里面的前几个列表，根据banana来就行，区别是改banana的第一个），剩余的慢慢来。Set函数可以修改对应的值。 Pool0：2，0xb23b4b10099690ff7e9ebe16d94c25124f9c4d07 true

重新编译和运行前端

因为我写笔记那会，sushi的前端还没有开源所以用的是yuno和banano的前端。

一修改

a var chefAddress = "0x6a6db5fe904366023a0c0a9e2cea29ed8226b415";//改 b var tokenAddress = "0x9527bf8828a991537558f33d291271b206376412";//改o:p c ["0xb23b4b10099690ff7e9ebe16d94c25124f9c4d07", "UNISWAP NEST/ETH", "https://uniswap.info/pair/0xb23b4b10099690ff7e9ebe16d94c25124f9c4d07", 2, 0, 0],//改两个 *function getUniswapPrice() {

var ctx0 = new web3.eth.Contract(uniswapABI, pools[0][0]);
var ctx1 = new web3.eth.Contract(uniswapABI, uni1); var ctx2 = new web3.eth.Contract(uniswapABI, "0xb23b4b10099690ff7e9ebe16d94c25124f9c4d07");//改一个。 d http-server
二第一次使用

进入到so部分，然后第一次设置会显示需要授权。授权后就可以存入，建议存入少量。存入后刷新页面，几秒钟到几分钟在staked token就可以出现了。然后再取出。几次就ok了。

三启动测试与运行

http-serve

四正常运行后的第三阶段

等稳定了后，做两件事情。（暂时不做，kimchi做了这个，yuno，hotdog都没有做这部分）.特别说明，所谓的稳定是在测试网测试过，搞清楚executeTransaction怎么用。 A 建立timelock，时间设定为delay（7天），管理员admin为我自己。 B 将chef合约的owner更改为timelock地址（这里还有很多问题需要解决起码还没搞清楚executeTransaction怎么用） C等完全都完事了，要部署GovernorAlpha，将timelock与挂接GovernorAlpha。就正式开启自治。

五自治后运行的事情

SushiSwap（SUSHI）发起流动性迁移提案＃QmXm9T7，投票期限为 1 天。Timelock的管理者（本人）将部署所有必需的智能合约 Migrator、SushiSwapFactory（UniswapFactory）、SushiMaker 以及 SushiBar，并设置「setMigrator」功能来调用时间锁智能合约，将在 48 小时后完成迁移。一旦迁移完成，SushiSwap 将会借助自有的 AMM，把收取的交易费用的 1/6 分配给 SUSHI 代币持有者。

注意事项

一分红从哪里来的。

按照sushi的逻辑就是，用sushi进行分红，可以分25%，但这个东西是从后面的交易所得来的。而后期进行转换的时候，则需要最开始的一段时间过去才行。

二可能存在的风险

慢雾创始人余弦发文分析，SushiSwap 仿盘项目 KIMCHI （泡菜）项目方确实拥有任意铸币的权限，只是如果项目方要任意铸币，至少需要等待2天时间。对接泡菜的平台可以观测泡菜厨师的devaddr地址是否变更为泡菜厨师的当前owner地址。

三 Migrator.sol

就是从旧的工厂合约迁移到新的工厂合约里面去，里面有一个时间点，少于这个时间点是不可以的。

四部分源码说明

Solidity中当签名不匹配任何的函数方法时，将会触发回退函数。比如，当你调用address.call(bytes4(bytes32(sha3("thisShouldBeAFunction(uint,bytes32)"))), 1, "test")时，EVM实际尝试调用地址中的thisShouldBeAFunction()，当这个函数不存在，会触发fallback函数。 call函数转账的使用方法是：地址.call.value(转账金额)()o:p

五令牌分红的本质

Uniswap 中的 LP Token，对于每一个交易对，Uniswap 合约会给流动性提供者发行相应的 LP Token，LP Token 是日后流动性提供者赎回本金的凭证，当交易产生手续费时，手续费会自动打到 Pool 中，此时如果价格不变的话，相当于单位 LP Token 所能赎回的本金变多了，通过这种方法完成分红。

六布置合约的说明

A 布置UniswapV2Factory.sol合约，其中那个地址就是我自己的地址（管理者） B 布置migrator（千万注意没有那个s），将UniswapV2Factory地址传输过去。还有一个旧地址，参考sushiswap里面的migraotr的oldfactory。布置将chef的owner转为timelock C Timelock.sol、migrator和GovernorAlpha.sol是一体的，用于治理。o:p D MasterChef里面有一个migrate合约，如果恶意放到不同的合约地址则有可能转走所有的币（在MasterChef里面的），Migrator合约的主要功能就是将uniswap里面的币转换为自己的池子里面并发新的币。这个里面需要注意的是，迁移的时间是需要大于一个值（这个值可以设计为很久），这样当set的时候，就可以由owner运行，而owner可以设计为可以换为另外一个，到时候则切换为GovernorAlpha投票进行即可

七部分解析
1. timelock，governoralpha，migrator不着急做，合一起就是用治理委员会完成迁移。但现在还没有启用。
2. MasterChef的owner给了timelock，Timelock的管理员（admin）可以设置一次，之后就锁死了，目前设置为某一个人；pendingAdmin目前还没有设置（为0）
3. 目前最主要的方案就是masterchef里面的迁移，这个需要在一个规定时间后（比如是3个月，在migrator的初始化里面设置），由masterchef的owner进行。因为这种权限太危险，所以要把这个owner权限给timelock，同时设定timelock的admin为自己（pendingAdmin待定）。 4.特别提示：等正式运行稳定了了，到了一定的规模，就将GovernorAlpha的权限转给timelock。在此之前一定要进行足够的风险提示。
  总结
  
  我的开发项目是智能设备自治，其中有一个很关键的部分就是，物联网设备之前如何进行有价的信息交换。本文首先对流动性挖矿（SUSHI）进行方案的解析，进而解决token是怎么来的问题。关于如何具体的怎么增加矿池修改矿池的流程，当时笔记就没再记录详细，就没写。而且相关的文件都是半年前写的，很多内容未做校对，错误很多，因此在这里，大家仅做参考。

学分: 98
分类: Uniswap
标签: 流动性挖矿智能合约

本文参与登链社区写作激励计划，好文好收益，欢迎正在阅读的你也加入。

SUSHI的源码及方案解析一（流动性挖矿部分的解析与克隆）

前言

流动性挖矿（SUSHI）概述

Token.sol

chef.sol

重新编译和布置sushi的智能合约

一 Token的安装

二 chief

三建立后需要完成的两件事情

重新编译和运行前端

一修改

二第一次使用

三启动测试与运行

四正常运行后的第三阶段

五自治后运行的事情

注意事项

一分红从哪里来的。

二可能存在的风险

三 Migrator.sol

四部分源码说明

五令牌分红的本质

六布置合约的说明

七部分解析

总结

0 条评论

文章目录

SUSHI的源码及方案解析一（流动性挖矿部分的解析与克隆）

前言

流动性挖矿（SUSHI）概述

Token.sol

chef.sol

重新编译和布置sushi的智能合约

一 Token的安装

二 chief

三 建立后需要完成的两件事情

重新编译和运行前端

一 修改

二 第一次使用

三 启动测试与运行

四 正常运行后的第三阶段

五自治后运行的事情

注意事项

一 分红从哪里来的。

二 可能存在的风险

三 Migrator.sol

四 部分源码说明

五 令牌分红的本质

六 布置合约的说明

七 部分解析

总结

0 条评论

文章目录

三建立后需要完成的两件事情

一修改

二第一次使用

三启动测试与运行

四正常运行后的第三阶段

一分红从哪里来的。

二可能存在的风险

四部分源码说明

五令牌分红的本质

六布置合约的说明

七部分解析